ocs : test

mapX=9
mapY=9
mapZ=9
map={}
drawz=1
winloop=0
drawscale=10
htime=0
groups={}
dim={}
dims={}
drawx=0
drawy=0
npower=0
GroupPower={}
SumOfDimensions={}
GroupSumPower=0
maps={}
TotalNumberOfBlocksInAllGroups=0
failstep=0
maxloop=0
loop=0
drawblocks=0
test=0
--bush
bush={}
start=1
draw=true
blocksmap={}
component=require("component")
 component.hologram.setScale(10)
font={}
font[0]={
{0,1,1,1,0},
{1,0,0,0,1},
{1,0,0,0,1},
{1,0,0,0,1},
{0,1,1,1,0}
}
font[1]=
{
{0,0,1,0,0},
{0,1,1,0,0},
{0,0,1,0,0},
{0,0,1,0,0},
{1,1,1,1,1}
}
font[2]=
{
{0,1,1,1,0},
{1,0,0,0,1},
{0,0,0,1,0},
{0,0,1,0,0},
{1,1,1,1,1}
}
font[3]=
{
{0,1,1,1,0},
{1,0,0,0,1},
{0,0,0,1,0},
{1,0,0,0,1},
{0,1,1,1,0}
}
font[4]=
{
{0,0,0,1,0},
{0,0,1,1,0},
{0,1,0,1,0},
{0,1,1,1,1},
{0,0,0,1,0}
}
font[5]=
{
{1,1,1,1,1},
{1,0,0,0,0},
{0,1,1,1,0},
{0,0,0,0,1},
{1,1,1,1,0}
}
font[6]=
{
{0,1,1,1,0},
{1,0,0,0,0},
{1,1,1,1,0},
{1,0,0,0,1},
{0,1,1,1,0}
}
font[7]=
{
{1,1,1,1,1},
{0,0,0,0,1},
{0,0,0,1,0},
{0,0,1,0,0},
{0,0,1,0,0}
}
font[8]=
{
{0,1,1,1,0},
{1,0,0,0,1},
{0,1,1,1,0},
{1,0,0,0,1},
{0,1,1,1,0}
}
font[9]=
{
{0,1,1,1,0},
{1,0,0,0,1},
{0,1,1,1,1},
{0,0,0,0,1},
{1,1,1,1,0}
}


