mtg_card_maker 0.1.0

data/lib/mtg_card_maker/svg_gradient_service.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module MtgCardMaker
+  # Simplified gradient definitions for SVG cards
+  # Removes complex abstraction in favor of direct gradient creation
+  class SvgGradientService # rubocop:disable Metrics/ClassLength
+    class << self
+      # Defines all gradients needed for a color scheme
+      def define_all_gradients(svg, color_scheme = DEFAULT_COLOR_SCHEME)
+        svg.defs do
+          define_standard_gradients(svg, color_scheme)
+          define_metallic_gradients(svg, color_scheme) if metallic_properties?(color_scheme)
+        end
+      end
+
+      # Get gradient ID for card gradient
+      def card_gradient_id(color_scheme)
+        "#{color_scheme.scheme_name}_card_gradient"
+      end
+
+      # Get gradient ID for frame gradient
+      def frame_gradient_id(color_scheme)
+        "#{color_scheme.scheme_name}_frame_gradient"
+      end
+
+      # Get gradient ID for name gradient
+      def name_gradient_id(color_scheme)
+        "#{color_scheme.scheme_name}_name_gradient"
+      end
+
+      # Get gradient ID for description gradient
+      def description_gradient_id(color_scheme)
+        "#{color_scheme.scheme_name}_description_gradient"
+      end
+
+      # Get gradient ID for metallic highlight gradient
+      def metallic_highlight_gradient_id(color_scheme)
+        "#{color_scheme.scheme_name}_metallic_highlight_gradient"
+      end
+
+      # Get gradient ID for metallic shadow gradient
+      def metallic_shadow_gradient_id(color_scheme)
+        "#{color_scheme.scheme_name}_metallic_shadow_gradient"
+      end
+
+      # Get pattern ID for metallic texture
+      def metallic_pattern_id(color_scheme)
+        "#{color_scheme.scheme_name}_metallic_pattern"
+      end
+
+      # Check if color scheme has metallic properties
+      def metallic_properties?(color_scheme)
+        [:gold, :colorless].include?(color_scheme.scheme_name)
+      end
+
+      def define_standard_gradients(svg, color_scheme)
+        scheme_name = color_scheme.scheme_name
+
+        define_card_gradient(svg, color_scheme, scheme_name)
+        define_frame_gradient(svg, color_scheme, scheme_name)
+        define_name_gradient(svg, color_scheme, scheme_name)
+        define_description_gradient(svg, color_scheme, scheme_name)
+      end
+
+      def define_card_gradient(svg, color_scheme, scheme_name)
+        svg.linearGradient id: "#{scheme_name}_card_gradient", x1: '0%', y1: '0%', x2: '100%', y2: '100%' do
+          svg.stop offset: '0%', 'stop-color': color_scheme.card_gradient_start
+          svg.stop offset: '50%', 'stop-color': color_scheme.card_gradient_middle
+          svg.stop offset: '100%', 'stop-color': color_scheme.card_gradient_end
+        end
+      end
+
+      def define_frame_gradient(svg, color_scheme, scheme_name)
+        svg.linearGradient id: "#{scheme_name}_frame_gradient", x1: '0%', y1: '0%', x2: '100%', y2: '100%' do
+          svg.stop offset: '0%', 'stop-color': color_scheme.frame_gradient_start
+          svg.stop offset: '50%', 'stop-color': color_scheme.frame_gradient_middle
+          svg.stop offset: '100%', 'stop-color': color_scheme.frame_gradient_end
+        end
+      end
+
+      def define_name_gradient(svg, color_scheme, scheme_name)
+        svg.linearGradient id: "#{scheme_name}_name_gradient", x1: '0%', y1: '0%', x2: '100%', y2: '100%' do
+          svg.stop offset: '0%', 'stop-color': color_scheme.name_gradient_start
+          svg.stop offset: '50%', 'stop-color': color_scheme.name_gradient_middle
+          svg.stop offset: '100%', 'stop-color': color_scheme.name_gradient_end
+        end
+      end
+
+      def define_description_gradient(svg, color_scheme, scheme_name)
+        svg.linearGradient id: "#{scheme_name}_description_gradient", x1: '0%', y1: '0%', x2: '100%', y2: '100%' do
+          svg.stop offset: '0%', 'stop-color': color_scheme.description_gradient_start
+          svg.stop offset: '50%', 'stop-color': color_scheme.description_gradient_middle
+          svg.stop offset: '100%', 'stop-color': color_scheme.description_gradient_end
+        end
+      end
+
+      def define_metallic_gradients(svg, color_scheme)
+        scheme_name = color_scheme.scheme_name
+
+        define_metallic_highlight_gradient(svg, color_scheme, scheme_name)
+        define_metallic_shadow_gradient(svg, color_scheme, scheme_name)
+        define_metallic_pattern(svg, color_scheme, scheme_name)
+      end
+
+      def define_metallic_highlight_gradient(svg, color_scheme, scheme_name)
+        svg.linearGradient id: "#{scheme_name}_metallic_highlight_gradient", x1: '0%', y1: '0%', x2: '100%',
+                           y2: '100%' do
+          svg.stop offset: '0%', 'stop-color': color_scheme.metallic_highlight_end, 'stop-opacity': '0.6'
+          svg.stop offset: '20%', 'stop-color': color_scheme.metallic_highlight_middle, 'stop-opacity': '0.9'
+          svg.stop offset: '38%', 'stop-color': color_scheme.metallic_highlight_start, 'stop-opacity': '1.0'
+          svg.stop offset: '42%', 'stop-color': color_scheme.metallic_highlight_middle, 'stop-opacity': '0.7'
+          svg.stop offset: '62%', 'stop-color': color_scheme.metallic_highlight_end, 'stop-opacity': '0.5'
+          svg.stop offset: '73%', 'stop-color': color_scheme.metallic_highlight_start, 'stop-opacity': '0.8'
+          svg.stop offset: '80%', 'stop-color': color_scheme.metallic_highlight_middle, 'stop-opacity': '0.6'
+          svg.stop offset: '100%', 'stop-color': color_scheme.metallic_highlight_end, 'stop-opacity': '0.4'
+        end
+      end
+
+      def define_metallic_shadow_gradient(svg, color_scheme, scheme_name)
+        svg.radialGradient id: "#{scheme_name}_metallic_shadow_gradient", cx: '50%', cy: '50%', r: '70%' do
+          svg.stop offset: '0%', 'stop-color': color_scheme.metallic_shadow_start, 'stop-opacity': '0.3'
+          svg.stop offset: '50%', 'stop-color': color_scheme.metallic_shadow_middle, 'stop-opacity': '0.5'
+          svg.stop offset: '100%', 'stop-color': color_scheme.metallic_shadow_end, 'stop-opacity': '0.7'
+        end
+      end
+
+      def define_metallic_pattern(svg, color_scheme, scheme_name)
+        svg.pattern id: "#{scheme_name}_metallic_pattern", x: '0', y: '0', width: '20', height: '20',
+                    patternUnits: 'userSpaceOnUse' do
+          add_metallic_pattern_lines(svg, color_scheme)
+          add_metallic_pattern_circles(svg, color_scheme)
+        end
+      end
+
+      def add_metallic_pattern_lines(svg, color_scheme)
+        svg.line x1: '0', y1: '0', x2: '20', y2: '20',
+                 stroke: color_scheme.metallic_pattern_light,
+                 'stroke-width': '0.5',
+                 opacity: '0.3'
+        svg.line x1: '20', y1: '0', x2: '0', y2: '20',
+                 stroke: color_scheme.metallic_pattern_dark,
+                 'stroke-width': '0.5',
+                 opacity: '0.2'
+      end
+
+      def add_metallic_pattern_circles(svg, color_scheme)
+        svg.circle cx: '5', cy: '5', r: '0.5',
+                   fill: color_scheme.metallic_pattern_light,
+                   opacity: '0.6'
+        svg.circle cx: '15', cy: '15', r: '0.5',
+                   fill: color_scheme.metallic_pattern_light,
+                   opacity: '0.6'
+        svg.circle cx: '10', cy: '10', r: '0.3',
+                   fill: color_scheme.metallic_pattern_dark,
+                   opacity: '0.4'
+      end
+    end
+  end
+end

