cryptopunks 1.2.2 → 2.1.0

data/lib/cryptopunks/generator.rb

@@ -5,23 +5,36 @@ module Cryptopunks
     ### todo/fix:
     ##    move into Punks::Metadata or such
     class Sprite
-      attr_reader :id, :name, :type, :gender
+      attr_reader :id, :name, :type, :gender, :size, :more_names
 
 
       def initialize( id:,
                       name:,
                       type:,
-                      gender: )
-         @id     = id      # zero-based index eg. 0,1,2,3, etc.
-         @name   = name
-         @type   = type
-         @gender = gender
+                      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
 
@@ -33,33 +46,60 @@ module Cryptopunks
  ######
  # static helpers  - (turn into "true" static self.class methods - why? why not?)
  #
- def normalize_key( str )
-    str.downcase.gsub(/[ ()°_-]/, '').strip
+ def self.normalize_key( str )
+   ## add & e.g. B&W
+    str.downcase.gsub(/[ ()&°_-]/, '').strip
  end
 
- def normalize_gender( str )
+ def self.normalize_gender( str )
     ## e.g. Female => f
     ##      F => f
-    ##  always return f or m
+    ##  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|
-      key = normalize_key( rec.name )
-      key << "_(#{rec.gender})"  if rec.attribute?
-
-      if h[ key ]
-        puts "!!! ERROR - attribute name is not unique:"
-        pp rec
-        puts "duplicate:"
-        pp h[key]
-        exit 1
+      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
-      h[ key ] = rec
-    end
+   end
     ## pp h
     h
  end
@@ -83,16 +123,22 @@ module Cryptopunks
 
     ## convert to "wrapped / immutable" kind-of struct
     recs = recs.map do |rec|
-             id     = rec['id'].to_i( 10 )
-             name   = rec['name']
-             gender = normalize_gender( rec['gender'] )
-             type   = rec['type']
+             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)
+               id:         id,
+               name:       name,
+               type:       type,
+               gender:     gender,
+               size:       size,
+               more_names: more_names )
            end
     recs
  end  # method build_recs
@@ -116,27 +162,80 @@ module Cryptopunks
  alias_method  :sheet, :spritesheet
 
 
+ def records() @recs; end
+ alias_method :meta, :records
 
 
 
- def find_meta( q, gender: nil )  ## gender (m/f) required for attributes!!!
+
+ 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
-    key << "_(#{normalize_gender( gender )})"  if gender
 
-    rec = @attributes_by_name[ key ]
-    if rec
-       puts " lookup >#{key}< => #{rec.id}: #{rec.name} / #{rec.type} (#{rec.gender})"
-       # pp rec
+    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
-       puts "!! WARN - no lookup found for key >#{key}<"
+       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 )  ## gender (m/f) required for attributes!!!
-    rec = find_meta( q, gender: gender )
+ 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
@@ -145,10 +244,11 @@ module Cryptopunks
 
 
 
- def to_recs( *values )
+ 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"
@@ -160,11 +260,15 @@ module Cryptopunks
       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 )
+        attribute = find_meta( attribute_name,
+                               gender: attribute_gender,
+                               size:   attribute_size,
+                               style:  style )
         if attribute.nil?
-           puts "!! ERROR - attribute >#{attribute_name}< for (#{attribute_gender}) not found; sorry"
+           puts "!! ERROR - attribute >#{attribute_name}< for (#{attribute_gender}+#{attribute_size}) not found; sorry"
            exit 1
         end
         recs << attribute
@@ -176,12 +280,13 @@ module Cryptopunks
 
 
 
- def generate_image( *values, background: nil )
+ def generate_image( *values, style: nil,
+                              background: nil )
 
     ids = if values[0].is_a?( Integer )  ## assume integer number (indexes)
               values
           else ## assume strings (names)
-              to_recs( *values ).map { |rec| rec.id }
+              to_recs( *values, style: style ).map { |rec| rec.id }
           end
 
 

data/lib/cryptopunks/image.rb

@@ -1,45 +1,6 @@
 module Cryptopunks
 
 