function saveinblocksmap(x,y,z)
blocksmap[#blocksmap+1]={x,y,z,map[x][y][z]}

end
function getblockmap(i)
return blocksmap[i][1],blocksmap[i][2],blocksmap[i][3],blocksmap[i][4]

end
bush[1]= function(x,y,z)
local radius=math.random(1,math.floor((mapX+mapY+mapZ)/3))
for nx=-radius,radius do
 for ny=-radius,radius do
  for nz=-radius,radius do
  local x2=limit(x+nx,mapX)
  local y2=limit(y+ny,mapY)
  local z2=limit(z+nz,mapZ)
  --print(x2,y2,z2)
   if map[x2][y2][z2]==-1
   then map[x2][y2][z2]=-2 else
   map[x2][y2][z2]=-1 end
  end
 end
 end
end
bush[2]= function(x2,y,z)
 for x=1,mapX do
  if map[x][y][z]==-1
  then map[x][y][z]=-2 else
  map[x][y][z]=-1 end
 end

end
bush[3]= function(x,y2,z)
 for y=1,mapY do
  if map[x][y][z]==-1
  then map[x][y][z]=-2 else
  map[x][y][z]=-1 end
 end
end
bush[4]= function(x,y,z2)
 for z=1,mapZ do
  if map[x][y][z]==-1
  then map[x][y][z]=-2 else
  map[x][y][z]=-1 end
 end
end
bush[5]= function(x2,y2,z)
 for x=1,x2 do
  for y=1,y2 do
   if math.random(1,2)==1 then
    if map[x][y][z]==-1
    then map[x][y][z]=-2 else
    map[x][y][z]=-1 end
   end
  end
 end
end

bush[6]= function(x,y2,z2)
 for z=1,z2 do
  for y=1,y2 do
   if math.random(1,2)==1 then
    if map[x][y][z]==-1
    then map[x][y][z]=-2 else
    map[x][y][z]=-1 end

 end
 end
 end
 end
bush[7]= function(x2,y,z2)
for x=1,x2 do
 for z=1,z2 do
 if math.random(1,2)==1 then
  if map[x][y][z]==-1
then map[x][y][z]=-2 else
 map[x][y][z]=-1 end

 end
 end
 end
 end
 bush[8]= function(x2,y2,z)
x=math.random(1,mapX)
y=math.random(1,mapY)
map[x][y][z]=-2
 end


 function generatemap()
 local I=-1
 local O=-2
for x=1,mapX do
map[x]={}
maps[x]={}
for y=1,mapY do
map[x][y]={}
maps[x][y]={}
for z=1,mapZ do
map[x][y][z]=-2
maps[x][y][z]=-2
end end end
--[[
for x=1,mapX,2 do
for y=1,mapY,2 do
for z=1,mapZ do
map[x][y][z]=-1
end end end
]]



for x=1,mapX do
for y=1,mapY do
for z=1,mapZ do
maps[x][y][z]=map[x][y][z] end end end

end
generatemap()

function resetall()
drawblocks=TotalNumberOfBlocksInAllGroups
TotalNumberOfBlocksInAllGroups=0
SumOfDimensions=nil
SumOfDimensions={}
SizePower=0

GroupPower=nil
GroupPower={}
GroupSumPower=0

end
function mima(mi,n,ma)
local x=math.min(n,ma)

local nx=math.max(mi,x)

return nx
end


function resetmap()
for I=1,#blocksmap do
x,y,z,name=getblockmap(I)
  if map[x][y][z]==-2 then else map[x][y][z]=-1 end


end
   groups=nil
groups={}
   dim=nil
dim={}
dims=nil
dims={}
blocksmap=nil
blocksmap={}
end

function limit(n,n1) -- 1=<n=<n1
local x=math.min(n,n1)
local nx=math.max(1,x)
return nx
end


function updateall()

loop=loop+1
if loop==maxloop then else
 if loop==1 then  else

bush[math.random(1,#bush)](math.random(1,mapX),math.random(1,mapY),math.random(1,mapZ))

 end

 for x=1,mapX do
 for y=1,mapY do
  for z=1,mapZ do

  saveinblocksmap(x,y,z,map[x][y][z])

  end end end





local fail=0
for I=1,#blocksmap do
x,y,z,name=getblockmap(I)
   if map[x][y][z]==-1 then
    groups[#groups+1]={}
    map[x][y][z]=#groups
    dim[#groups]={}
    dims[#groups]={}
    for i=1,(mapX+mapY+mapZ)/3 do
    for I2=1,#blocksmap do
x2,y2,z2,name=getblockmap(I2)
        if map[x2][y2][z2]==#groups then
        reactorupdate(x2,y2,z2,-1,#groups) else fail=fail+1



      end


   end
  end
 end
end
if #groups>0 then
dim[#dim]={}

 for i=1, #dim do
    for I2=1,#blocksmap do
x,y,z,name=getblockmap(I2)
     if map[x][y][z]==i then dim[i][#dim[i]+1]={x,y,z}


   end
  end
 end
end

for i=1, #groups do
for n=1, #dim[i] do




    if n==1 then
minx=dim[i][n][1]
maxx=dim[i][n][1]
miny=dim[i][n][2]
maxy=dim[i][n][2]
minz=dim[i][n][3]
maxz=dim[i][n][3]
 else
minx=math.min (dim[i][n][1],minx)
maxx=math.max (dim[i][n][1],maxx)
miny=math.min (dim[i][n][2],miny)
maxy=math.max (dim[i][n][2],maxy)
minz=math.min (dim[i][n][3],minz)
maxz=math.max (dim[i][n][3],maxz)

 end


 end

 dims[i]={maxx-(minx-1),maxy-(miny-1),maxz-(minz-1)}



 end

 for i=1, #groups do
 SumOfDimensions[i]=dims[i][1]+dims[i][2]+dims[i][3]
 SizePower = 2000000 / ( 1 + 1.000696^(-0.333*(SumOfDimensions[i]/3)^1.7)) - 1000000

 BlockPower = 25 * #dim[i]
 SizePower =math.min(SizePower,1000000 )
 GroupPower[i] = BlockPower + SizePower

  GroupSumPower=GroupSumPower+(SumOfDimensions[i]/3)^1.7



  TotalNumberOfBlocksInAllGroups = TotalNumberOfBlocksInAllGroups+#dim[i]
  end
  GroupSumSizePower = 2000000 / ( 1 + 1.000696^(-0.333 * GroupSumPower)) - 1000000
  BlockPower = 25 * TotalNumberOfBlocksInAllGroups
 TotalPower = math.floor(BlockPower + GroupSumSizePower)



if npower<TotalPower then    npower=TotalPower

savemap() else loadmap()

 failstep=failstep+1  end
resetall()
end

--[[
winloop=winloop+1
oldfile=reader(getmaxpowersave())
local N=0
local N2=1
local N3=1
local N4=1
local table={}
 for n in string.gmatch(oldfile, ".") do
 if n=="&"then table[#table+1]=0
 table[#table]=n

end end
for i=1,#table do
N=N+1
if N==1 then mapX=table[i]
elseif N==2 then mapY=table[i]
elseif N==3 then mapZ=table[i]
else
if N2>mapX then N2=1 N3=N3+1 end
if N3<mapY then N3=1 N4=N4+1 end
map[N2][N3][N4]=table[i]


 N2=N2+1
end


end
 ]]
end

function reactorupdate(x,y,z,d,d2)



    if  map[x][y][z]==d then map[x][y][z]=d2 end
    if  map[limit(x+1,mapX)][y][z]==d then map[limit(x+1,mapX)][y][z]=d2 end
    if  map[limit(x-1,mapX)][y][z]==d then map[limit(x-1,mapX)][y][z]=d2 end
    if  map[x][limit(y+1,mapY)][z]==d then map[x][limit(y+1,mapY)][z]=d2 end
    if  map[x][limit(y-1,mapY)][z]==d then map[x][limit(y-1,mapY)][z]=d2 end
    if  map[x][y][limit(z+1,mapZ)]==d then map[x][y][limit(z+1,mapZ)]=d2 end
    if  map[x][y][limit(z-1,mapZ)]==d then map[x][y][limit(z-1,mapZ)]=d2 end

end

function savemap()
  for x=1,mapX do
   for y=1,mapY do
    for z=1,mapZ do
maps[x][y][z]=map[x][y][z]
 end end
end end
function loadmap()
  for x=1,mapX do
   for y=1,mapY do
    for z=1,mapZ do
map[x][y][z]=maps[x][y][z]
end end
end end
function mimat(mi,n,ma)
if n<mi or n>ma then return false else return true end


end

function update()
math.randomseed(os.time()+math.random(-100000,1000000000))
if start==1 then
 updateall() end
end
function drawtext(text)
text=tostring(text)
 for w in string.gmatch(text, ".") do
  for x=5,1,-1  do
  for y=5,1,-1 do



 if font[tonumber(w)][y][x]==1 then
 component.hologram.set(w*x,y , math.floor((48-mapZ)/2)+mapZ,true) end

 end end
 end
end
function draw()


for z=1,mapZ do

for x=1,mapY do
for y=1,mapX do
if  map[x][y][z]==-2 then

 else
component.hologram.set(math.floor((48-mapX)/2)+x,y,math.floor((48-mapZ)/2)+z,true)

end
end
end




end
drawtext(1)
 resetmap()
end

while true do
update()
draw()

end