data/lib/mtg_card_maker/text_rendering_service.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module MtgCardMaker
+  # Minimal text rendering service with basic word wrapping for SVG.
+  # This service handles text layout, wrapping, and attribute generation
+  # for SVG text elements with configurable font sizes, colors, and spacing.
+  #
+  # @example
+  #   service = MtgCardMaker::TextRenderingService.new(
+  #     text: "Lightning Bolt deals 3 damage to any target.",
+  #     x: 40, y: 545, font_size: 24, available_width: 550
+  #   )
+  #   lines = service.wrapped_text_lines
+  #
+  # @since 0.1.0
+  class TextRenderingService
+    # @return [String] the text to render
+    attr_accessor :text
+
+    # @return [LayerConfig] the layer configuration
+    attr_accessor :layer_config
+
+    # @return [Integer] the x-coordinate for text positioning
+    attr_accessor :x
+
+    # @return [Integer] the y-coordinate for text positioning
+    attr_accessor :y
+
+    # @return [Integer] the font size
+    attr_accessor :font_size
+
+    # @return [String] the text color
+    attr_accessor :color
+
+    # @return [Integer] the available width for text wrapping
+    attr_accessor :available_width
+
+    # @return [Integer] the line height
+    attr_accessor :line_height
+
+    # @return [String, nil] the CSS class for styling
+    attr_accessor :css_class
+
+    # Initialize a new text rendering service
+    #
+    # @param kwargs [Hash] the initialization parameters
+    # @option kwargs [String] :text the text to render (default: '')
+    # @option kwargs [LayerConfig] :layer_config the layer configuration (default: LayerConfig.default)
+    # @option kwargs [Integer] :x the x-coordinate (default: 0)
+    # @option kwargs [Integer] :y the y-coordinate (default: 0)
+    # @option kwargs [Integer] :font_size the font size (default: from layer_config)
+    # @option kwargs [String] :color the text color (default: from layer_config)
+    # @option kwargs [Integer] :available_width the available width (default: CARD_WIDTH)
+    # @option kwargs [Integer] :line_height the line height (default: calculated)
+    # @option kwargs [String] :css_class the CSS class (default: nil)
+    def initialize(**kwargs)
+      # Set defaults
+      defaults = {
+        text: '',
+        layer_config: LayerConfig.default,
+        x: 0,
+        y: 0,
+        font_size: nil,
+        color: nil,
+        available_width: nil,
+        line_height: nil,
+        css_class: nil
+      }
+
+      # Merge defaults with provided kwargs
+      final_params = defaults.merge(kwargs)
+
+      # Set instance variables
+      final_params.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+
+      # Post-process dependent values
+      @font_size ||= @layer_config.default_font_size
+      @color ||= @layer_config.default_text_color
+      @available_width ||= CARD_WIDTH
+      @line_height ||= calculate_default_line_height
+    end
+
+    # Returns an array of [line, attrs] for SVG text elements
+    #
+    # @param text [String, nil] optional text to override current text
+    # @return [Array<Array>] array of [line_text, attributes_hash] pairs
+    def wrapped_text_lines(text = nil)
+      @text = text if text
+      render_text_lines
+    end
+
+    private
+
+    def calculate_default_line_height
+      @font_size * @layer_config.default_line_height_multiplier
+    end
+
+    def render_text_lines
+      lines = text_to_lines
+      build_text_attributes(lines)
+    end
+
+    def text_to_lines
+      @text.to_s.split(/\r?\n/).flat_map do |line|
+        wrap_line(line)
+      end.reject(&:empty?)
+    end
+
+    def build_text_attributes(lines)
+      lines.each_with_index.map do |line, idx|
+        attrs = {
+          x: @x,
+          y: @y + (idx * @line_height).to_i,
+          fill: @color,
+          font_size: @font_size
+        }
+        attrs[:class] = @css_class if @css_class
+        [line, attrs]
+      end
+    end
+
+    def wrap_line(line)
+      return [''] if line.strip.empty?
+
+      char_width = @font_size * @layer_config.char_width_multiplier
+      words = line.split(/\s+/)
+      process_words(words, char_width)
+    end
+
+    def process_words(words, char_width)
+      lines = []
+      current = ''
+
+      words.each do |word|
+        current, completed_line = process_word(word, current, char_width)
+        lines << completed_line if completed_line
+      end
+      lines << current unless current.empty?
+      lines
+    end
+
+    def process_word(word, current, char_width)
+      test = current.empty? ? word : "#{current} #{word}"
+      if test.length * char_width <= @available_width
+        [test, nil]
+      else
+        [word, current]
+      end
+    end
+
+    class << self
+      # Convenience method for backward compatibility
+      def wrapped_text_lines(*, **)
+        new(*, **).wrapped_text_lines
+      end
+    end
+  end
+end

