punks 0.1.0 → 0.2.1

data/lib/punks/generator.rb

@@ -0,0 +1,329 @@
+
+module Punk
+
+  class Metadata
+    ### todo/fix:
+    ##    move into Punks::Metadata or such
+    class Sprite
+      attr_reader :id, :name, :type, :gender, :size, :more_names
+
+
+      def initialize( id:,
+                      name:,
+                      type:,
+                      gender:,
+                      size:,
+                      more_names: [] )
+         @id         = id      # zero-based index eg. 0,1,2,3, etc.
+         @name       = name
+         @type       = type
+         @gender     = gender
+         @size       = size
+         @more_names = more_names
+      end
+
+      ## todo/check - find better names for type attribute/archetypes?
+      ##     use (alternate name/alias) base or face  for archetypes? any others?
+      def attribute?()  @type.downcase.start_with?( 'attribute' ); end
+      def archetype?()  @type.downcase.start_with?( 'archetype' ); end
+
+      def small?()     @size == 's'; end
+      def large?()     @size == 'l'; end
+      def universal?() @size == 'u'; end
+      alias_method  :unisize?, :universal?   ## add unisize or allsizes or such - why? why not?
+
+      def male?()      @gender == 'm'; end
+      def female?()    @gender == 'f'; end
+      def unisex?()    @gender == 'u'; 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
+    str.downcase.gsub(/[ ()&°_-]/, '').strip
+ end
+
+ def self.normalize_gender( str )
+    ## e.g. Female => f
+    ##      F => f
+    ##  always return f/m
+    str.downcase[0]
+ end
+
+ def self.normalize_size( str )
+    ## e.g. U or Unisize or Univeral => u
+    ##      S or Small               => s
+    ##      L or Large               => l
+    ##   always return u/l/s
+    str.downcase[0]
+ 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_gender( str )  self.class.normalize_gender( str ); end
+ def normalize_size( str )    self.class.normalize_size( 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 )
+        key << "_(#{rec.gender}+#{rec.size})"  if rec.attribute?
+
+        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'] )
+             gender     = normalize_gender( rec['gender'] )
+             size       = normalize_size( rec['size'] )
+             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,
+               gender:     gender,
+               size:       size,
+               more_names: more_names )
+           end
+    recs
+ end  # method build_recs
+
+
+
+
+ def initialize( image_path="./spritesheet.png",
+                 meta_path="./spritesheet.csv",
+                 image_class: )
+    @image_class  = image_class
+
+    @sheet = Pixelart::ImageComposite.read( image_path,
+                                              width: 24,
+                                              height: 24 )
+    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, gender: nil,
+                   size: nil,
+                   style: nil )   ## note: gender (m/f) required for attributes!!!
+
+    key = normalize_key( q )  ## normalize q(uery) string/symbol
+
+    keys = []    ## note allow lookup by more than one keys
+                    ##  e.g. if gender set try   f/m first and than try unisex as fallback
+    if gender
+       gender = normalize_gender( gender )
+       ## auto-fill size if not passed in
+       ##    for f(emale)  =>   s(mall)
+       ##        m(ale)    =>   l(arge)
+       size =  if size.nil?
+                 gender == 'f' ? 's' : 'l'
+               else
+                 normalize_size( size )
+               end
+
+       ###
+       #  try (auto-add) style-specific version first (fallback to "regular" if not found)
+       if style
+         ## for now only support natural series
+         style_key =  if style.downcase.start_with?( 'natural' )
+                          'natural'
+                      else
+                        puts "!! ERROR - unknown attribute style #{style}; sorry"
+                        exit 1
+                      end
+
+         keys << "#{key}#{style_key}_(#{gender}+#{size})"
+         ## auto-add (u)niversal size as fallback
+         keys << "#{key}#{style_key}_(#{gender}+u)"  if size == 's' || size == 'l'
+         ## auto-add u(nisex) as fallback
+         keys << "#{key}#{style_key}_(u+#{size})"    if gender == 'f' || gender == 'm'
+       end
+
+
+       keys << "#{key}_(#{gender}+#{size})"
+       ## auto-add (u)niversal size as fallback
+       keys << "#{key}_(#{gender}+u)"  if size == 's' || size == 'l'
+       ## auto-add u(nisex) as fallback
+       keys << "#{key}_(u+#{size})"    if gender == 'f' || gender == 'm'
+    else
+       keys << key
+    end
+
+
+    rec = nil
+    keys.each do |key|
+       rec = @attributes_by_name[ key ]
+       if rec
+         puts " lookup >#{key}< => #{rec.id}: #{rec.name} / #{rec.type} (#{rec.gender}+#{rec.size})"
+         # pp rec
+         break
+       end
+    end
+
+    if rec.nil?
+       puts "!! WARN - no lookup found for #{keys.size} key(s) >#{keys.inspect}<"
+    end
+
+    rec
+ end
+
+
+ def find( q, gender: nil, size: nil, style: nil )  ## gender (m/f) required for attributes!!!
+    rec = find_meta( q, gender: gender, size: size, style: style )
+
+    ## return image if record found
+    rec ? @sheet[ rec.id ] : nil
+ end
+
+
+
+
+ def to_recs( *values, style: nil, patch: nil )
+      archetype_name  = values[0]
+
+      if archetype_name.is_a?( Pixelart::Image )
+         archetype = archetype_name
+      elsif patch && img=patch[ normalize_key(archetype_name) ]
+         archetype = img
+      else ## assume it's a string
+        ### todo/fix:  check for nil/not found!!!!
+        ## todo/check/fix:  assert meta record returned is archetype NOT attribute!!!!
+        archetype  = find_meta( archetype_name )
+        if archetype.nil?
+          puts "!! ERROR -  archetype >#{archetype}< not found; sorry"
+          exit 1
+        end
+      end
+
+      recs       = [archetype]
+
+      ## note: attribute lookup requires gender from archetype!!!!
+      if archetype.is_a?( Pixelart::Image )
+         ### for now assume (support only)
+         ##    large & unisex (u&u) for "inline/patch" archetypes - why? why not?
+         attribute_gender = 'u'
+         attribute_size   = 'l'
+      else
+         attribute_gender = archetype.gender
+         attribute_size   = archetype.size
+      end
+
+      attribute_names  = values[1..-1]
+      attribute_names.each do |attribute_name|
+         ## note: quick hack - allow "inline" raw images for now - why? why not?
+         ##         pass through as-is
+        if attribute_name.is_a?( Pixelart::Image )
+          recs << attribute_name
+        elsif patch && img=patch[ normalize_key(attribute_name) ]
+          recs << img
+        else
+          rec = find_meta( attribute_name,
+                           gender: attribute_gender,
+                           size:   attribute_size,
+                           style:  style )
+          if rec.nil?
+            puts "!! ERROR - attribute >#{attribute_name}< for (#{attribute_gender}+#{attribute_size}) not found; sorry"
+            exit 1
+          end
+          recs << rec
+         end
+      end
+
+      recs
+ end
+
+
+
+
+ def generate_image( *values, style: nil, patch: nil )
+   ## check: rename patch to more/extras/foreign or ... - why? why not?
+
+    recs = to_recs( *values, style: style, patch: patch )
+
+    punk = @image_class.new( 24, 24 )
+
+    recs.each do |rec|
+      ## note: quick hack - allow "inline" raw images for now - why? why not?
+      ##         pass through as-is
+      img = if rec.is_a?( Pixelart::Image )
+              rec
+            else
+              @sheet[ rec.id ]
+            end
+      punk.compose!( img )
+    end
+
+    punk
+ end
+ alias_method :generate, :generate_image
+
+ end # class Generator
+
+end # module Punk

