cryptopunks 2.0.1 → 2.1.0

data/lib/cryptopunks/generator.rb

@@ -5,18 +5,20 @@ module Cryptopunks
     ### todo/fix:
     ##    move into Punks::Metadata or such
     class Sprite
-      attr_reader :id, :name, :type, :gender, :more_names
+      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
 
@@ -24,6 +26,15 @@ module Cryptopunks
       ##     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
 
@@ -35,32 +46,49 @@ 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 normalize_name( str )
+ 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|
 
+      names.each do |name|
         key = normalize_key( name )
-        key << "_(#{rec.gender})"  if rec.attribute?
+        key << "_(#{rec.gender}+#{rec.size})"  if rec.attribute?
 
         if h[ key ]
           puts "!!! ERROR - attribute name is not unique:"
@@ -98,6 +126,7 @@ module Cryptopunks
              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( '|' )
@@ -108,6 +137,7 @@ module Cryptopunks
                name:       name,
                type:       type,
                gender:     gender,
+               size:       size,
                more_names: more_names )
            end
     recs
@@ -138,24 +168,74 @@ module Cryptopunks
 
 
 
- 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
@@ -164,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"
@@ -179,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
@@ -195,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/tool.rb

@@ -1,5 +1,5 @@
-module Cryptopunks
 
+module Cryptopunks
 
 
 class Tool
@@ -21,6 +21,8 @@ class Opts
     @zoom     = options[:zoom]      if options[:zoom]
     @offset   = options[:offset]    if options[:offset]
 
+    @seed     = options[:seed]      if options[:seed]
+
     @verbose = true     if options[:verbose] == true
   end
 
@@ -45,6 +47,13 @@ class Opts
 
   def outdir()  @outdir || '.'; end
   def outdir?() @outdir;  end
+
+  ### use a standard (default) seed - why? why not?
+  def seed()  @seed || 4142; end
+  def seed?() @seed;  end
+
+
+
 end # class Opts
 
 
@@ -71,12 +80,21 @@ arg_name 'NUM'
 default_value opts.offset
 flag [:offset], type: Integer
 
+
+desc "Seed for random number generation / shuffle"
+arg_name 'NUM'
+default_value opts.seed
+flag [:seed], type: Integer
+
+
+
 desc "Output directory"
 arg_name 'DIR'
 default_value opts.outdir
 flag [:d, :dir,
       :o, :out, :outdir], type: String
 
+
 ### todo/check: move option to -t/--tile command only - why? why not?
 desc "True Official Genuine CryptoPunks™ all-in-one composite image"
 arg_name 'FILE'
@@ -92,6 +110,94 @@ switch [:verbose], negatable: false    ## todo: use -w for short form? check rub
 
 
 
+desc "Flip (vertically) all punk characters in all-in-one punk series composite (#{opts.file})"
+command [:f, :flip] do |c|
+  c.action do |g,o,args|
+    puts "==> reading >#{opts.file}<..."
+    punks = ImageComposite.read( opts.file )
+
+    ## note: for now always assume 24x24
+    cols = punks.width / 24
+    rows = punks.height / 24
+    tile_width = 24
+    tile_height = 24
+
+    phunks = ImageComposite.new( cols, rows,
+                                 width: tile_width,
+                                 height: tile_height )
+
+    punks.each do |punk|
+       phunks << punk.flip_vertically
+    end
+
+    ## make sure outdir exits (default is current working dir e.g. .)
+    FileUtils.mkdir_p( opts.outdir )  unless Dir.exist?( opts.outdir )
+
+    ## note: allways assume .png extension for now
+    basename = File.basename( opts.file, File.extname( opts.file ) )
+    path  = "#{opts.outdir}/#{basename}-flipped.png"
+    puts "==> saving phunks flipped one-by-one by hand to >#{path}<..."
+
+    phunks.save( path )
+    puts 'Done.'
+  end # action
+end # command flip
+
+
+desc "Shuffle all punk characters (randomly) in all-in-one punk series composite (#{opts.file})"
+command [:s, :shuffle] do |c|
+  c.action do |g,o,args|
+    puts "==> reading >#{opts.file}<..."
+    punks = ImageComposite.read( opts.file )
+
+    ## note: for now always assume 24x24
+    cols  = punks.width / 24
+    rows  = punks.height / 24
+    tile_width = 24
+    tile_height = 24
+
+    phunks = ImageComposite.new( cols, rows,
+                                 width: tile_width,
+                                 height: tile_height )
+
+    tiles = cols * rows
+    indexes = (0..tiles-1).to_a
+    srand( opts.seed )     ## note: for new reset **global** random seed and use (builtin) Array#shuffle
+    puts "   using random generation number seed >#{opts.seed}< for shuffle"
+    indexes = indexes.shuffle
+
+    ###
+    # seed 4142 ends in [..., 7566, 828, 8987, 9777]
+    #       333 ends in [..., 6067, 9635, 973, 8172]
+
+
+    indexes.each_with_index do |old_index,new_index|
+       puts "    ##{old_index} now ##{new_index}"
+       phunks << punks[old_index]
+    end
+
+    puts "    all #{tiles} old index numbers (zero-based) for reference using seed #{opts.seed}:"
+    puts indexes.inspect
+
+    ## make sure outdir exits (default is current working dir e.g. .)
+    FileUtils.mkdir_p( opts.outdir )  unless Dir.exist?( opts.outdir )
+
+    ## note: allways assume .png extension for now
+    basename = File.basename( opts.file, File.extname( opts.file ) )
+    path  = "#{opts.outdir}/#{basename}-#{opts.seed}.png"
+    puts "==> saving p(h)unks shuffled one-by-one by hand to >#{path}<..."
+
+    phunks.save( path )
+    puts 'Done.'
+  end # action
+end # command shuffle
+
+
+
+
+
+
+
 desc "Get punk characters via image tiles from all-in-one punk series composite (#{opts.file}) - for IDs use 0 to 9999"
 command [:t, :tile] do |c|
   c.action do |g,o,args|

data/lib/cryptopunks/version.rb

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

data/lib/cryptopunks.rb

@@ -50,24 +50,103 @@ module Cryptopunks
   end
 
   class Image
-     def self.generate( *values )
-       img = Cryptopunks.generator.generate( *values )
+    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
+
+       img = Cryptopunks.generator.generate( *values, style: style )
        ## note: unwrap inner image before passing on to c'tor (requires ChunkyPNG image for now)
        new( img.image )
-     end
+     end # method Image.generate
+
   end # class Image
 
 
   class Spritesheet
     ## note: for now class used for "namespace" only
-    def self.find_by( name:, gender: nil )  ## return archetype/attribute image by name
+    def self.find_by( name:, gender: nil, size: nil )  ## return archetype/attribute image by name
        # note: pass along name as q (query string)
-       Cryptopunks.generator.find( name, gender: gender )
+       Cryptopunks.generator.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 Cryptopunks
 
 
@@ -98,6 +177,12 @@ end ## module Cryptopunks
 ### add some convenience shortcuts
 CryptoPunks = Cryptopunks
 Punks       = Cryptopunks
+## add singular too -why? why not?
+Cryptopunk  = Cryptopunks
+CryptoPunk  = Cryptopunks
+Punk        = Cryptopunks
+
+
 
 
 ###

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cryptopunks
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-17 00:00:00.000000000 Z
+date: 2022-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pixelart
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.2.1
 - !ruby/object:Gem::Dependency
   name: csvreader
   requirement: !ruby/object:Gem::Requirement