data/lib/mtg_card_maker/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MtgCardMaker
+  MAJOR = 0
+  MINOR = 1
+  PATCH = 0
+  VERSION = [MAJOR, MINOR, PATCH].join('.')
+end

data/lib/mtg_card_maker.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require_relative 'mtg_card_maker/version'
+require 'victor'
+
+# MTG Card Maker is a Ruby gem for creating Magic: The Gathering card templates.
+# It uses the Victor SVG library to generate layered card designs with customizable
+# colors, text, and artwork. The library provides a modular layer system where
+# each component (frame, art, text areas) inherits from BaseLayer and implements
+# its own rendering logic.
+#
+# @example Basic Usage
+#   card = MtgCardMaker::BaseCard.new(
+#     name: "Lightning Bolt",
+#     mana_cost: "R",
+#     type: "Instant",
+#     description: "Lightning Bolt deals 3 damage to any target.",
+#     color_scheme: :red
+#   )
+#   card.generate("lightning_bolt.svg")
+#
+# @example Custom Template
+#   template = MtgCardMaker::Template.new
+#   template.add_layer(MtgCardMaker::BorderLayer.new(dimensions: {...}, color: :red))
+#   template.add_layer(MtgCardMaker::NameLayer.new(dimensions: {...}, text: "Lightning Bolt"))
+#   template.save("custom_card.svg")
+#
+# @since 0.1.0
+# @author Joe Sharp
+module MtgCardMaker
+  # Standard MTG card width in pixels
+  # @return [Integer] the width of a standard MTG card
+  CARD_WIDTH = 630
+
+  # Standard MTG card height in pixels
+  # @return [Integer] the height of a standard MTG card
+  CARD_HEIGHT = 880
+
+  # Load unified color scheme system
+  require_relative 'mtg_card_maker/color_scheme'
+  require_relative 'mtg_card_maker/color_palette'
+  require_relative 'mtg_card_maker/layer_config'
+
+  # Default color scheme using colorless colors
+  # @return [ColorScheme] the default colorless color scheme
+  DEFAULT_COLOR_SCHEME = ColorScheme.new(:colorless)
+
+  # Default text color from the default color scheme
+  # @return [String] the default text color hex value
+  DEFAULT_TEXT_COLOR = DEFAULT_COLOR_SCHEME.text_color
+
+  # White color constant for border compatibility
+  # @return [String] the white color hex value
+  WHITE = '#EEE'
+
+  # Custom error class for MTG Card Maker specific errors
+  class Error < StandardError; end
+
+  # Base class for all card layers that provides common attributes and rendering interface.
+  # All layer classes (frames, text areas, art) inherit from this base class and
+  # implement their own specific rendering logic.
+  #
+  # @abstract Subclasses must implement the {#render} method
+  # @since 0.1.0
+  class BaseLayer
+    # @return [Template, nil] the template instance this layer belongs to
+    attr_accessor :template
+
+    # @return [Integer] the x-coordinate of the layer
+    attr_reader :x
+
+    # @return [Integer] the y-coordinate of the layer
+    attr_reader :y
+
+    # @return [Integer] the width of the layer
+    attr_reader :width
+
+    # @return [Integer] the height of the layer
+    attr_reader :height
+
+    # @return [String] the color of the layer
+    attr_reader :color
+
+    # Initialize a new layer with the given dimensions and color
+    #
+    # @param dimensions [Hash] the layer dimensions
+    # @option dimensions [Integer] :x the x-coordinate
+    # @option dimensions [Integer] :y the y-coordinate
+    # @option dimensions [Integer] :width the width
+    # @option dimensions [Integer] :height the height
+    # @param color [String] the color of the layer (default: 'white')
+    def initialize(dimensions:, color: 'white')
+      @x = dimensions[:x]
+      @y = dimensions[:y]
+      @width = dimensions[:width]
+      @height = dimensions[:height]
+      @color = color
+      @template = nil
+    end
+
+    # Render the layer to the SVG canvas
+    #
+    # @abstract Subclasses must implement this method
+    # @raise [NotImplementedError] if not implemented by subclass
+    def render
+      raise NotImplementedError, "Subclasses must implement the 'render' method."
+    end
+
+    # Access the SVG canvas through the template
+    #
+    # @return [Victor::SVG, nil] the SVG canvas instance
+    def svg
+      @template&.instance_variable_get(:@svg)
+    end
+  end
+
+  require_relative 'mtg_card_maker/layer_initializer'
+  require_relative 'mtg_card_maker/base_card'
+  require_relative 'mtg_card_maker/layer_factory'
+  require_relative 'mtg_card_maker/svg_gradient_service'
+  require_relative 'mtg_card_maker/text_rendering_service'
+  require_relative 'mtg_card_maker/sprite_sheet_assets'
+  require_relative 'mtg_card_maker/sprite_sheet_builder'
+  require_relative 'mtg_card_maker/sprite_sheet_service'
+  require_relative 'mtg_card_maker/layers/border_layer'
+  require_relative 'mtg_card_maker/layers/frame_layer'
+  require_relative 'mtg_card_maker/layers/name_layer'
+  require_relative 'mtg_card_maker/layers/art_layer'
+  require_relative 'mtg_card_maker/layers/type_line_layer'
+  require_relative 'mtg_card_maker/layers/text_box_layer'
+  require_relative 'mtg_card_maker/layers/power_layer'
+  require_relative 'mtg_card_maker/cli'
+
+  # Main template class that manages the SVG canvas and layer composition.
+  # This class handles creating the SVG canvas, adding layers, and saving
+  # the final SVG file. It also manages font embedding and CSS styling.
+  #
+  # @example
+  #   template = MtgCardMaker::Template.new
+  #   template.add_layer(MtgCardMaker::BorderLayer.new(dimensions: {...}))
+  #   template.add_layer(MtgCardMaker::NameLayer.new(dimensions: {...}, text: "Lightning Bolt"))
+  #   template.save("card.svg")
+  #
+  # @since 0.1.0
+  class Template
+    # @return [Integer] the width of the SVG canvas
+    attr_reader :width
+
+    # @return [Integer] the height of the SVG canvas
+    attr_reader :height
+
+    # Initialize a new template with the given dimensions
+    #
+    # @param width [Integer] the width of the canvas (default: CARD_WIDTH)
+    # @param height [Integer] the height of the canvas (default: CARD_HEIGHT)
+    # @param embed_font [Boolean] whether to embed the font as base64 (default: false)
+    def initialize(width: CARD_WIDTH, height: CARD_HEIGHT, embed_font: false)
+      @width = width
+      @height = height
+      @svg = Victor::SVG.new width: width, height: height
+      embed_font(embed: embed_font)
+      define_css_classes
+    end
+
+    # Add a layer to the template and render it
+    #
+    # @param layer [BaseLayer] the layer to add and render
+    # @return [void]
+    def add_layer(layer)
+      layer.template = self
+      layer.render
+    end
+
+    # Save the SVG to a file
+    #
+    # @param filename [String] the filename to save to
+    # @return [void]
+    def save(filename)
+      @svg.save(filename)
+    end
+
+    # Get the SVG as a string
+    #
+    # @return [String] the SVG content as a string
+    def to_svg
+      @svg.to_s
+    end
+
+    private
+
+    def embed_font(embed: false)
+      if embed
+        font_path = File.join(__dir__, 'mtg_card_maker', 'fonts', 'goudy_base64.txt')
+        base64_font_data = File.read(font_path).strip
+        @svg.style <<~CSS
+          @font-face {
+            font-family: 'Goudy Mediaeval DemiBold';
+            src: url(data:font/truetype;charset=utf-8;base64,#{base64_font_data}) format('truetype');
+            font-weight: normal;
+            font-style: normal;
+          }
+        CSS
+      else
+        @svg.style <<~CSS
+          @font-face {
+            font-family: 'Goudy Mediaeval DemiBold';
+            src: url('fonts/Goudy Mediaeval DemiBold.ttf') format('truetype');
+            font-weight: normal;
+            font-style: normal;
+          }
+        CSS
+      end
+    end
+
+    def define_css_classes
+      @svg.style <<~CSS
+        /* Font Classes */
+        .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;
+        }
+
+        .card-copyright {
+          font-family: sans-serif;
+          font-weight: normal;
+          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

data/sig/mtg_card_maker.rbs

@@ -0,0 +1,4 @@
+module MtgCardMaker
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end