data/lib/punks/marilyns.rb

@@ -0,0 +1,20 @@
+
+
+module Marilyn
+
+  class Image < Pixelart::Image
+
+    MARILYN_ATTRIBUTES = ['Female 3', 'Wild Blonde', 'Mole',
+                          'Blue Eye Shadow']
+
+    def self.generate( *values, style: nil )
+        punk = Punk::Image.generate( *MARILYN_ATTRIBUTES,
+                                     *values, style: style )
+        phunk = punk.mirror
+
+        ## wrap in Marilyn class (note: use/ requires inner image)
+        new( phunk.width, phunk.height, phunk.image )
+    end
+  end # class Image
+end  # module Marilyn
+

data/lib/punks/philips.rb

@@ -0,0 +1,24 @@
+
+
+module Philip
+
+  class Image < Pixelart::Image
+
+    ## note: right-looking ("pre-phlipped") philip
+    PHILIP = Pixelart::Image.read( "#{Pixelart::Module::Punks.root}/config/philip-24x24.png" )
+
+    def self.generate( *values )
+        punk = Image.new( 24, 24 )
+        punk.compose!( PHILIP )
+
+        values.each do |name|
+          attribute = Punk::Sheet.find_by( name: name,
+                                           gender: 'm' )
+          punk.compose!( attribute )
+        end
+
+        phunk = punk.mirror
+        phunk
+    end
+  end # class Image
+end  # module Philip

