mtg_card_maker 0.1.0

data/lib/mtg_card_maker/base_card.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require_relative 'layers/art_layer'
+require_relative 'layers/text_box_layer'
+require_relative 'layers/frame_layer'
+require_relative 'layers/name_layer'
+require_relative 'layers/border_layer'
+require_relative 'layers/power_layer'
+require_relative 'layers/type_line_layer'
+
+module MtgCardMaker
+  # Base class for all Magic: The Gathering card types that provides common
+  # functionality with simplified configuration. This class handles the creation
+  # of complete MTG cards with all necessary layers (frames, text, art, etc.)
+  # using predefined dimensions and layouts.
+  #
+  # @example
+  #   card = MtgCardMaker::BaseCard.new(
+  #     name: "Lightning Bolt",
+  #     mana_cost: "R",
+  #     type_line: "Instant",
+  #     rules_text: "Lightning Bolt deals 3 damage to any target.",
+  #     color_scheme: :red
+  #   )
+  #   card.save("lightning_bolt.svg")
+  #
+  # @since 0.1.0
+  class BaseCard
+    # Fixed defaults for card layout and dimensions
+    # @return [Hash] the default configuration for card layers and dimensions
+    DEFAULTS = {
+      layers: {
+        border: {
+          x: 0,
+          y: 0,
+          width: 630,
+          height: 880
+        },
+        frame: {
+          x: 10,
+          y: 10,
+          width: 610,
+          height: 860
+        },
+        name_area: {
+          x: 30,
+          y: 40,
+          width: 570,
+          height: 50
+        },
+        art_layer: {
+          x: 40,
+          y: 95,
+          width: 550,
+          height: 400,
+          corner_radius: { x: 5, y: 5 }
+        },
+        type_area: {
+          x: 30,
+          y: 500,
+          width: 570,
+          height: 40
+        },
+        text_box: {
+          x: 40,
+          y: 545,
+          width: 550,
+          height: 265
+        },
+        power_area: {
+          x: 455,
+          y: 790,
+          width: 140,
+          height: 40
+        }
+      },
+      mask_id: 'artWindowMask',
+      frame_stroke_width: 2
+    }.freeze
+
+    # @return [String, nil] the card name
+    attr_reader :name
+
+    # @return [String, nil] the mana cost in MTG notation (e.g., "R", "1U")
+    attr_reader :mana_cost
+
+    # @return [String, nil] the card type (e.g., "Instant", "Creature")
+    attr_reader :type_line
+
+    # @return [String, nil] the card description/rules text
+    attr_reader :rules_text
+
+    # @return [String, nil] the flavor text (italic text at bottom)
+    attr_reader :flavor_text
+
+    # @return [String, nil] the power value for creatures
+    attr_reader :power
+
+    # @return [String, nil] the toughness value for creatures
+    attr_reader :toughness
+
+    # @return [String, nil] the border color
+    attr_reader :border_color
+
+    # @return [ColorScheme] the color scheme for the card
+    attr_reader :color_scheme
+
+    # @return [String, nil] the URL or path for the card artwork
+    attr_reader :art
+
+    # Initialize a new card with the given configuration
+    #
+    # @param config [Hash] the card configuration
+    # @option config [String] :name the card name
+    # @option config [String] :mana_cost the mana cost in MTG notation
+    # @option config [String] :type_line the card type
+    # @option config [String] :rules_text the card rules text
+    # @option config [String] :flavor_text the flavor text
+    # @option config [String] :power the power value for creatures
+    # @option config [String] :toughness the toughness value for creatures
+    # @option config [String] :border_color the border color
+    # @option config [Symbol, String] :color the color scheme
+    # @option config [String] :art the URL or path for card artwork
+    def initialize(config)
+      assign_attributes(config)
+      @template = Template.new
+      add_layers
+    end
+
+    # Save the card to an SVG file
+    #
+    # @param filename [String] the filename to save to
+    # @return [void]
+    def save(filename)
+      @template.save(filename)
+    end
+
+    # @private
+    def use_color_scheme(color)
+      if color
+        ColorScheme.new(color)
+      else
+        DEFAULT_COLOR_SCHEME
+      end
+    end
+
+    # Delegate dimension methods to DEFAULTS for LayerFactory compatibility
+    # @private
+    def card_width
+      CARD_WIDTH
+    end
+
+    # @private
+    def card_height
+      CARD_HEIGHT
+    end
+
+    # @private
+    def dimensions_for_layer(layer_name)
+      DEFAULTS[:layers][layer_name.to_sym] || {}
+    end
+
+    # @private
+    def art_window_config
+      DEFAULTS[:layers][:art_layer]
+    end
+
+    # @private
+    def frame_stroke_width
+      DEFAULTS[:frame_stroke_width]
+    end
+
+    private
+
+    def assign_attributes(config)
+      @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]
+      @border_color = config[:border_color]
+      @color_scheme = use_color_scheme(config[:color])
+      @art = config[:art]
+    end
+
+    def define_art_window_mask
+      svg = @template.instance_variable_get(:@svg)
+      svg.defs do
+        svg.mask id: DEFAULTS[:mask_id] do
+          # White rectangle covers the entire card (opaque)
+          svg.rect x: 0, y: 0, width: '100%', height: '100%', fill: '#FFF'
+          # Black rectangle creates the transparent window at art position
+          art_config = art_window_config
+          svg.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_layers
+      define_art_window_mask
+      # Use LayerFactory to create layers in order
+      layers = LayerFactory.create_layers_for_card(self, DEFAULTS[:mask_id], self)
+      layers.each { |layer| @template.add_layer(layer) }
+    end
+  end
+end

