cryptopunks 1.2.0 → 2.0.0

data/lib/cryptopunks/generator.rb

@@ -0,0 +1,207 @@
+
+module Cryptopunks
+
+  class Metadata
+    ### todo/fix:
+    ##    move into Punks::Metadata or such
+    class Sprite
+      attr_reader :id, :name, :type, :gender
+
+
+      def initialize( id:,
+                      name:,
+                      type:,
+                      gender: )
+         @id     = id      # zero-based index eg. 0,1,2,3, etc.
+         @name   = name
+         @type   = type
+         @gender = gender
+      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 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
+      end
+      h[ key ] = rec
+    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   = rec['name']
+             gender = normalize_gender( rec['gender'] )
+             type   = rec['type']
+
+             Metadata::Sprite.new(
+               id:     id,
+               name:   name,
+               type:   type,
+               gender: gender)
+           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

@@ -0,0 +1,33 @@
+module Cryptopunks
+
+
+
+class Image
+
+def self.read( path )   ## convenience helper
+  img = ChunkyPNG::Image.from_file( path )
+  new( img )
+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
+      ## note: unwrap inner image before passing on to super c'tor
+      img = Pixelart::Image.parse( design, colors: colors ).image
+    end
+
+    super( img.width, img.height, img )
+end
+
+
+
+end  # class Image
+end  # module Cryptopunks

data/lib/cryptopunks/structs.rb

@@ -137,12 +137,25 @@ end  ## (nested) class Accessory
     @birthday    = Date.new( 2017, 6, 23)   ## all 10,000 minted on June 23, 2017
   end
 
-  ## convenience helpers for types (5)
-  def alien?()  @type.name=='Alien'; end
-  def ape?()    @type.name=='Ape'; end
-  def zombie?() @type.name=='Zombie'; end
-  def female?() @type.name=='Female'; end
-  def male?()   @type.name=='Male'; end
+  def is_type?( name ) @type.name == name; end
+  alias_method :is?, :is_type?
+
+  ## convenience helpers for "classic" (5) types
+  def alien?()  is_type?( 'Alien'); end
+  def ape?()    is_type?( 'Ape' ); end
+  def zombie?() is_type?( 'Zombie' ); end
+  def female?() is_type?( 'Female' ); end
+  def male?()   is_type?( 'Male' ); end
+
+  ## convenience helpers to lookup attributes
+  def has_attribute?( name )
+    accessories.each do |acc|
+      return true  if acc.name == name
+    end
+    false
+  end
+  alias_method :has?,     :has_attribute?
+  alias_method :include?, :has_attribute?
 end # class Metadata
 
 end  # module Cryptopunks

data/lib/cryptopunks/tool.rb

@@ -0,0 +1,264 @@
+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|
+  puts
+  puts "*** error: #{e.message}"
+
+  if opts.verbose?
+    puts e.backtrace
+  end
+
+  false # skip default error handling
+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 = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')