data/lib/punks/phunks.rb

@@ -0,0 +1,14 @@
+
+module Phunk
+
+  class Image < Pixelart::Image
+
+    def self.generate( *values, style: nil )
+        punk = Punk::Image.generate( *values, style: style )
+        phunk = punk.mirror
+
+        ## wrap in Phunks class (note: use/ requires inner image)
+        new( phunk.width, phunk.height, phunk.image )
+    end
+  end # class Image
+end  # module Phunk

data/lib/punks/punks.rb

@@ -0,0 +1,123 @@
+
+
+module Punk
+
+  class Image < Pixelart::Image
+    def self.generator
+      ### todo/fix:  break out/ split off spritesheet from generator!!!!
+      @generator ||= Generator.new(  "#{Pixelart::Module::Punks.root}/config/punks-24x24.png",
+                                     "#{Pixelart::Module::Punks.root}/config/punks-24x24.csv", image_class: Image )
+    end
+
+
+    def self.generate( *values, style: nil, patch: nil )
+
+     if values[0].is_a?( String )
+       #####  add style option / hack - why? why not?
+       if style
+         values =  if style.downcase.index( 'natural') && style.downcase.index( '2')
+                     ["#{values[0]} (N2)"] + values[1..-1]
+                   elsif style.downcase[0] == 'n'  ## starting with n - always assume natural(s)
+                    ## auto-add (N) for Natural to archetype
+                     ["#{values[0]} (N)"] + values[1..-1]
+                   else
+                     puts "!! ERROR - unknown punk style #{style}; sorry"
+                     exit 1
+                   end
+       end
+
+     ###### hack for black&white
+     ##   auto-add b&w (black&white) to all attribute names e.g.
+     ##      Eyes   =>  Eyes B&W
+     ##      Smile  =>  Smile B&W
+     ##      ....
+      archetype_key =  Generator.normalize_key( values[0] )
+       if archetype_key.end_with?( 'bw' ) ||  ## e.g. B&W
+          archetype_key.end_with?( '1bit')    ## e.g. 1-Bit or 1Bit
+
+          values = [values[0]] + values[1..-1].map do |attribute|
+             if attribute.is_a?( Pixelart::Image )
+                attribute
+             else
+                attribute_key = Generator.normalize_key( attribute )
+                if ['wildhair'].include?( attribute_key )   ## pass through known b&w attributes by "default"
+                   attribute
+                elsif attribute_key.index( "black" )
+                   attribute ## pass through as-is
+                else
+                  "#{attribute} B&W"
+                end
+             end
+         end
+
+         pp values
+      end
+
+    # note: female mouth by default has "custom" colors (not black)
+    #          for every 1/2/3/4 (human) skin tone and for zombie
+    #   auto-"magically" add mapping
+    #
+    #  todo/check/fix - add more "contraints"
+    #    for mapping to only kick-in for "basic" versions
+    #      and not "colored" e.g. golden and such - why? why not?
+    #
+    #    move this mapping here to "post-lookup" processing
+    #   to get/incl. more "meta" attribute info  - why? why not?
+    if archetype_key.index( 'female1' ) ||
+       archetype_key.index( 'female2' ) ||
+       archetype_key.index( 'female3' ) ||
+       archetype_key.index( 'female4' ) ||
+       archetype_key.index( 'zombiefemale' )
+
+      values = [values[0]] + values[1..-1].map do |attribute|
+        if attribute.is_a?( Pixelart::Image )
+          attribute
+        else
+          attribute_key = Generator.normalize_key( attribute )
+
+          if attribute_key == 'smile' || attribute_key == 'frown'
+             attribute +=   if    archetype_key.index( 'zombiefemale' ) then ' Zombie'
+                            elsif archetype_key.index( 'female1' )      then ' 1'
+                            elsif archetype_key.index( 'female2' )      then ' 2'
+                            elsif archetype_key.index( 'female3' )      then ' 3'
+                            elsif archetype_key.index( 'female4' )      then ' 4'
+                            else
+                              puts "!! ERROR - smile or frown (mouth expression) not supported for archetype:"
+                              pp values
+                              exit 1
+                            end
+           end
+           attribute
+        end
+      end
+    end
+   end
+
+       generator.generate( *values, style: style, patch: patch )
+     end # method Image.generate
+  end # class Image
+
+
+
+  class Spritesheet
+    def self.builtin
+       ## for now get spritesheet via generator
+       Image.generator
+    end
+    ## note: for now class used for "namespace" only
+    def self.find_by( name:, gender: nil, size: nil )  ## return archetype/attribute image by name
+       # note: pass along name as q (query string)
+       builtin.find( name,
+                     gender: gender,
+                     size:   size )
+    end
+  end  # class Spritesheet
+  ## add convenience (alternate spelling) alias - why? why not?
+  SpriteSheet = Spritesheet
+  Sheet       = Spritesheet
+  Sprite      = Spritesheet
+end #  module Punk
+
+
+
+

