artbase-cocos 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 631db0140f623a59d67e52957f2b9f58020239dc02a3b5ac2aa9e15126a9df85
+  data.tar.gz: edbfda7a4d05e2827c7229def1d25e6b0146319bfbcf8cb8e81d77997c83829e
+SHA512:
+  metadata.gz: 480f00c1d0b1f303037373787293302997287323b4f2b41b5d7db8741430ad39c98cfec0edd516a842a718bafb0a476e5f93bcf7d48f64af07432025f0bf25e3
+  data.tar.gz: 6e1e364752bce64215a32f93b29eda79742698d6dc65c4ca9a7737c359a054bf20073cdd1181eadc6fa09c5c7f5c34f32223722d359b03c10d0c867db9d09164

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.0.1 / 2022-11-26
+
+* Everything is new. First release

data/Manifest.txt

@@ -0,0 +1,15 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/artbase-cocos.rb
+lib/artbase-cocos/attributes.rb
+lib/artbase-cocos/collection/base.rb
+lib/artbase-cocos/collection/image.rb
+lib/artbase-cocos/collection/token.rb
+lib/artbase-cocos/collection/token_meta.rb
+lib/artbase-cocos/helper.rb
+lib/artbase-cocos/image.rb
+lib/artbase-cocos/image/sample.rb
+lib/artbase-cocos/retry.rb
+lib/artbase-cocos/version.rb

data/README.md

