cryptopunks 1.2.1 → 2.0.1

data/lib/cryptopunks/generator.rb

@@ -0,0 +1,223 @@
+
+module Cryptopunks
+
+  class Metadata
+    ### todo/fix:
+    ##    move into Punks::Metadata or such
+    class Sprite
+      attr_reader :id, :name, :type, :gender, :more_names
+
+
+      def initialize( id:,
+                      name:,
+                      type:,
+                      gender:,
+                      more_names: [] )
+         @id         = id      # zero-based index eg. 0,1,2,3, etc.
+         @name       = name
+         @type       = type
+         @gender     = gender
+         @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
+   end  # class Metadata::Sprite
+  end # class Metadata
+
+
+
+
+  class Generator
+
+ ######
+ # static helpers  - (turn into "true" static self.class methods - why? why not?)
+ #
+ def normalize_key( str )
+    str.downcase.gsub(/[ ()°_-]/, '').strip
+ end
+
+ def normalize_gender( str )
+    ## e.g. Female => f
+    ##      F => f
+    ##  always return f or m
+    str.downcase[0]
+ end
+
+ def normalize_name( str )
+   ## normalize spaces in more names
+   str.strip.gsub( /[ ]{2,}/, ' ' )
+ 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})"  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'] )
+             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,
+               more_names: more_names )
+           end
+    recs
+ end  # method build_recs
+
+
+
+
+ def initialize( image_path="./spritesheet.png",
+                 meta_path="./spritesheet.csv" )
+    @sheet = Pixelart::ImageComposite.read( image_path )
+    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 )  ## 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
+    else
+       puts "!! WARN - no lookup found for key >#{key}<"
+    end
+    rec
+ end
+
+
+ def find( q, gender: nil )  ## gender (m/f) required for attributes!!!
+    rec = find_meta( q, gender: gender )
+
+    ## return image if record found
+    rec ? @sheet[ rec.id ] : nil
+ end
+
+
+
+
+ def to_recs( *values )
+      archetype_name  = values[0]
+
+      ### todo/fix:  check for nil/not found!!!!
+      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_names.each do |attribute_name|
+        attribute = find_meta( attribute_name, gender: attribute_gender )
+        if attribute.nil?
+           puts "!! ERROR - attribute >#{attribute_name}< for (#{attribute_gender}) not found; sorry"
+           exit 1
+        end
+        recs << attribute
+      end
+
+      recs
+ end
+
+
+
+
+ def generate_image( *values, 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 }
+          end
+
+
+    punk = Pixelart::Image.new( 24, 24 )
+
+    if background    ## for now assume background is (simply) color
+       punk.compose!( Pixelart::Image.new( 24, 24, background ) )
+    end
+
+    ids.each do |id|
+      punk.compose!( @sheet[ id ] )
+    end
+
+    punk
+ end
+ alias_method :generate, :generate_image
+
+ end # class Generator
+
+end # module Cryptopunks

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 = inital
+      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

data/lib/cryptopunks/tool.rb