data/lib/punks/punks_xl.rb

@@ -0,0 +1,36 @@
+
+
+module Punkxl
+
+  class Spritesheet
+    def self.builtin
+      @builtin ||= Pixelart::Spritesheet.read(  "#{Pixelart::Module::Punks.root}/config/punks_xl-32x32.png",
+                                                "#{Pixelart::Module::Punks.root}/config/punks_xl-32x32.csv",
+                                                width:  32,
+                                                height: 32 )
+    end
+
+    ## note: for now class used for "namespace" only
+    def self.find_by( name: )  ## return archetype/attribute image by name
+       builtin.find_by( name: name )
+    end
+  end  # class Spritesheet
+  ## add convenience (alternate spelling) alias - why? why not?
+  SpriteSheet = Spritesheet
+  Sheet       = Spritesheet
+  Sprite      = Spritesheet
+
+
+  class Image  <  Pixelart::Image
+    def self.generator
+      @generator ||= Artfactory.use( Punkxl::Sheet.builtin,
+                                     image_class: Image )
+    end
+    def self.generate( *names )
+      generator.generate( *names )
+    end
+  end # class Image
+
+
+end #  module Punkxl
+

data/lib/punks/version.rb

@@ -4,8 +4,8 @@ module Module
 module Punks
 
   MAJOR = 0
-  MINOR = 1
-  PATCH = 0
+  MINOR = 2
+  PATCH = 1
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/punks.rb

@@ -1,57 +1,54 @@
 ## 3rd party
 require 'pixelart/base'
 require 'backgrounds/base'
-require 'artfactory'    ### todo/fix: change to artfactory/base
+require 'artfactory/base'
 
 
 ## our own code
 require 'punks/version'    # note: let version always go first
 
+require 'punks/generator'
 
 
-###
-## add convenience pre-configurated generatored with build-in spritesheet (see config)
-
-module Punkxl
-
-  class Spritesheet
-    def self.builtin
-      @builtin ||= Pixelart::Spritesheet.read(  "#{Pixelart::Module::Punks.root}/config/punks_xl-32x32.png",
-                                                "#{Pixelart::Module::Punks.root}/config/punks_xl-32x32.csv",
-                                                width:  32,
-                                                height: 32 )
-    end
+## --- 24x24 series
+require 'punks/punks'
+require 'punks/phunks'
+require 'punks/marilyns'
+require 'punks/philips'
+## --- 32x32 series
+require 'punks/punks_xl'
 
-    ## note: for now class used for "namespace" only
-    def self.find_by( name: )  ## return archetype/attribute image by name
-       builtin.find_by( name: name )
-    end
-  end  # class Spritesheet
-  ## add convenience (alternate spelling) alias - why? why not?
-  SpriteSheet = Spritesheet
-  Sheet       = Spritesheet
-  Sprite      = Spritesheet
 
 
-  class Image  <  Pixelart::Image
-    def self.generator
-      @generator ||= Artfactory.use( Punkxl::Sheet.builtin )
-    end
-    def self.generate( *names )
-      img =  generator.generate( *names )
-       ## note: unwrap inner image before passing on to c'tor (requires ChunkyPNG image for now)
-       new( 32, 32, img.image )
-     end # method Image.generate
-  end # class Image
 
 
-end #  module Punkxl
+### add some convenience shortcuts
+Cryptopunks = Punk
+CryptoPunks = Punk
+Punks       = Punk
+## add singular too -why? why not?
+Cryptopunk  = Punk
+CryptoPunk  = Punk
 
 
 ### add some convenience shortcuts / alternate spelling variants
 PunkXL = Punkxl
 PunkXl = Punkxl
 
+### add some convenience shortcuts / alternate spelling variants
+Phunks  = Phunk
+
+### add some convenience shortcuts / alternate spelling variants
+Philips = Philip
+
+### add some convenience shortcuts / alternate spelling variants
+Marilyns = Marilyn
+
+
+
+###
+# note: for convenience auto include Pixelart namespace!!! - why? why not?
+include Pixelart