8-bit generator

[Enzo]

I'm reviewing an old code from fresh, a classic black-and-white 8-bit generator, from all the possible combinations of 4, 4*4 squares and the 16 different combinations of each square, theoretically there is only 34,000 possible 8x8 squares, I believe, which can be displayed on about 3 1080p images, my interest is in the pixel art, all 8-bit has been patented but I am hoping to shuffle the three screens and produce art by random rearranging of the 8x8 squares,
now there is a ton of combinations of this, but I've done it before and found some cool looking items for video games flowers and several orbs I even found a pixel gobin looking creature once,

I am trying to reproduce the code, this is what I have so far


Global fscount, config, pixel, startzero, zero, X, Y, x, y, maxbmp
fscount = 4 'number of 4*4 square tiles
config = fscount * fscount 'max configs
pixel = fscount
startzero = 1
zero = 0
Y = 0
X = 0

maxbmp = 2 '16*16 grid to start  '(100 * 8 pixels - 4, 4*4 grids) (1600x1600 pixel image "10,000 4*4*4 grid 8-bit") <'debug line

dim xy(maxbmp,maxbmp)
dim fs1(config)
dim fs2(config)
dim fs3(config)
dim fs4(config)

goto [fssetup]

[start]

goto [guisetup]
[return]

for xyloop = startzero to maxbmp 'keeps track of main 8x8 X Y GRID

if X = maxbmp then
Y = Y + 1
X = zero
end if

X = X + 1


for mainloop=startzero to fscount 'goes down list one at a time, automatically

select case mainloop
 case 1
x = zero
y = zero
fs = 1
printf=fs(fs,x,y)
 case 2
x = 1*pixel*X
y = zero
fs=2
printf=fs(fs,x,y)
 case 3
x = 1*pixel*X
y = 1*pixel*Y
fs=3
printf=fs(fs,x,y)
 case 1
x = zero
y = 1*pixel*Y
fs=4
printf=fs(fs,x,y)
end select

next mainloop
next xyloop

[gui]
'gui here graphics box 1600x1600
'menu with save bmp and print
goto [return]

[fssetup]
for setup = 1 to 16
fs1(setup)=setup
fs2(setup)=setup
fs3(setup)=setup
fs4(setup)=setup
next setup

goto [start]

function fs(fs,x,y,X,Y)

'display a 1 - 16 from
' x y which was calculated to grid from mainloop X Y looping + 1
select case fs
case 1
fs1(rnd)=grid
case 2
fs2(rnd)=grid
case 3
fs3(rnd)=grid
case 4
fs4(rnd)=grid
end select
write=display(grid,x,y,X,Y)
end function

function display(grid,x,y,X,Y)
'display 1-16 via pen; or maybe sprite x y
'draw(grid, X+x,Y+y)
end function

function draw(grid, xx, yy)
'sprite or pen function to draw 1-16
end function

Question does it look like I am on the right track? Starting with a maxbmp count of 2 instead of 100, 4*4*4 images in a row, to simplify, now sure if I should use pen function or use sprites? I am trying now, to produce the first image, non-shuffling


Thanks

[tsh73]

Hello
This doesn't work as posted
description has 5 parameter
function fs(fs,x,y,X,Y)
usage has 3
printf=fs(fs,x,y)
so it doesn't start (at all).

As a side note, all X, Y, x, y described Global
Wierd thing to do with parameters, IMHO

Then made run it does nothing (no window, no drawing)
Make it do something visible and you'll see if you are on a track or not.

[tsh73]

Something along this, may be

---

EDIT btw single character is 0..255, that is 16^2.
Here we have 4 lines by 4 points - 4^4, or 65536 possible different "characters".

---

nomainwin
'open "test" for graphics_nsb_nf as #gr  'default about 300x300
open "test" for graphics_nsb_fs as #gr 'full screen
#gr "trapclose [quit]"
#gr "down"
#gr "home; posxy cx cy"
#gr "\";cx;" ";cy
size = 3
#gr "size ";size
gap = 5

t0=time$("ms")
for X = 0 to 2*cx/(4*size+gap)
   for Y = 0 to 2*cy/(4*size+gap)
   SCAN    'make it breakable
       for x = 0 to 3
           for y = 0 to 3
               if rnd(0)>.5 then #gr "set ";X*(4*size+gap)+x*size;" ";Y*(4*size+gap)+y*size
           next
       next
   next
next
#gr "flush"
notice "Time taken, ms ";time$("ms")-t0
wait

[quit]
close #gr
end



[tenochtitlanuk]

