pixelart 1.2.3 → 1.3.2

data/lib/pixelart/composite.rb

@@ -1,154 +1,154 @@
-module Pixelart
-
-class ImageComposite < Image  # check: (re)name to Collage, Sheet, Sprites, or such?
-
-  ## default tile width / height in pixel -- check: (re)name to sprite or such? why? why not?
-  TILE_WIDTH  = 24
-  TILE_HEIGHT = 24
-
-
-  def self.read( path, width: TILE_WIDTH, height: TILE_WIDTH )   ## convenience helper
-    img = ChunkyPNG::Image.from_file( path )
-    new( img, width:  width,
-              height: width )
-  end
-
-
-  def initialize( *args, **kwargs )
-    @tile_width  = kwargs[:width]  || kwargs[:tile_width]  || TILE_WIDTH
-    @tile_height = kwargs[:height] || kwargs[:tile_height] || TILE_HEIGHT
-
-    ## check for background
-    background = kwargs[:background] || kwargs[:tile_background]
-
-    if background
-      ## wrap into an array if not already an array
-      ##  and convert all colors to true rgba colors as integer numbers
-      background = [background]   unless background.is_a?( Array )
-      @background_colors = background.map { |color| Color.parse( color ) }
-    else
-      ## todo/check: use empty array instead of nil - why? why not?
-      @background_colors = nil
-    end
-
-
-    ## todo/fix: check type - args[0] is Image!!!
-    if args.size == 1   ## assume "copy" c'tor with passed in image
-       img = args[0]    ## pass image through as-is
-
-       @tile_cols  = img.width  / @tile_width       ## e.g. 2400/24 = 100
-       @tile_rows  = img.height / @tile_height      ## e.g. 2400/24 = 100
-       @tile_count = @tile_cols * @tile_rows       ## ## 10000 = 100x100  (2400x2400 pixel)
-    elsif args.size == 2 || args.size == 0     ## cols, rows
-      ## todo/fix: check type - args[0] & args[1] is Integer!!!!!
-       ## todo/check - find a better name for cols/rows - why? why not?
-       @tile_cols = args[0] || 3
-       @tile_rows = args[1] || 3
-       @tile_count = 0   # (track) current index (of added images)
-
-       background_color = if @background_colors && @background_colors.size == 1
-                             @background_colors[0]
-                          else
-                             0  # note: 0 is transparent (0) true color
-                          end
-
-        ## todo/check - always auto-fill complete image (even if empty/no tiles)
-        ##                with background color if only one background color
-        ##                   why? why not??? or always follow the "model"
-        ##                                       with more than one background color???
-        img = ChunkyPNG::Image.new( @tile_cols * @tile_width,
-                                    @tile_rows * @tile_height,
-                                    background_color )
-
-    else
-       raise ArgumentError, "cols, rows or image arguments expected; got: #{args.inspect}"
-    end
-
-
-    puts "     #{img.height}x#{img.width} (height x width)"
-
-    super( nil, nil, img )
-  end
-
-
-  def count() @tile_count; end
-  alias_method :size, :count   ## add size alias (confusing if starting with 0?) - why? why not?
-  alias_method :tile_count, :count
-
-  def tile_width() @tile_width; end
-  def tile_height() @tile_height; end
-
-
-
-  #####
-  # set / add tile
-  def _add( image )
-    y, x =  @tile_count.divmod( @tile_cols )
-
-    puts "    [#{@tile_count}] @ (#{x}/#{y}) #{image.width}x#{image.height} (height x width)"
-
-    ## note: only used if more than one background color specified
-    ##        needs to cycle through
-    if @background_colors && @background_colors.size > 1
-      i = x + y*@tile_cols
-
-      ## note: cycle through background color for now
-      background_color = @background_colors[i % @background_colors.size]
-      background = Image.new( @tile_width, @tile_height, background_color )  ## todo/chekc: use "raw" ChunkyPNG:Image here - why? why not?
-      background.compose!( image )
-      image = background    ## switch - make image with background new image
-    end
-
-    ## note: image.image  - "unwrap" the "raw" ChunkyPNG::Image
-    @img.compose!( image.image, x*@tile_width, y*@tile_height )
-    @tile_count += 1
-  end
-
-  def add( image_or_images )   ## note: allow adding of image OR array of images
-    if image_or_images.is_a?( Array )
-      images = image_or_images
-      images.each { |image| _add( image ) }
-    else
-      image = image_or_images
-      _add( image )
-    end
-  end
-  alias_method :<<, :add
-
-
-
-  ######
-  # get tile
-
-  def tile( index )
-    y, x = index.divmod( @tile_cols )
-    img = @img.crop( x*@tile_width, y*@tile_height, @tile_width, @tile_height )
-    Image.new( img.width, img.height, img )  ## wrap in pixelart image
-  end
-
-  def []( *args )    ## overload - why? why not?
-    if args.size == 1
-      index = args[0]
-      tile( index )
-    else
-      super   ## e.g [x,y] --- get pixel
-    end
-  end
-
-
-  ## convenience helpers to loop over composite
-  def each( &block )
-    count.times do |i|
-      block.call( tile( i ) )
-    end
-  end
-
-  def each_with_index( &block )
-    count.times do |i|
-      block.call( tile( i ), i )
-    end
-  end
-
-
-end # class ImageComposite
-end # module Pixelart
+module Pixelart
+
+class ImageComposite < Image  # check: (re)name to Collage, Sheet, Sprites, or such?
+
+  ## default tile width / height in pixel -- check: (re)name to sprite or such? why? why not?
+  TILE_WIDTH  = 24
+  TILE_HEIGHT = 24
+
+
+  def self.read( path, width: TILE_WIDTH, height: TILE_WIDTH )   ## convenience helper
+    img = ChunkyPNG::Image.from_file( path )
+    new( img, width:  width,
+              height: width )
+  end
+
+
+  def initialize( *args, **kwargs )
+    @tile_width  = kwargs[:width]  || kwargs[:tile_width]  || TILE_WIDTH
+    @tile_height = kwargs[:height] || kwargs[:tile_height] || TILE_HEIGHT
+
+    ## check for background
+    background = kwargs[:background] || kwargs[:tile_background]
+
+    if background
+      ## wrap into an array if not already an array
+      ##  and convert all colors to true rgba colors as integer numbers
+      background = [background]   unless background.is_a?( Array )
+      @background_colors = background.map { |color| Color.parse( color ) }
+    else
+      ## todo/check: use empty array instead of nil - why? why not?
+      @background_colors = nil
+    end
+
+
+    ## todo/fix: check type - args[0] is Image!!!
+    if args.size == 1   ## assume "copy" c'tor with passed in image
+       img = args[0]    ## pass image through as-is
+
+       @tile_cols  = img.width  / @tile_width       ## e.g. 2400/24 = 100
+       @tile_rows  = img.height / @tile_height      ## e.g. 2400/24 = 100
+       @tile_count = @tile_cols * @tile_rows       ## ## 10000 = 100x100  (2400x2400 pixel)
+    elsif args.size == 2 || args.size == 0     ## cols, rows
+      ## todo/fix: check type - args[0] & args[1] is Integer!!!!!
+       ## todo/check - find a better name for cols/rows - why? why not?
+       @tile_cols = args[0] || 3
+       @tile_rows = args[1] || 3
+       @tile_count = 0   # (track) current index (of added images)
+
+       background_color = if @background_colors && @background_colors.size == 1
+                             @background_colors[0]
+                          else
+                             0  # note: 0 is transparent (0) true color
+                          end
+
+        ## todo/check - always auto-fill complete image (even if empty/no tiles)
+        ##                with background color if only one background color
+        ##                   why? why not??? or always follow the "model"
+        ##                                       with more than one background color???
+        img = ChunkyPNG::Image.new( @tile_cols * @tile_width,
+                                    @tile_rows * @tile_height,
+                                    background_color )
+
+    else
+       raise ArgumentError, "cols, rows or image arguments expected; got: #{args.inspect}"
+    end
+
+
+    puts "     #{img.height}x#{img.width} (height x width)"
+
+    super( nil, nil, img )
+  end
+
+
+  def count() @tile_count; end
+  alias_method :size, :count   ## add size alias (confusing if starting with 0?) - why? why not?
+  alias_method :tile_count, :count
+
+  def tile_width() @tile_width; end
+  def tile_height() @tile_height; end
+
+
+
+  #####
+  # set / add tile
+  def _add( image )
+    y, x =  @tile_count.divmod( @tile_cols )
+
+    puts "    [#{@tile_count}] @ (#{x}/#{y}) #{image.width}x#{image.height} (height x width)"
+
+    ## note: only used if more than one background color specified
+    ##        needs to cycle through
+    if @background_colors && @background_colors.size > 1
+      i = x + y*@tile_cols
+
+      ## note: cycle through background color for now
+      background_color = @background_colors[i % @background_colors.size]
+      background = Image.new( @tile_width, @tile_height, background_color )  ## todo/chekc: use "raw" ChunkyPNG:Image here - why? why not?
+      background.compose!( image )
+      image = background    ## switch - make image with background new image
+    end
+
+    ## note: image.image  - "unwrap" the "raw" ChunkyPNG::Image
+    @img.compose!( image.image, x*@tile_width, y*@tile_height )
+    @tile_count += 1
+  end
+
+  def add( image_or_images )   ## note: allow adding of image OR array of images
+    if image_or_images.is_a?( Array )
+      images = image_or_images
+      images.each { |image| _add( image ) }
+    else
+      image = image_or_images
+      _add( image )
+    end
+  end
+  alias_method :<<, :add
+
+
+
+  ######
+  # get tile
+
+  def tile( index )
+    y, x = index.divmod( @tile_cols )
+    img = @img.crop( x*@tile_width, y*@tile_height, @tile_width, @tile_height )
+    Image.new( img.width, img.height, img )  ## wrap in pixelart image
+  end
+
+  def []( *args )    ## overload - why? why not?
+    if args.size == 1
+      index = args[0]
+      tile( index )
+    else
+      super   ## e.g [x,y] --- get pixel
+    end
+  end
+
+
+  ## convenience helpers to loop over composite
+  def each( &block )
+    count.times do |i|
+      block.call( tile( i ) )
+    end
+  end
+
+  def each_with_index( &block )
+    count.times do |i|
+      block.call( tile( i ), i )
+    end
+  end
+
+
+end # class ImageComposite
+end # module Pixelart