data/lib/mtg_card_maker/cli.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'yaml'
+require 'fileutils'
+
+module MtgCardMaker
+  # Thor-based command-line interface for MTG Card Maker.
+  # Provides commands for generating individual cards and sprite sheets
+  # from YAML configuration files.
+  #
+  # @example Generate a single card
+  #   mtg_card_maker generate_card --name "Lightning Bolt" --type-text "Instant" \
+  #     --rules-text "Lightning Bolt deals 3 damage to any target." --color red
+  #
+  # @example Generate a sprite sheet
+  #   mtg_card_maker generate_sprite cards.yml sprite.svg
+  #
+  # @example Add a card to YAML file
+  #   mtg_card_maker add_card cards.yml --name "Lightning Bolt" --type-text "Instant" \
+  #     --rules-text "Lightning Bolt deals 3 damage to any target." --color red
+  #
+  # @since 0.1.0
+  class CLI < Thor # rubocop:disable Metrics/ClassLength
+    package_name 'mtg_card_maker'
+    map 'a'  => :add_card
+    map 'ac' => :add_card
+    map 'g'  => :generate_card
+    map 'gc' => :generate_card
+    map 'gcs'=> :generate_sprite
+    map 'gs' => :generate_sprite
+
+    def self.exit_on_failure?
+      true
+    end
+
+    # Define the standard card options for CLI commands
+    #
+    # @return [Hash] the card option definitions for Thor
+    def self.card_options
+      {
+        name: { type: :string, required: true, desc: 'Card name' },
+        mana_cost: { type: :string, aliases: ['mana', 'cost'], desc: 'Mana cost (e.g., "2RR", "XG")' },
+        type_line: { type: :string, required: true, aliases: ['type'],
+                     desc: 'Card type & subtype (e.g., "Creature - Dragon", "Instant")' },
+        rules_text: { type: :string, required: true, aliases: ['rules'], desc: 'Card rules text' },
+        flavor_text: { type: :string, aliases: ['flavor'], desc: 'Flavor text (optional)' },
+        power: { type: :string, desc: 'Power (for creatures)' },
+        toughness: { type: :string, desc: 'Toughness (for creatures)' },
+        border_color: { type: :string, aliases: ['border'], desc: 'Border color (white, black, gold, silver)' },
+        color: { type: :string,
+                 default: 'colorless',
+                 desc: 'Card color (white, blue, black, red, green, colorless)' },
+        art: { type: :string, aliases: ['artwork', 'image'], desc: 'Image URL or path for card artwork' }
+      }
+    end
+
+    # Generate a single MTG card with specified parameters
+    #
+    # @option options [String] :name the card name (required)
+    # @option options [String] :mana_cost the mana cost in MTG notation
+    # @option options [String] :type_line the card type (required)
+    # @option options [String] :rules_text the card rules (required)
+    # @option options [String] :flavor_text the flavor text
+    # @option options [String] :power the power value for creatures
+    # @option options [String] :toughness the toughness value for creatures
+    # @option options [String] :border_color the border color
+    # @option options [String] :color the card color scheme
+    # @option options [String] :art the URL for card artwork
+    # @option options [String] :output the output filename (default: output_card.svg)
+    # @return [void]
+    # @!method generate_card
+    #   Generate a single MTG card with specified parameters
+    desc 'generate_card [OPTIONS]', 'Generate a single MTG card with specified parameters'
+    card_options.each { |option, config| option option, config }
+    option :output, type: :string, default: 'output_card.svg', desc: 'Output filename'
+    def generate_card
+      config = build_card_config_from_options
+      # Convert string keys to symbols for BaseCard compatibility
+      config = config.transform_keys(&:to_sym)
+      card = BaseCard.new(config)
+      card.save(options[:output])
+      puts "✨ Generated #{options[:output]}! ✨"
+    end
+
+    # @!method generate_sprite(yaml_file, output_file)
+    #   Generate a sprite sheet from YAML configuration
+    desc 'generate_sprite YAML_FILE OUTPUT_FILE [OPTIONS]', 'Generate a sprite sheet from YAML configuration'
+    option :cards_per_row, type: :numeric, default: 4, desc: 'Number of cards per row in sprite'
+    option :spacing, type: :numeric, default: 30, desc: 'Spacing between cards in pixels'
+    def generate_sprite(yaml_file, output_file)
+      validate_yaml_file(yaml_file)
+
+      begin
+        config = load_yaml_config(yaml_file)
+        sprite_service = create_sprite_service
+        process_sprite_generation(config, sprite_service, output_file)
+      rescue Psych::SyntaxError => e
+        handle_yaml_error(e)
+      rescue StandardError => e
+        handle_general_error(e)
+      end
+    end
+
+    # @!method add_card(yaml_file)
+    #   Add a new card configuration to YAML file
+    desc 'add_card YAML_FILE [OPTIONS]', 'Add a new card configuration to YAML file'
+    card_options.each { |option, config| option option, config }
+    def add_card(yaml_file)
+      # Create directory if it doesn't exist
+      FileUtils.mkdir_p(File.dirname(yaml_file))
+
+      # Load existing config or create new one
+      config = File.exist?(yaml_file) ? YAML.safe_load_file(yaml_file) : {}
+
+      # Generate a unique key for the card
+      card_key = generate_card_key(options[:name], config)
+
+      # Build card configuration
+      card_config = build_card_config_from_options
+
+      # Add to config
+      config[card_key] = card_config
+
+      # Save back to file
+      File.write(yaml_file, config.to_yaml)
+      puts "✨ Added card '#{options[:name]}' to #{yaml_file}! ✨"
+      puts "🎴 Key: #{card_key}"
+    end
+
+    private
+
+    def validate_yaml_file(yaml_file)
+      return if File.exist?(yaml_file)
+
+      warn "❌ YAML file not found: #{yaml_file}"
+      exit 1
+    end
+
+    def process_sprite_generation(config, sprite_service, output_file)
+      if sprite_service.create_sprite_sheet(config, output_file)
+        display_success_message(config, sprite_service, output_file)
+      else
+        warn '❌ Failed to generate sprite sheet'
+        exit 1
+      end
+    end
+
+    def handle_yaml_error(error)
+      warn "❌ Invalid YAML syntax: #{error.message}"
+      exit 1
+    end
+
+    def handle_general_error(error)
+      warn "💥 Error: #{error.message}"
+      exit 1
+    end
+
+    def display_success_message(config, sprite_service, output_file)
+      puts "✨ Generated #{output_file}! ✨"
+      width, height = sprite_service.sprite_dimensions(config.length)
+      puts "📏 Sprite dimensions: #{width}x#{height} pixels"
+      puts "🎨 Contains #{config.length} cards"
+    end
+
+    def load_yaml_config(yaml_file)
+      YAML.safe_load_file(yaml_file)
+    end
+
+    def create_sprite_service
+      SpriteSheetService.new(
+        cards_per_row: options[:cards_per_row],
+        spacing: options[:spacing]
+      )
+    end
+
+    def build_card_config_from_options
+      config = build_required_config
+      add_optional_fields(config)
+      config
+    end
+
+    def build_required_config
+      {
+        'name' => options[:name],
+        'type_line' => options[:type_line],
+        'rules_text' => process_newlines(options[:rules_text])
+      }
+    end
+
+    def add_optional_fields(config)
+      optional_fields = %w[mana_cost power toughness border_color color art]
+      optional_fields.each do |field|
+        config[field] = options[field.to_sym] if options[field.to_sym]
+      end
+
+      # Handle flavor_text separately to process newlines
+      return unless options[:flavor_text]
+
+      config['flavor_text'] = process_newlines(options[:flavor_text])
+    end
+
+    def process_newlines(text)
+      # Convert literal \n to actual newlines
+      text.gsub('\\n', "\n")
+    end
+
+    def generate_card_key(name, existing_config)
+      base_key = name.downcase.gsub(/[^a-z0-9]/, '_').squeeze('_').chomp('_')
+
+      # If key already exists, append a number
+      if existing_config.key?(base_key)
+        counter = 1
+        counter += 1 while existing_config.key?("#{base_key}_#{counter}")
+        "#{base_key}_#{counter}"
+      else
+        base_key
+      end
+    end
+  end
+end