I'm still not clear if we want systematic 'blocks' or random 'blocks' as neighbours, but had fun producing this sequence of the first 2K of 4x4 blocks.




   nomainwin

   WindowWidth  =1280
   WindowHeight =1080

   open "Patterns" for graphics_nsb as #wg

   #wg "trapclose quit"

   #wg "size 2 ; down ; fill black ; flush"

   global I, xO, yO: I =0: xO =0: yO =0

   for i =0 to 31
       for j =0 to 63
           bin$    =dec2bin$( I)
           call plotBlock i, j, bin$
           I       =I +1
           xO      =xO +3
           scan
       next j
       xO      =0
       yO      =yO +3
   next i

   #wg "flush"
   #wg "getbmp scr 1 1 1280 1080"
   bmpsave "scr", "allBinary9A.bmp"

   wait

   sub plotBlock i, j, in$ '   y posn, x posn, binarystring$

       for y =3 to 0 step -1
           for x =3 to 0 step -1
               t$      =mid$( in$, 49 +x +4 *y, 1)
               if ( t$ ="1") then #wg "color yellow" else #wg "color 200 50 50"
               xS      =( ( I mod 64) *4) +x
               yS      =( ( int( I / 64)) mod 64) *4 + y +2
               #wg "set "; 4 *xS +10 +xO; " "; 1 +4 *yS +yO
           next x
           print ""
       next y

       'print ""
   end sub

   function dec2bin$( num)
       if num =0 then dec2bin$ =space$( 64): exit function
       while num >0
           dec2bin$   =str$( num mod 2) +dec2bin$
           num        =int( num /2)
       wend
       dec2bin$   =right$( space$( 64) +dec2bin$, 64)
   end function

   sub quit h$
       close #wg
       end
   end sub


[tsh73]

Nice colors

[Rod]

Can Enzo point us at an image that he is trying to replicate?

[tenochtitlanuk]

That would indeed help us help him!

Meanwhile more play- and a quote from the past about blinking lights seemed relevant..

ACHTUNG!!!

Das machine is nicht fur gefingerpoken und mittengrabben. Ist easy
schnappen der springenwerk, blowenfusen und corkenpoppen mit
spitzensparken. Ist nicht fur gewerken by das dummkopfen. Das
rubbernecken sightseeren keepen hands in das pockets. Relaxen und
vatch das blinkenlights!!!


   ' 4, 4*4 squares

   nomainwin

   WindowWidth  =780
   WindowHeight =800

   open "Patterns" for graphics_nsb as #wg

   #wg "trapclose quit"

   #wg "size 70 ; down ; fill  0 0 60 ; flush"

   global I, xO, yO: I =0: xO =0: yO =0

   for test =1 to 100
   for i =0 to 1

       for j =0 to 1
           I       =int( 2^16 *rnd( 1))
           bin$    =dec2bin$( I)
           'print "|"; bin$; "|"
           call plotBlock i, j, bin$
           scan
           #wg "getbmp scr 1 1 780 800"
           bmpsave "scr", "temp/scr16x" +right$( "000" +str$( test), 3) +".bmp"
       next j

   next i

   call hold 100

   next test

   #wg "flush"
   #wg "getbmp scr 1 1 1280 1080"
   bmpsave "scr", "big_4x4x4.bmp"

   wait

   sub hold secs
       t =time$( "ms")
       [L]
       if time$( "ms") -t < secs then goto [L]
   end sub

   sub plotBlock i, j, in$ '   y posn, x posn, binarystring$
       I   =1
       for y =3 to 0 step -1
           for x =3 to 0 step -1
               t$      =mid$( in$, I, 1)
               if ( t$ ="1") then #wg "color yellow"
               if ( t$ ="0") then #wg "color red"
               xS      =20    +x *20   +85 *j
               yS      =20    +y *20   +85 *i
               #wg "set "; 4 *xS +10 +xO; " "; 1 +4 *yS +yO
               I =I +1
           next x

       next y
   end sub

   function dec2bin$( num)
       if num =0 then dec2bin$ ="0000000000000000": exit function
       while num >0
           dec2bin$   =str$( num mod 2) +dec2bin$
           num        = int( num /2)
       wend
       dec2bin$   =right$( "0000000000000000" +dec2bin$, 16)
   end function

   sub quit h$
       close #wg
       end
   end sub



[Rod]

I suspect we are not looking for color. I suspect we are looking for the best 4bit black and white combo that mirrors a specific part of a photo so that an entire image can be rendered on 4x4 or 8x8 block if we expand the game. But we need to hear from the OP.

[Enzo]

Everyone is spot on, I enjoyed viewing your guys code and glad you had fun!

[Enzo]

Single image randomized, colors don't 100% matter basically we are reproducing 16x16+ pixel art if you call that size image that


Bascially all images are comprised on the same set this is the only set we can look at as humans i think a 8x8 would be too large of a tileset 'set'