data/lib/pixelart/generator.rb

@@ -0,0 +1,202 @@
+####
+#  "simple" generator (no different sizes, genders, etc.)
+#     uses built-in spritesheet for (archetypes &) attributes
+
+
+module Pixelart
+
+  class Metadata
+    class Sprite
+      attr_reader :id, :name, :type, :more_names
+
+      def initialize( id:,
+                      name:,
+                      type:,
+                      more_names: [] )
+         @id         = id      # zero-based index eg. 0,1,2,3, etc.
+         @name       = name
+         @type       = type
+         @more_names = more_names
+      end
+   end  # class Metadata::Sprite
+  end # class Metadata
+
+
+
+
+  class Generator
+
+ ######
+ # static helpers  - (turn into "true" static self.class methods - why? why not?)
+ #
+ def self.normalize_key( str )
+   ## add & e.g. B&W
+   ## add ' e.g. McDonald's Red
+    str.downcase.gsub(/[ ()&°'_-]/, '').strip
+ end
+
+ def self.normalize_name( str )
+   ## normalize spaces in more names
+   str.strip.gsub( /[ ]{2,}/, ' ' )
+ end
+
+ def normalize_key( str )     self.class.normalize_key( str ); end
+ def normalize_name( str )    self.class.normalize_name( str ); end
+
+
+
+ def build_attributes_by_name( recs )
+    h = {}
+    recs.each_with_index do |rec|
+      names = [rec.name] + rec.more_names
+
+      names.each do |name|
+        key = normalize_key( name )
+
+        if h[ key ]
+          puts "!!! ERROR - attribute name is not unique:"
+          pp rec
+          puts "duplicate:"
+          pp h[key]
+          exit 1
+        end
+        h[ key ] = rec
+      end
+   end
+    ## pp h
+    h
+ end
+
+
+ def build_recs( recs )   ## build and normalize (meta data) records
+    ## sort by id
+    recs = recs.sort do |l,r|
+                       l['id'].to_i( 10 ) <=> r['id'].to_i( 10 )   # use base10 (decimal)
+                     end
+
+    ## assert all recs are in order by id (0 to size)
+    recs.each_with_index do |rec, exp_id|
+       id = rec['id'].to_i(10)
+       if id != exp_id
+          puts "!! ERROR -  meta data record ids out-of-order - expected id #{exp_id}; got #{id}"
+          exit 1
+       end
+    end
+
+    ## convert to "wrapped / immutable" kind-of struct
+    recs = recs.map do |rec|
+             id         = rec['id'].to_i( 10 )
+             name       = normalize_name( rec['name'] )
+             type       = rec['type']
+
+             more_names = (rec['more_names'] || '').split( '|' )
+             more_names = more_names.map {|str| normalize_name( str ) }
+
+             Metadata::Sprite.new(
+               id:         id,
+               name:       name,
+               type:       type,
+               more_names: more_names )
+           end
+    recs
+ end  # method build_recs
+
+
+
+ def initialize( image_path="./spritesheet.png",
+                 meta_path="./spritesheet.csv",
+                 width: 24,
+                 height: 24 )
+    @width  = width
+    @height = height
+
+    @sheet = ImageComposite.read( image_path, width: @width, height: @height )
+    recs  = CsvHash.read( meta_path )
+
+    @recs = build_recs( recs )
+
+    ## lookup by "case/space-insensitive" name / key
+    @attributes_by_name = build_attributes_by_name( @recs )
+ end
+
+
+ def spritesheet() @sheet; end
+ alias_method  :sheet, :spritesheet
+
+
+ def records() @recs; end
+ alias_method :meta, :records
+
+
+
+
+ def find_meta( q )
+    key = normalize_key( q )  ## normalize q(uery) string/symbol
+
+    rec = @attributes_by_name[ key ]
+    if rec
+       puts " lookup >#{key}< => #{rec.id}: #{rec.name} / #{rec.type}"
+    else
+       puts "!! WARN - no lookup found for key >#{key}<"
+    end
+
+    rec
+ end
+
+ def find( q )
+    rec = find_meta( q )
+
+    ## return image if record found
+    rec ? @sheet[ rec.id ] : nil
+ end
+
+
+ def to_recs( *values )
+      recs       = []
+
+      attribute_names  = values
+
+      attribute_names.each do |attribute_name|
+        attribute = find_meta( attribute_name )
+        if attribute.nil?
+           puts "!! ERROR - attribute >#{attribute_name}< not found; sorry"
+           exit 1
+        end
+        recs << attribute
+      end
+
+      recs
+ end
+
+
+
+ def generate_image( *values, background: nil, before: nil )
+   ## note: generate_image NO longer supports
+   ##             - generate by integer number (indexes), sorry
+
+    recs = to_recs( *values )
+
+    ## note: first construct/generate image on transparent background
+    ##          add background if present as LAST step
+    img = Image.new( @width, @height )
+
+    recs.each do |rec|
+      ## note: before call(back) MUST change image INPLACE!!!!
+      before.call( img, rec )   if before
+      img.compose!( @sheet[ rec.id ] )
+    end
+
+    if background    ## for now assume background is (simply) color
+      img2 = Image.new( @width, @height )
+      img2.compose!( Image.new( @width, @height, background ) )
+      img2.compose!( img )
+      img = img2
+    end
+
+    img
+ end
+ alias_method :generate, :generate_image
+
+ end # class Generator
+
+end # module Pixelart