punks 0.0.1 → 0.2.0

data/config/punks_xl-32x32.csv

@@ -0,0 +1,49 @@
+id, category, name, more_names
+0, , male1, 
+1, , male2, 
+2, , male3, 
+3, , female1, 
+4, , female2, 
+5, , female3, 
+6, , Zombie 1, Zombie
+7, , zombie2, 
+8, , zombie3, 
+9, , zombie4, 
+10, , Ape 1, Ape
+11, , ape2, 
+12, , ape3, 
+13, , ape4, 
+14, , ape5, 
+15, , ape6, 
+16, , ape7, 
+17, , ape8, 
+18, , Alien 1, Alien
+19, , alien2, 
+20, , alien3, 
+21, , blonde_bob, 
+22, , crazy_hair, 
+23, , half_shaved, 
+24, , mohawk, 
+25, , wild_hair, 
+26, , bandana, 
+27, , beanie, 
+28, , cap_forward, 
+29, , cowboy_hat, 
+30, , headband, 
+31, , knitted_cap, 
+32, , top_hat, 
+33, , 3d_glasses, 
+34, , big_shades, 
+35, , small_shades, 
+36, , nerd_glasses, 
+37, , eye_patch, 
+38, , goat, 
+39, , green_eye_shadow, 
+40, , purple_eye_shadow, 
+41, , hot_lipstick, 
+42, , smile, 
+43, , earring, 
+44, , cigarette, 
+45, , medical_mask, 
+46, , pipe, 
+47, , hoodie, 

data/lib/punks/generator.rb

@@ -0,0 +1,302 @@
+
+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 )
+      archetype_name  = values[0]
+
+      ### 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
+
+      recs       = [archetype]
+
+      attribute_names  = values[1..-1]
+      ## note: attribute lookup requires gender from archetype!!!!
+      attribute_gender = archetype.gender
+      attribute_size   = archetype.size
+
+      attribute_names.each do |attribute_name|
+        attribute = find_meta( attribute_name,
+                               gender: attribute_gender,
+                               size:   attribute_size,
+                               style:  style )
+        if attribute.nil?
+           puts "!! ERROR - attribute >#{attribute_name}< for (#{attribute_gender}+#{attribute_size}) not found; sorry"
+           exit 1
+        end
+        recs << attribute
+      end
+
+      recs
+ end
+
+
+
+
+ def generate_image( *values, style: nil )
+
+    recs = to_recs( *values, style: style )
+
+    punk = @image_class.new( 24, 24 )
+
+    recs.each do |rec|
+      punk.compose!( @sheet[ rec.id ] )
+    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,116 @@
+
+
+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 )
+
+   #####  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|
+           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
+
+       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|
+        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
+
+       generator.generate( *values, style: style )
+     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 = 0
-  PATCH = 1
+  MINOR = 2
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/punks.rb

@@ -1,11 +1,54 @@
 ## 3rd party
 require 'pixelart/base'
-
+require 'backgrounds/base'
+require 'artfactory/base'
 
 
 ## our own code
 require 'punks/version'    # note: let version always go first
 
+require 'punks/generator'
+
+
+## --- 24x24 series
+require 'punks/punks'
+require 'punks/phunks'
+require 'punks/marilyns'
+require 'punks/philips'
+## --- 32x32 series
+require 'punks/punks_xl'
+
+
+
+
+
+### 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