data/lib/mtg_card_maker/color_palette.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module MtgCardMaker
+  # ColorPalette aggregates the five core interface colors for cohesive design.
+  # It focuses on background elements, buttons, borders, and other UI components,
+  # excluding text color. Multiple instances can be created for different themes
+  # (default, dark, corporate, etc.).
+  #
+  # @example
+  #   palette = MtgCardMaker::ColorPalette.new(
+  #     primary_color: '#42A5F5',
+  #     background_color: '#E3F2FD',
+  #     border_color: '#1565C0'
+  #   )
+  #   palette.primary_color # => "#42A5F5"
+  #
+  # @example Using predefined themes
+  #   dark_palette = MtgCardMaker::ColorPalette.dark
+  #   light_palette = MtgCardMaker::ColorPalette.light
+  #   default_palette = MtgCardMaker::ColorPalette.default
+  #
+  # @since 0.1.0
+  class ColorPalette
+    # @return [String] the primary color
+    attr_reader :primary_color
+
+    # @return [String] the background color
+    attr_reader :background_color
+
+    # @return [String] the border color
+    attr_reader :border_color
+
+    # @return [String] the frame stroke color
+    attr_reader :frame_stroke_color
+
+    # @return [String] the accent color
+    attr_reader :accent_color
+
+    # Default frame stroke color used across the application
+    # @return [String] the default frame stroke color
+    FRAME_STROKE_COLOR = '#111'
+
+    # Initialize a new color palette
+    #
+    # @param primary_color [String, nil] the primary color (default: from default color scheme)
+    # @param background_color [String, nil] the background color (default: from default color scheme)
+    # @param border_color [String, nil] the border color (default: from default color scheme)
+    # @param frame_stroke_color [String] the frame stroke color (default: FRAME_STROKE_COLOR)
+    # @param accent_color [String, nil] the accent color (default: from default color scheme)
+    def initialize(primary_color: nil, background_color: nil, border_color: nil,
+                   frame_stroke_color: FRAME_STROKE_COLOR, accent_color: nil)
+      @primary_color = primary_color || DEFAULT_COLOR_SCHEME.primary_color
+      @background_color = background_color || DEFAULT_COLOR_SCHEME.background_color
+      @border_color = border_color || DEFAULT_COLOR_SCHEME.border_color
+      @frame_stroke_color = frame_stroke_color
+      @accent_color = accent_color || DEFAULT_COLOR_SCHEME.primary_color
+    end
+
+    # Create a palette from a color scheme
+    #
+    # @param color_scheme [ColorScheme] the color scheme to create palette from
+    # @return [ColorPalette] a new color palette based on the color scheme
+    def self.from_color_scheme(color_scheme)
+      new(
+        primary_color: color_scheme.primary_color,
+        background_color: color_scheme.background_color,
+        border_color: color_scheme.border_color,
+        accent_color: color_scheme.primary_color
+      )
+    end
+
+    # Default palette using the default color scheme
+    #
+    # @return [ColorPalette] the default color palette
+    def self.default
+      from_color_scheme(DEFAULT_COLOR_SCHEME)
+    end
+
+    # Dark theme palette
+    #
+    # @return [ColorPalette] a dark theme color palette
+    def self.dark
+      new(
+        primary_color: '#2A2A2A',
+        background_color: '#1A1A1A',
+        border_color: '#4A4A4A',
+        frame_stroke_color: '#333',
+        accent_color: '#6B6B6B'
+      )
+    end
+
+    # Light theme palette
+    #
+    # @return [ColorPalette] a light theme color palette
+    def self.light
+      new(
+        primary_color: '#E8E8E8',
+        background_color: '#F5F5F5',
+        border_color: '#D4D4D4',
+        frame_stroke_color: '#666',
+        accent_color: '#8B8B8B'
+      )
+    end
+
+    # Return all colors as a hash for easy access
+    def to_h
+      {
+        primary_color: @primary_color,
+        background_color: @background_color,
+        border_color: @border_color,
+        frame_stroke_color: @frame_stroke_color,
+        accent_color: @accent_color
+      }
+    end
+
+    # Return all colors as an array
+    def to_a
+      [@primary_color, @background_color, @border_color, @frame_stroke_color, @accent_color]
+    end
+
+    # Check if this palette matches another
+    def ==(other)
+      return false unless other.is_a?(ColorPalette)
+
+      to_h == other.to_h
+    end
+
+    alias_method :eql?, :==
+
+    # Generate a hash for this palette
+    def hash
+      to_h.hash
+    end
+  end
+end