@@ -0,0 +1,275 @@
+module Cryptopunks
+
+
+
+class Tool
+  def run( args )
+    Toolii.run( args )
+  end
+end
+
+
+
+class Opts
+  def merge_gli_options!( options = {} )
+    # puts "  update options:"
+    # puts options.inspect
+
+    @file     = options[:file]      if options[:file]
+    @outdir   = options[:dir]       if options[:dir]
+
+    @zoom     = options[:zoom]      if options[:zoom]
+    @offset   = options[:offset]    if options[:offset]
+
+    @verbose = true     if options[:verbose] == true
+  end
+
+
+  def verbose=(boolean)   # add: alias for debug ??
+    @verbose = boolean
+  end
+
+  def verbose?
+    return false if @verbose.nil?   # default verbose/debug flag is false
+    @verbose == true
+  end
+
+  def file()    @file || './punks.png';  end
+  def file?()   @file;  end    ## note: let's you check if file is set (or "untouched")
+
+  def zoom()    @zoom || 1; end
+  def zoom?()   @zoom;  end
+
+  def offset()  @offset || 0; end
+  def offset?() @offset;  end
+
+  def outdir()  @outdir || '.'; end
+  def outdir?() @outdir;  end
+end # class Opts
+
+
+
+## note: use gli "dsl" inside a class / namespace
+class Toolii
+   extend GLI::App
+
+   opts = Opts.new
+
+
+program_desc 'punk (or cryptopunk) command line tool'
+
+version Cryptopunks::VERSION
+
+
+desc "Zoom factor x2, x4, x8, etc."
+arg_name 'ZOOM'
+default_value opts.zoom
+flag [:z, :zoom], type: Integer
+
+desc "Start counting at offset"
+arg_name 'NUM'
+default_value opts.offset
+flag [:offset], 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'
+default_value opts.file
+flag [:f, :file], type: String
+
+
+
+### global option (required)
+## todo: add check that path is valid?? possible?
+desc '(Debug) Show debug messages'
+switch [:verbose], negatable: false    ## todo: use -w for short form? check ruby interpreter if in use too?
+
+
+
+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|
+
+    # puts "opts:"
+    # puts opts.inspect
+
+    puts "==> reading >#{opts.file}<..."
+    punks = ImageComposite.read( opts.file )
+
+
+    puts "    setting zoom to #{opts.zoom}x"   if opts.zoom != 1
+
+    ## make sure outdir exits (default is current working dir e.g. .)
+    FileUtils.mkdir_p( opts.outdir )  unless Dir.exist?( opts.outdir )
+
+    args.each_with_index do |arg,index|
+      punk_index = arg.to_i( 10 )  ## assume base 10 decimal
+
+      punk = punks[ punk_index ]
+
+      punk_name = "punk-" + "%04d" % (punk_index + opts.offset)
+
+      ##  if zoom - add x2,x4 or such
+      if opts.zoom != 1
+        punk = punk.zoom( opts.zoom )
+        punk_name << "@#{opts.zoom}x"
+      end
+
+      path  = "#{opts.outdir}/#{punk_name}.png"
+      puts "==> (#{index+1}/#{args.size}) saving punk ##{punk_index+opts.offset} to >#{path}<..."
+
+      punk.save( path )
+    end
+    puts 'Done.'
+  end # action
+end # command tile
+
+
+
+desc 'Generate punk characters from text attributes (from scratch / zero) via builtin punk spritesheet'
+command [:g, :gen, :generate] do |c|
+  c.action do |g,o,args|
+
+    puts "==> generating  >#{args.join( ' + ' )}<..."
+    punk = Image.generate( *args )
+
+    puts "    setting zoom to #{opts.zoom}x"   if opts.zoom != 1
+
+    ## make sure outdir exits (default is current working dir e.g. .)
+    FileUtils.mkdir_p( opts.outdir )  unless Dir.exist?( opts.outdir )
+
+    punk_index = 0    ## assume base 10 decimal
+    punk_name = "punk-" + "%04d" % (punk_index + opts.offset)
+
+    ##  if zoom - add x2,x4 or such
+    if opts.zoom != 1
+      punk = punk.zoom( opts.zoom )
+      punk_name << "@#{opts.zoom}x"
+    end
+
+    path  = "#{opts.outdir}/#{punk_name}.png"
+    puts "==> saving punk ##{punk_index+opts.offset} to >#{path}<..."
+
+    punk.save( path )
+    puts 'Done.'
+  end # action
+end # command generate
+
+
+desc 'Query (builtin off-chain) punk contract for punk text attributes by IDs - use 0 to 9999'
+command [:q, :query] do |c|
+  c.action do |g,o,args|
+
+    # puts "opts:"
+    # puts opts.inspect
+
+    args.each_with_index do |arg,index|
+      punk_index = arg.to_i( 10 )  ## assume base 10 decimal
+
+      puts "==> (#{index+1}/#{args.size}) punk ##{punk_index}..."
+
+      attribute_names = CryptopunksData.punk_attributes( punk_index )
+      ## downcase name and change spaces to underscore
+      attribute_names = attribute_names.map do |name|
+                          name.downcase.gsub( ' ', '_' )
+                        end
+
+      print "  "
+      print attribute_names.join( '  ' )
+      print "\n"
+    end
+    puts 'Done.'
+  end
+end
+
+
+
+desc 'List all punk archetype and attribute names from builtin punk spritesheet'
+command [:l, :ls, :list] do |c|
+  c.action do |g,o,args|
+
+    generator = Cryptopunks.generator
+
+    puts "==> Archetypes"
+    generator.meta.each do |rec|
+      next unless rec.archetype?
+
+      print "  "
+      print "%-30s"  % "#{rec.name} / (#{rec.gender})"
+      print " - #{rec.type}"
+      print "\n"
+    end
+
+    puts ""
+    puts "==> Attributes"
+    generator.meta.each do |rec|
+      next unless rec.attribute?
+
+      print "  "
+      print "%-30s"  % "#{rec.name} / (#{rec.gender})"
+      print " - #{rec.type}"
+      print "\n"
+    end
+
+    puts ""
+    puts "  See github.com/cryptopunksnotdead/punks.spritesheet for more."
+    puts ""
+
+    puts 'Done.'
+  end # action
+end # command list
+
+
+
+pre do |g,c,o,args|
+  opts.merge_gli_options!( g )
+  opts.merge_gli_options!( o )
+
+  if opts.verbose?
+    ## LogUtils::Logger.root.level = :debug
+  end
+
+  ## logger.debug "Executing #{c.name}"
+  true
+end
+
+post do |global,c,o,args|
+  ## logger.debug "Executed #{c.name}"
+  true
+end
+
+
+on_error do |e|
+
+  if opts.verbose?
+    puts e.backtrace
+  end
+
+  if e.is_a?( SystemExit )
+     puts
+     puts "*** error: system exit with status code ( #{e.status} )"
+     exit( e.status )   ## try exit again to make sure error code gets passed along!!!
+  else
+    puts
+    puts "*** error: #{e.message}"
+  end
+
+  ## note: was false    # skip default error handling
+
+  ## note: try true - false WILL SWALLOW exit codes and such
+  ##  - looks like it's still returning 0 (e.g. on unknown option or such)!!!!
+  true
+end
+
+
+### exit run(ARGV)  ## note: use Toolii.run( ARGV ) outside of class
+end   # class Toolii
+end # module Cryptopunks
+
+

data/lib/cryptopunks/version.rb

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