-class Design   ## todo/fix - move to its own file!!!
-
-end # class Design
-
-
-
-##############
-## todo/check:
-##    find a better way to (auto?) include more designs?
-class DesignSeries    ## find a better name for class (just use Series?) - why? why not?
-  def self.build( dir )
-    data = {}
-    paths =  Dir.glob( "#{dir}/**.txt" )
-    paths.each do |path|
-      basename = File.basename( path, File.extname( path ) )
-      text = File.open( path, 'r:utf-8' ) { |f| f.read }
-      ## todo/check: auto-parse "ahead of time" here
-      ##              or keep "raw" text - why? why not?
-      data[ basename ] = text
-    end
-    data
-  end
-
-  def initialize( dir )
-    @dir = dir  # e.g. "#{Cryptopunks.root}/config/more"
-  end
-
-  def data
-    ## note: lazy load / build on first demand only
-    @data ||= self.class.build( @dir )
-  end
-
-  def [](key) data[ key ]; end
-  def size()    data.size; end
-  def keys()    data.keys; end
-  def to_h()    data; end    ## todo/check: use to_hash() - why? why not?
-end   # class DesignSeries
-
-
 
 class Image
 
@@ -49,65 +10,16 @@ def self.read( path )   ## convenience helper
 end
 
 
+
+### keep design & colors keyword args in c'tor here
+##     or use parse() like in pixelart - why? why not?
+
 def initialize( initial=nil, design: nil,
                              colors: nil )
     if initial
       ## pass image through as-is
       img = initial
     else
-
-      ## todo/fix:
-      ## move design code into design class!!!
-      ##  for now assume design is a string
-      ##   split into parts
-      ##       original/alien-male or original@alien-male
-      ##       more/alien-female or more@alien-female
-      ##       original/human-male+darker or original@human-male!darker ????
-      ##        human-male!darker ?????
-      ##    keep @ as separator too - why? why not?
-      parts = design.split( %r{[@/]} )
-      parts.unshift( '*' )    if parts.size == 1  ## assume "all-in-one" series (use * as name/id/placeholder)
-
-      series_key        = parts[0]
-      design_composite  = parts[1]
-
-      ## todo/check - find a way for unambigious (color) variant key
-      ##   use unique char e.g. +*!# or such
-      more_parts = design_composite.split(  %r{[!+]} )
-      design_key   = more_parts[0]
-      variant_key  = more_parts[1]     ## color variant for now (for humans) e.g. lighter/light/dark/darker
-
-      series = if ['*','**','_','__'].include?( series_key )
-                  DESIGNS    ## use all-series-in-one collection
-               else
-                  case series_key
-                  when 'original' then DESIGNS_ORIGINAL
-                  when 'more'     then DESIGNS_MORE
-                  else  raise ArgumentError, "unknown design series >#{series_key}<; sorry"
-                  end
-               end
-
-      design = series[ design_key ]
-      raise ArgumentError, "unknow design >#{design_key}< in series >#{series_key}<; sorry"  if design.nil?
-
-      if colors.nil?  ## try to auto-fill in colors
-         ##  note: (auto-)remove _male,_female qualifier if exist
-         colors_key = design_key.sub( '-male', '' ).sub( '-female', '' )
-         colors =  COLORS[ colors_key ]
-
-         ## allow / support color scheme variants (e.g. lighter/light/dark/darker) etc.
-         if colors.is_a?(Hash)
-           if variant_key
-             colors = colors[ variant_key ]
-             raise ArgumentError, "no colors defined for variant >#{variant_key}< for design >#{design_key}< in series >#{series_key}<; sorry"   if colors.nil?
-           else  ## note: use (fallback to) first color scheme if no variant key present
-             colors = colors[ colors.keys[0] ]
-           end
-         end
-
-         raise ArgumentError, "no (default) colors defined for design >#{design_key}< in series >#{series_key}<; sorry"   if colors.nil?
-      end
-
       ## note: unwrap inner image before passing on to super c'tor
       img = Pixelart::Image.parse( design, colors: colors ).image
     end