@@ -0,0 +1,27 @@
+# artbase-cocos - artbase (shared) code commons (cocos); read artbase collection configs & metadata; download collection token metadata, images, and more
+
+
+* home  :: [github.com/pixelartexchange/artbase](https://github.com/pixelartexchange/artbase)
+* bugs  :: [github.com/pixelartexchange/artbase/issues](https://github.com/pixelartexchange/artbase/issues)
+* gem   :: [rubygems.org/gems/artbase-cocos](https://rubygems.org/gems/artbase-cocos)
+* rdoc  :: [rubydoc.info/gems/artbase-cocos](http://rubydoc.info/gems/artbase-cocos)
+
+
+
+## Usage
+
+To be done
+
+
+
+
+
+## License
+
+The `artbase` scripts are dedicated to the public domain.
+Use it as you please with no restrictions whatsoever.
+
+
+## Questions? Comments?
+
+Post them on the [D.I.Y. Punk (Pixel) Art reddit](https://old.reddit.com/r/DIYPunkArt). Thanks.

data/Rakefile

@@ -0,0 +1,40 @@
+require 'hoe'
+require './lib/artbase-cocos/version.rb'
+
+
+###
+# hack/ quick fix for broken intuit_values - overwrite with dummy
+class Hoe
+  def intuit_values( input ); end
+end
+
+
+Hoe.spec 'artbase-cocos' do
+
+  self.version = Artbase::Module::Cocos::VERSION
+
+  self.summary = "artbase-cocos - artbase (shared) code commons (cocos); read artbase collection configs & metadata; download collection token metadata, images, and more"
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/pixelartexchange/artbase'}
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'wwwmake@googlegroups.com'
+
+  # switch extension to .markdown for gihub formatting
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.extra_deps = [
+    ['cocos', '>= 0.1.2'],
+    ['pixelart', '>= 1.3.6'],
+    ['webclient', '>= 0.2.2'],  ## weblclient part of cocos?
+  ]
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.2.2'
+  }
+
+end

data/lib/artbase-cocos/attributes.rb

@@ -0,0 +1,83 @@
+
+
+def counter_to_text( counter )
+
+  counter = counter.to_a
+
+  attribute_counter = counter[0]
+  more_counter      = counter[1..-1]
+
+
+  puts "Attribute Counts\n"
+  trait_type, h = attribute_counter
+
+  total = h[:by_type].values.reduce(0) { |sum,count| sum+count }
+
+
+  types = h[:by_type]
+  types = types.sort { |l,r| l[0]<=>r[0] }  ## sort by name
+
+  puts "\n"
+  puts "|Name|Total (%)|"
+  puts "|--------|----------:|"
+
+  types.each do |rec|
+      name     = rec[0]
+      count    = rec[1]
+      percent =  Float(count*100)/Float(total)
+
+      puts "| **#{name} Attributes** | #{count} (#{'%.2f' % percent}) |"
+  end
+  puts "\n"
+
+  more_counter.each_with_index do |(trait_type, h),i|
+    print " · "  if i > 0   ## add separator
+    print "#{trait_type } (#{h[:by_type].size})"
+  end
+  puts "\n\n"
+
+
+
+  more_counter.each do |trait_type, h|
+    print "### #{trait_type } (#{h[:by_type].size}) - "
+    print "∑Total #{h[:count]}/#{total}\n"
+
+    puts "\n"
+    puts "|Name|Total (%)|"
+    puts "|--------|----------:|"
+
+      types = h[:by_type]
+      types = types.sort do |l,r|
+                            # sort by 1) by count
+                            #         2) by name a-z
+                                  res = r[1] <=> l[1]
+                                  res = l[0] <=> r[0]  if res == 0
+                                  res
+                         end  ## sort by count
+      types.each do |rec|
+         name     = rec[0]
+         count    = rec[1]
+         percent =  Float(count*100)/Float(total)
+
+         puts "| **#{name}** | #{count} (#{'%.2f' % percent}) |"
+      end
+      puts "\n\n"
+    end
+end
+
+
+
+
+def counter_to_csv( counter )
+
+  puts "type, name, count"
+  counter.each do |trait_type, h|
+    puts "#{trait_type}, ∑ Total, #{h[:count]}"
+    h[:by_type].each do |trait_value, count|
+       puts "#{trait_type}, #{trait_value}, #{count}"
+    end
+  end
+end
+
+
+

data/lib/artbase-cocos/collection/base.rb

@@ -0,0 +1,332 @@
+
+module Artbase
+class Base     ## "abstract" Base collection - check -use a different name - why? why not?
+
+
+def convert_images( overwrite: )
+  image_dir = "./#{@slug}/token-i"
+  Image.convert( image_dir, from: 'jpg', to: 'png', overwrite: overwrite )
+  Image.convert( image_dir, from: 'gif', to: 'png', overwrite: overwrite )
+  Image.convert( image_dir, from: 'svg', to: 'png', overwrite: overwrite )
+end
+
+
+
+def make_strip
+  composite_count = @count - @excludes.size
+
+  composite = ImageComposite.new( 9, 1,
+                                  width:  @width,
+                                  height: @height )
+
+  i = 0
+  each_image do |img, id|
+    puts "==> [#{i+1}/9] #{id}"
+    composite << img
+
+    i += 1
+    break if i >= 9
+  end
+
+
+  composite.save( "./#{@slug}/tmp/#{@slug}-strip.png" )
+end
+
+
+
+def make_composite( limit: nil,
+                    mirror: false )
+  ### use well-known / pre-defined (default) grids
+  ##        (cols x rows) for now - why? why not?
+
+  composite_count = if limit
+                      limit
+                    else
+                      @count - @excludes.size
+                    end
+
+  cols, rows = case composite_count
+               when    99 then   [10,  10]
+               when   100 then   [10,  10]
+               when   150 then   [15,  10]
+               when   314 then   [15,  21]
+               when   500 then   [25,  20]
+               when   946 then   [25,  38]
+               when  1000 then   [25,  40]
+               when  1300 then   [25,  52]
+               when  2048 then   [50,  41]
+               when  2077 then   [50,  42]
+               when  2200 then   [50,  44]
+               when  2222 then   [50,  45]
+               when  2469 then   [50,  50]
+               when  3000 then   [100, 30]    ## or use 50*60 - why? why not?
+               when  3500 then   [100, 35]    ## or use 50*x ??
+               when  3979 then   [100, 40]
+               when  4000 then   [100, 40]    ## or use 50x80 - why? why not?
+               when  4444 then   [100, 45]    ## or use 50x??
+               when  5000 then   [100, 50]    ## or use 50x100 - why? why not?
+               when  5555 then   [100, 56]   # 5600 (45 left empty)
+               when  6666 then   [100, 67]   # 6700 (34 left empty)
+               when  6688 then   [100, 67]   # 6700 (12 left empty)
+               when  6969 then   [100, 70]   # 7000 (31 left empty)
+               when  7500 then   [100, 75]
+               when  8888 then   [100, 89]
+               when  9969 then   [100,100]
+               when 10000 then   [100,100]
+               else
+                   raise ArgumentError, "sorry - unknown composite count #{composite_count}/#{@count} for now"
+               end
+
+  composite = ImageComposite.new( cols, rows,
+                                  width:  @width,
+                                  height: @height )
+
+
+  count = 0
+  each_image do |img, id|
+    puts "==> #{id}"
+    composite <<    if mirror
+                      img.mirror
+                    else
+                      img
+                    end
+
+    count += 1
+    break if limit && count >= limit
+  end
+
+
+  slug = "#{@slug}"
+  slug += "#{limit}" if limit
+  slug += "_left"    if mirror
+
+  path = "./#{@slug}/tmp/#{slug}-#{@width}x#{@height}.png"
+  puts "   saving #{path}..."
+  composite.save( path )
+
+  if composite_count < 1000
+    path = "./#{@slug}/tmp/#{slug}-#{@width}x#{@height}@2x.png"
+    puts "   saving 2x #{path}..."
+    composite.zoom(2).save( path )
+  end
+end
+
+
+
+def calc_attribute_counters  ## todo/check: use a different name _counts/_stats etc - why? why not?
+
+  attributes_by_count = { count: 0,
+                          by_count: Hash.new(0)
+                        }
+  counter = {}
+
+
+  each_meta do |meta, id|   ## todo/fix: change id to index
+    traits = meta.traits
+    # print "#{traits.size} - "
+    # pp  traits
+
+    print "#{id}.."   if id % 100 == 0  ## print progress report
+
+    attributes_by_count[ :count ] +=1
+    attributes_by_count[ :by_count ][ traits.size ] += 1
+
+    traits.each do |trait_type, trait_value|
+        trait_type  = _normalize_trait_type( trait_type )
+        trait_value = _normalize_trait_value( trait_value )
+
+
+        rec = counter[ trait_type ] ||= { count: 0,
+                                          by_type: Hash.new(0)
+                                        }
+        rec[ :count ] +=1
+        rec[ :by_type ][ trait_value ] += 1
+    end
+  end
+
+  print "\n"
+  puts
+
+  ## return all-in-one hash
+  {
+    total:  attributes_by_count,
+    traits: counter,
+  }
+end
+
+
+def dump_attributes
+  stats = calc_attribute_counters
+
+  total    = stats[:total]
+  counter  = stats[:traits]
+
+  puts
+  puts "attribute usage / counts:"
+  pp total
+  puts
+
+  puts "#{counter.size} attribute(s):"
+  counter.each do |trait_name, trait_rec|
+     puts "  #{trait_name}  #{trait_rec[:count]}  (#{trait_rec[:by_type].size} uniques)"
+  end
+
+  puts
+  pp counter
+end
+
+
+
+
+##  order - allow "custom" attribute order export
+##  renames - allow renames of attributes
+def export_attributes(
+   order: [],
+   renames: {}
+)
+
+  ## step 1: get counters
+  stats = calc_attribute_counters
+
+  total    = stats[:total]
+  counter  = stats[:traits]
+
+  puts
+  puts "attribute usage / counts:"
+  pp total
+  puts
+
+  puts "#{counter.size} attribute(s):"
+  counter.each do |trait_name, trait_rec|
+     puts "  #{trait_name}  #{trait_rec[:count]}  (#{trait_rec[:by_type].size} uniques)"
+  end
+
+
+  trait_names = []
+  trait_names += order    ## get attributes if any in pre-defined order
+  counter.each do |trait_name, _|
+      if trait_names.include?( trait_name )
+         next    ## skip already included
+      else
+         trait_names  << trait_name
+      end
+  end
+
+
+  recs = []
+
+
+  ## step 2: get tabular data
+  each_meta do |meta, id|   ## todo/fix: change id to index
+
+    traits = meta.traits
+    # print "#{traits.size} - "
+    # pp  traits
+
+    print "#{id}.."   if id % 100 == 0  ## print progress report
+
+    ## setup empty hash table (with all attributes)
+    rec = {}
+
+    ## note: use __Slug__& __Name__
+    ##         to avoid conflict with attribute names
+    ##         e.g. attribute with "Name" will overwrite built-in and so on
+
+    rec['__Slug__'] = if respond_to?( :_meta_slugify )
+                       _meta_slugify( meta, id )
+                  else
+                     ## default to id (six digits) as string with leading zeros
+                     ##    for easy sorting using strings
+                     ##   e.g.  1 => '000001'
+                     ##         2 => '000002'
+                       '%06d' % id
+                  end
+
+    rec['__Name__'] = meta.name
+
+    ## add all attributes/traits names/keys
+    trait_names.reduce( rec ) { |h,value| h[value] = []; h }
+    ## pp rec
+
+    ## note: use an array (to allow multiple values for attributes)
+    traits.each do |trait_type, trait_value|
+       trait_type  = _normalize_trait_type( trait_type )
+       trait_value = _normalize_trait_value( trait_value )
+
+       values = rec[ trait_type ]
+       values << trait_value
+    end
+    recs << rec
+  end
+  print "\n"
+
+  ## pp recs
+
+  ## flatten recs
+  data = []
+  recs.each do |rec|
+     row = rec.values.map do |value|
+                  if value.is_a?( Array )
+                     value.join( ' / ' )
+                  else
+                     value
+                  end
+             end
+     data << row
+  end
+
+
+  ## sort by slug
+  data = data.sort {|l,r| l[0] <=> r[0] }
+  pp data
+
+  ### save dataset
+  ##  note: change first colum Slug to ID - only used for "internal" sort etc.
+  headers = ['ID', 'Name']
+  headers += trait_names.map do |trait_name|   ## check for renames
+                                renames[trait_name] || trait_name
+                             end
+
+
+  path = "./#{@slug}/tmp/#{@slug}.csv"
+  dirname = File.dirname( path )
+  FileUtils.mkdir_p( dirname )  unless Dir.exist?( dirname )
+
+  File.open( path, 'w:utf-8' ) do |f|
+    f.write(  headers.join( ', ' ))
+    f.write( "\n" )
+    ## note: replace ID with our own internal running (zero-based) counter
+    data.each_with_index do |row,i|
+      f.write( ([i]+row[1..-1]).join( ', '))
+      f.write( "\n" )
+    end
+  end
+end
+
+
+
+
+#############
+#  "private" helpers
+
+def _normalize_trait_type( trait_type )
+  if @patch && @patch[:trait_types]
+    @patch[:trait_types][ trait_type ] || trait_type
+  else
+     trait_type
+  end
+end
+
+def _normalize_trait_value( trait_value )
+  if @patch && @patch[:trait_values]
+    @patch[:trait_values][ trait_value ] || trait_value
+  else
+    trait_value
+  end
+end
+
+
+
+
+end  # class Base
+end  # module Artbase

data/lib/artbase-cocos/collection/image.rb

@@ -0,0 +1,39 @@
+
+
+class ImageCollection
+
+  attr_reader :slug, :count
+
+  def initialize( slug, count,
+                  image_base: )   # check: rename count to items or such - why? why not?
+    @slug = slug
+    @count = count
+    @image_base = image_base
+  end
+
+  def download_images( range=(0...@count) )
+    start = Time.now
+    delay_in_s = 0.3
+
+    range.each do |offset|
+      image_src = @image_base.sub( '{id}', offset.to_s )
+
+      puts "==> #{offset} - #{@slug}..."
+
+      ## note: will auto-add format file extension (e.g. .png, .jpg)
+      ##        depending on http content type!!!!!
+      copy_image( image_src, "./#{@slug}/image-i/#{offset}" )
+
+      stop = Time.now
+      diff = stop - start
+
+      mins = diff / 60  ## todo - use floor or such?
+      secs = diff % 60
+      puts "up #{mins} mins #{secs} secs (total #{diff} secs)"
+
+      puts "sleeping #{delay_in_s}s..."
+      sleep( delay_in_s )
+    end
+  end
+end # class ImageCollection
+