View difference between Paste ID: Ur5Q8nDd and hABYHWwr

-local gpu=require("component").gpu
+local AGUI_VERSION = "0.6"
-local event=require("event")
+local component = require("component")
-
+local success, gui
-fieldWidth=20
+repeat
-fieldHeight=26
+  success, gui = pcall(require, "AGUI")
-
+  if not success then
-width=30 --width of mas NOT field
+    print(gui)
-
+    io.write("For the application need a library AGUI (https://pastebin.com/s4UFSFwn).\n")
-mas={}
+    if not component.isAvailable("internet") then
-
+      os.exit()
-StockBlocks = { { start_position = { x = 4, y = 1 },
+    end
-                  color = { 175, 175, 0 },
+    io.write("Do you want to install?[Y/n] ")
-                  symbol = "T",
+    if not ((io.read() or "n").."y"):match("^%s*[Yy]") then
-                  transformations = { { { x = -1, y = 0 },
+      os.exit()
-                                        { x = 0, y = 0 },
+    end
-                                        { x = 1, y = 0 },
+    loadfile("/bin/wget.lua")("https://pastebin.com/raw/s4UFSFwn", "/lib/AGUI.lua", "-f")
-                                        { x = 0, y = -1 } },
+  end
-                                      { { x = 0, y = 0 },
+until success
-                                        { x = 0, y = -1 },
+
-                                        { x = 0, y = 1 },
+if gui.Version ~= AGUI_VERSION then
-                                        { x = 1, y = 0 } },
+  io.write("Recommended version of AGUI library ("..AGUI_VERSION..") does not match installed ("..(gui.Version or "unknown")..")\n")
-                                      { { x = -1, y = 0 },
+  io.write("Do you want to continue?[Y/n] ")
-                                        { x = 0, y = 0 },
+    if not ((io.read() or "n").."y"):match("^%s*[Yy]") then
-                                        { x = 1, y = 0 },
+      os.exit()
-                                        { x = 0, y = 1 } },
+    end
-                                      { { x = 0, y = 0 },
+end
-                                        { x = 0, y = -1 },
+
-                                        { x = 0, y = 1 },
+local gpu = component.gpu
-                                        { x = -1, y = 0 } } } },
+local event = require("event")
-                { start_position = { x = 4, y = 1 },
+
-                  color = { 0, 255, 0 },
+------SETTINGS-------
-                  symbol = "Z",
+local cfg = {}
-                  transformations = { { { x = -1, y = 0 },
+cfg.mapWidth = 10
-                                        { x = 0, y = 0 },
+cfg.mapHeight = 20
-                                        { x = 0, y = -1 },
+cfg.startX = gui.GetCenter(1, cfg.mapWidth, 1) - 1
-                                        { x = 1, y = -1 } },
+cfg.drawShadow = true
-                                      { { x = 0, y = -1 },
+cfg.shadowColor = 0x222222
-                                        { x = 0, y = 0 },
+cfg.tickDelay = 0.1
-                                        { x = 1, y = 0 },
+cfg.fallTickCnt = 3
-                                        { x = 1, y = 1 } } } },
+cfg.fallLinesDelay = 0.3
-                { start_position = { x = 4, y = 1 },
+cfg.backColor = 0x000000
-                  color = { 100, 100, 175 },
+--
-                  symbol = "S",
+function InRange(value, left, right)
-                  transformations = { { { x = 1, y = 0 },
+  return left <= value and value <= right
-                                        { x = 0, y = 0 },
+end
-                                        { x = 0, y = -1 },
+
-                                        { x = -1, y = -1 } },
+function ValidateConfig()
-                                      { { x = 0, y = 1 },
+  local MaxScreenWidth, MaxScreenHeight
-                                        { x = 0, y = 0 },
+  MaxScreenWidth, MaxScreenHeight = gpu.maxResolution()
-                                        { x = 1, y = 0 },
+
-                                        { x = 1, y = -1 } } } },
+  if not InRange(cfg.mapWidth * 2 + 12, 22, MaxScreenWidth) then
-                { start_position = { x = 4, y = 0 },
+    return "MapWidthError", "out of bounds"
-                  color = { 255, 255, 100 },
+  end
-                  symbol = "J",
+
-                  transformations = { { { x = -1, y = 0 },
+  if not InRange(cfg.mapHeight, 15, MaxScreenHeight) then
-                                        { x = 0, y = 0 },
+    return "MapHeightError", "out of bounds"
-                                        { x = 1, y = 0 },
+  end
-                                        { x = -1, y = 1 } },
+end
-                                      { { x = 0, y = -1 },
+
-                                        { x = 0, y = 0 },
+--UpdateScreenSettings()
-                                        { x = 0, y = 1 },
+local err, msg = ValidateConfig()
-                                        { x = 1, y = 1 } },
+if err ~= nil then
-                                      { { x = -1, y = 0 },
+  print(err, msg)
-                                        { x = 0, y = 0 },
+  os.exit()
-                                        { x = 1, y = 0 },
+end
-                                        { x = 1, y = -1 } },
+--
-                                      { { x = 0, y = -1 },
+
-                                        { x = 0, y = 0 },
+linePoints = {[0] = 0, [1] = 10, [2] = 25, [3] = 50, [4] = 100}
-                                        { x = 0, y = 1 },
+---------------------
-                                        { x = -1, y = -1 } } } },
+-- function centerText(x,y,w,text)
-                { start_position = { x = 4, y = 0 },
+  -- gpu.set(x+math.floor(w/2-string.len(text)/2),y,text)
-                  color = { 255, 0, 255 },
+-- end
-                  symbol = "L",
+
-                  transformations = { { { x = -1, y = 0 },
+-- function messageBox(title,text,color)
-                                        { x = 0, y = 0 },
+  -- local x,y=cfg.mapWidth-9,math.floor(cfg.mapHeight/2)-3
-                                        { x = 1, y = 0 },
+  -- local len1,len2=string.len(title),string.len(text)
-                                        { x = 1, y = 1 } },
+  -- local len3=math.max(len1,len2)+2
-                                      { { x = 0, y = -1 },
+  -- gpu.setBackground(0xffffff)
-                                        { x = 0, y = 0 },
+  -- gpu.fill(x,y,len3,2+3," ")
-                                        { x = 0, y = 1 },
+  -- gpu.setForeground(color or 0xFF0000)
-                                        { x = 1, y = -1 } },
+  -- centerText(x,y+1,len3,title)
-                                      { { x = -1, y = 0 },
+  -- gpu.setForeground(0x000000)
-                                        { x = 0, y = 0 },
+  -- centerText(x,y+3,len3,text)
-                                        { x = 1, y = 0 },
+  -- gpu.setBackground(color or 0xFF0000)
-                                        { x = -1, y = -1 } },
+  -- gpu.setForeground(0xffffff)
-                                      { { x = 0, y = -1 },
+  -- gpu.fill(x,y+5,len3,3," ")
-                                        { x = 0, y = 0 },
+  -- centerText(x,y+6,len3,"OK!")
-                                        { x = 0, y = 1 },
+-- end
-                                        { x = -1, y = 1 } } } },
+----------------------------------------------------------------
-                { start_position = { x = 4, y = 0 },
+StockBlocks = { { start_position = { x = 1, y = 1 },
-                  color = { 255, 0, 0 },
+                  color = 0xFFFF00,
-                  symbol = "I",
+                  symbol = "T",
-                  transformations = { { { x = -1, y = 0 },
+                  transformations = { { { x = -1, y = 0 },
-                                        { x = 0, y = 0 },
+                                        { x = 0, y = 0 },
-                                        { x = 1, y = 0 },
+                                        { x = 1, y = 0 },
-                                        { x = 2, y = 0 } },
+                                        { x = 0, y = -1 } },
-                                      { { x = 0, y = -1 },
+                                      { { x = 0, y = 0 },
-                                        { x = 0, y = 0 },
+                                        { x = 0, y = -1 },
-                                        { x = 0, y = 1 },
+                                        { x = 0, y = 1 },
-                                        { x = 0, y = 2 } } } },
+                                        { x = -1, y = 0 } },
-                { start_position = { x = 4, y = 0 },
+                                      { { x = -1, y = 0 },
-                  color = { 0, 0, 255 },
+                                        { x = 0, y = 0 },
-                  symbol = "[]",
+                                        { x = 1, y = 0 },
-                  transformations = { { { x = 0, y = 0 },
+                                        { x = 0, y = 1 } },
-                                        { x = 0, y = 1 },
+                                      { { x = 0, y = 0 },
-                                        { x = 1, y = 0 },
+                                        { x = 0, y = -1 },
-                                        { x = 1, y = 1 } } } }
+                                        { x = 0, y = 1 },
-             }
+                                        { x = 1, y = 0 } } } },
-
+
-function toXY(num,wid)
+                { start_position = { x = 1, y = 1 },
-  wid=wid or width
+                  color = 0x00FF00,
-  y=math.floor((num-1)/wid)+1
+                  symbol = "Z",
-  return num-(y-1)*width,y
+                  transformations = { { { x = -1, y = 0 },
-end
+                                        { x = 0, y = 0 },
-function fromXY(x,y,wid)
+                                        { x = 0, y = -1 },
-  wid=wid or width
+                                        { x = 1, y = -1 } },
-  return (y-1)*wid+x
+                                      { { x = 0, y = -1 },
-end
+                                        { x = 0, y = 0 },
-
+                                        { x = 1, y = 0 },
-for i=-1000,2500 do
+                                        { x = 1, y = 1 } } } },
-  mas[i]=0
+                { start_position = { x = 1, y = 1 },
-end
+                  color = 0x9999CC,
---print(StockBlocks[1].transformations[1][1].y)
+                  symbol = "S",
---[[f=7
+                  transformations = { { { x = 1, y = 0 },
-tr=1
+                                        { x = 0, y = 0 },
-for i=1,4 do
+                                        { x = 0, y = -1 },
-  gpu.set(StockBlocks[f].transformations[tr][i].x+5,StockBlocks[f].transformations[tr][i].y+5,"!")
+                                        { x = -1, y = -1 } },
-end]]--
+                                      { { x = 0, y = 1 },
-obj={
+                                        { x = 0, y = 0 },
-  id=-1,
+                                        { x = 1, y = 0 },
-  x=-1,
+                                        { x = 1, y = -1 } } } },
-  y=-1,
+                { start_position = { x = 1, y = 0 },
-  dX=0,
+                  color = 0xFFFF99,
-  dY=0,
+                  symbol = "J",
-  dR=0,
+                  transformations = { { { x = -1, y = 0 },
-  rotate=-1,
+                                        { x = 0, y = 0 },
-}
+                                        { x = 1, y = 0 },
-function newTile(tile)
+                                        { x = -1, y = 1 } },
-  tile=tile or (math.random(1,7))
+                                      { { x = 0, y = -1 },
-  obj.id=tile
+                                        { x = 0, y = 0 },
-  obj.x,obj.y=StockBlocks[tile].start_position.x+5,StockBlocks[tile].start_position.y
+                                        { x = 0, y = 1 },
-  obj.rotate=1
+                                        { x = 1, y = 1 } },
-  if test() then
+                                      { { x = -1, y = 0 },
-    gpu.setForeground(0xff0000)
+                                        { x = 0, y = 0 },
-    gpu.set(10,1,"GAME OVER")
+                                        { x = 1, y = 0 },
-    os.sleep(0.5)
+                                        { x = 1, y = -1 } },
-    gpu.setForeground(0xffffff)
+                                      { { x = 0, y = -1 },
-    isRunning=false
+                                        { x = 0, y = 0 },
-  else
+                                        { x = 0, y = 1 },
-    clearLines()
+                                        { x = -1, y = -1 } } } },
-  end
+                { start_position = { x = 1, y = 0 },
---  print("!")
+                  color = 0xFF00FF,
-end
+                  symbol = "L",
-function drawBlock(x,y,color)
+                  transformations = { { { x = -1, y = 0 },
-  gpu.set((x-1)*2+1,y,"  ")
+                                        { x = 0, y = 0 },
-end
+                                        { x = 1, y = 0 },
-function drawTile(color)
+                                        { x = 1, y = 1 } },
-  gpu.setBackground(color or 0x005500)
+                                      { { x = 0, y = -1 },
---  print(obj.id,obj.rotate)
+                                        { x = 0, y = 0 },
-  for i=1,4 do
+                                        { x = 0, y = 1 },
-    drawBlock(StockBlocks[obj.id].transformations[obj.rotate][i].x+obj.x,StockBlocks[obj.id].transformations[obj.rotate][i].y+obj.y)
+                                        { x = 1, y = -1 } },
-  end
+                                      { { x = -1, y = 0 },
-  gpu.setBackground(0x000000)
+                                        { x = 0, y = 0 },
-end
+                                        { x = 1, y = 0 },
-function testLine(line)
+                                        { x = -1, y = -1 } },
-  for x=1,fieldWidth-1 do
+                                      { { x = 0, y = -1 },
-    if mas[fromXY(x,line)]==0 then
+                                        { x = 0, y = 0 },
-      return false
+                                        { x = 0, y = 1 },
-    end
+                                        { x = -1, y = 1 } } } },
-  end
+                { start_position = { x = 1, y = 0 },
-  return true
+                  color = 0xFF0000,
-end
+                  symbol = "I",
-function clearLines()
+                  transformations = { { { x = -1, y = 0 },
---  gpu.set(90,1,"!")
+                                        { x = 0, y = 0 },
-  for i=1,fieldHeight do
+                                        { x = 1, y = 0 },
-    if testLine(i) then
+                                        { x = 2, y = 0 } },
-      downTiles(i)
+                                      { { x = 0, y = -1 },
---      gpu.set(90,2,"!")
+                                        { x = 0, y = 0 },
-      gpu.set(1,i,string.rep(" ",fieldWidth*2-2))
+                                        { x = 0, y = 1 },
-      os.sleep(0.5)
+                                        { x = 0, y = 2 } } } },
-      gpu.copy(1,i-20,fieldWidth*2-1,20,0,1)
+                { start_position = { x = 1, y = 0 },
-    end
+                  color = 0x0000FF,
-  end
+                  symbol = "[]",
-end
+                  transformations = { { { x = 0, y = 0 },
-function downTiles(line)
+                                        { x = 0, y = 1 },
-  for i=line,1,-1 do
+                                        { x = 1, y = 0 },
-    for j=1,fieldWidth+2 do
+                                        { x = 1, y = 1 } } } }
-      mas[fromXY(j,i)]=mas[fromXY(j,i-1)]
+             }
-    end
+
-  end
+local width = cfg.mapWidth + 10 --width of map NOT field
-end
+local score -- = 0
-function test()
+local map -- = {}
-  for i=1,4 do
+local control
-    local x,y=StockBlocks[obj.id].transformations[obj.rotate][i].x+obj.x,StockBlocks[obj.id].transformations[obj.rotate][i].y+obj.y
+local tick
-    if (y==fieldHeight)or(mas[fromXY(x,y)]~=0)or(x>=fieldWidth)or(x<1) then
+local isRunning = false
-      return true
+local isInited = false
-    end
+
-  end
+function toXY(num,wid)
-  return false
+  wid=wid or width
-end
+  y=math.floor((num-1)/wid)+1
-function putInMap()
+  return num-(y-1)*width,y
-  for j=1,4 do
+end
-    mas[fromXY(StockBlocks[obj.id].transformations[obj.rotate][j].x+obj.x,StockBlocks[obj.id].transformations[obj.rotate][j].y+obj.y)]=1
+function fromXY(x,y,wid)
-  end
+  wid = wid or width
-end
+  return (y-1)*wid+x
-function mapUpdate()
+end
-  drawTile(0x000000)
+
-  if step2 then
+-- TODO DELETE
-    obj.y=obj.y+1
+-- for i=-1000,2500 do
-  end
+  -- map[i]=0
---  obj.x=obj.x+obj.dX
+-- end
-  if (test())and(step2) then
+--print(StockBlocks[1].transformations[1][1].y)
---    obj.x=obj.x-obj.dX
+--[[f=7
-      obj.y=obj.y-1
+tr=1
-    drawTile()
+for i=1,4 do
-    putInMap()
+  gpu.set(StockBlocks[f].transformations[tr][i].x+5,StockBlocks[f].transformations[tr][i].y+5,"!")
-    newTile()
+end]]--
-  else
+local fObj, nextObj, sObj
-    if obj.dY==1 then
+local gCanvas, pCanvas
-      drawTile(0x000000)
+
-      obj.y=obj.y+1
+local scoreObj
-      if test() then
+function GetScore()
-        obj.y=obj.y-1
+  return tonumber(scoreObj.Text)
-        drawTile()
+end
-        putInMap()
+
-        newTile()
+function SetScore(value)
-      end
+  scoreObj:Modify{Text = tostring(value)}:Paint()
-    end
+end
-    if obj.dX~=0 then
+
-      drawTile(0x000000)
+function IncreaseScore(amount)
-      obj.x=obj.x+obj.dX
+  SetScore(GetScore() + amount)
-      if test() then
+end
-        obj.x=obj.x-obj.dX
+
-      end
+function randomID()
-    end
+  -- return 6
-    if obj.dR~=0 then
+  return math.random(1, 7)
-      local tmp=obj.rotate
+end
-      drawTile(0x000000)
+
-      obj.rotate=(obj.rotate+#StockBlocks[obj.id].transformations)%(#StockBlocks[obj.id].transformations)+1
+function createObject(id, x, y)
-      if test() then
+  id = id or randomID()
-        obj.rotate=tmp
+  local obj = {}
-      end
+  obj.id = id
---      obj.rotate=obj.rotate+1
+  obj.x, obj.y = StockBlocks[id].start_position.x + (x or cfg.startX), StockBlocks[id].start_position.y + (y or 0)
-    end
+  obj.color = StockBlocks[id].color
-  end
+  obj.rotate = 1
-  obj.dX=0
+  return obj
-  obj.dY=0
+end
-  obj.dR=0
+
-  drawTile()
+function cloneObject(obj, x, y, r)
-end
+  local nObj = {}
-function onKey(ev,_,code1,code2,player)
+  for index, value in pairs(obj) do
-  if (code1==113)and(code2==16) then
+    nObj[index] = value
-    isRunning=false
+  end
-  elseif (code1==0) then
+  nObj.x = nObj.x + (x or 0)
-    if code2==203 then--left
+  nObj.y = nObj.y + (y or 0)
-      obj.dX=-1
+  nObj.rotate = (nObj.rotate - 1 + (r or 0) + #StockBlocks[obj.id].transformations) % (#StockBlocks[obj.id].transformations) + 1
-    elseif code2==200 then--up
+  return nObj
-      obj.dR=1
+end
-    elseif code2==205 then--right
+
-      obj.dX=1
+function createShadow(obj)
-    elseif code2==208 then--down
+  local sObj = cloneObject(obj)
-      obj.dY=1
+  while check(sObj) do
-    end
+    sObj.y = sObj.y + 1
-  end
+  end
-end
+  sObj.y = sObj.y - 1
-newTile()
+  return sObj
-drawTile()
+end
-isRunning=true
+
-event.ignore("key_down",onKey)
+function drawBlock(canvas, x, y, color)
-event.listen("key_down",onKey)
+  canvas.set(x * 2 - 1, y, "  ")
-step2=false
+end
-gpu.setBackground(0x222222)
+
-require("term").clear()
+function drawObject(canvas, obj, color)
-gpu.setBackground(0x000000)
+  gpu.setBackground(color or obj.color)
-gpu.fill(1,1,fieldWidth*2-2,fieldHeight-1," ")
+  for i = 1, 4 do
-while isRunning do
+    drawBlock(canvas, StockBlocks[obj.id].transformations[obj.rotate][i].x + obj.x,StockBlocks[obj.id].transformations[obj.rotate][i].y + obj.y)
-  step2=not step2
+  end
-  os.sleep(0.15)
+  gpu.setBackground(0x000000)
-  mapUpdate()
+end
---  for i=1,fieldWidth do
+
---    gpu.set(70+i,3,tostring(mas[fromXY(i,25)]))
+function drawPredict(obj)
---  end
+  gpu.setBackground(cfg.backColor)
-end
+  pCanvas.fill(1, 1, 8, 4, " ")
-event.ignore("key_down",onKey)
+  drawObject(pCanvas, obj)
 end
 
 function checkLine(line)
   for x = 1, cfg.mapWidth do
     if not map[fromXY(x, line)] then
       return false
     end
   end
   return true
 end
 
 function fallBlocks(line)
   for i = line, 1, -1 do
     for j = 1, cfg.mapWidth do
       map[fromXY(j,i)] = map[fromXY(j,i-1)]
     end
   end
 end
 
 function clearLines()
   local cnt, offset = 0, 0
   -- for i = cfg.mapHeight, 1, -1 do
     -- if checkLine(i) then
       -- cnt = cnt + 1
       -- offset = offset + 1
       -- gpu.set(1, i - offset, string.rep(" ", cfg.mapWidth * 2))
       -- os.sleep(cfg.fallLinesDelay)
       -- gpu.copy(1, i - cfg.mapHeight, cfg.mapWidth * 2, cfg.mapHeight, 0, 1)
     -- end
     -- if offset > 0 then
       -- for j = 1, cfg.mapWidth do
         -- map[fromXY(j, i - offset)] = map[fromXY(j, i)]
       -- end
     -- end
   -- end
   for i = 1, cfg.mapHeight do
     if checkLine(i) then
       cnt = cnt + 1
       fallBlocks(i) -- ... TODO SPEEDUP
       gpu.set(1, i, string.rep(" ", cfg.mapWidth * 2))
       os.sleep(cfg.fallLinesDelay)
       gpu.copy(1, i - cfg.mapHeight, cfg.mapWidth * 2, cfg.mapHeight, 0, 1)
     end
   end
   return cnt
 end
 
 function check(obj)
   for i = 1, 4 do
     local x, y = StockBlocks[obj.id].transformations[obj.rotate][i].x + obj.x, StockBlocks[obj.id].transformations[obj.rotate][i].y + obj.y
     if (y == cfg.mapHeight + 1) or (map[fromXY(x,y)]) or (x > cfg.mapWidth) or (x < 1) then
       return false
     end
   end
   return true
 end
 
 function putInMap(obj)
   for j = 1, 4 do
     map[fromXY(StockBlocks[obj.id].transformations[obj.rotate][j].x + obj.x, StockBlocks[obj.id].transformations[obj.rotate][j].y + obj.y)] = 1
   end
 end
 
 function GameInit()
   map = {}
   control = {}
   SetScore(0)
   fObj = createObject()
   sObj = createShadow(fObj)
   nextObj = createObject(nil, 1, 2)
   tick = 0
 end
 
 function DrawMap()
   -- gpu.setBackground(0x222222)
   -- require("term").clear()
   gpu.setBackground(cfg.backColor)
   gCanvas:Paint()
   -- gpu.fill(1, 1, cfg.mapWidth * 2, cfg.mapHeight, " ")
   drawPredict(nextObj)
   if cfg.drawShadow then
     drawObject(gCanvas, sObj, cfg.shadowColor)
   end
 end
 
 function GameHandle()
   local dX = 0
   local dY = 0
   local dR = 0
   if control.l then
     dX = dX - 1
   end
   if control.r then
     dX = dX + 1
   end
   if control.d then
     dY = 1
   end
   if control.u then
     dR = -1
     control.u = false
   end
   -- control = {}
 
   tick = (tick + 1) % cfg.fallTickCnt
 
   local moved = false
   local shadowMoved = false
   local tObj = cloneObject(fObj)
 
   if dX ~= 0 then
     fObj.x = fObj.x + dX
     if not check(fObj) then
       fObj.x = fObj.x - dX
     else
       moved = true
       shadowMoved = true
     end
   end
   if dR ~= 0 then
     fObj.rotate = (fObj.rotate - 1 + dR + #StockBlocks[fObj.id].transformations) % (#StockBlocks[fObj.id].transformations) + 1
     if not check(fObj) then
       fObj.rotate = (fObj.rotate - 1 - dR + #StockBlocks[fObj.id].transformations) % (#StockBlocks[fObj.id].transformations) + 1
     else
       moved = true
       shadowMoved = true
     end
   end
 
   local freeze = false
   if dY ~= 0 then
     tick = 0
     fObj.y = fObj.y + dY
     if not check(fObj) then
       freeze = true
       fObj.y = fObj.y - dY
     else
       moved = true
     end
   elseif tick == 0 then
     fObj.y = fObj.y + 1
     if not check(fObj) then
       freeze = true
       fObj.y = fObj.y - 1
     else
       moved = true
     end
   end
 
   if cfg.drawShadow and shadowMoved then
     drawObject(gCanvas, sObj, cfg.backColor)
     sObj = createShadow(fObj)
     drawObject(gCanvas, sObj, cfg.shadowColor)
   end
   if moved then
     drawObject(gCanvas, tObj, cfg.backColor)
     drawObject(gCanvas, fObj)
   end
   if freeze then
     putInMap(fObj)
     IncreaseScore(linePoints[clearLines()])
     fObj = nextObj
     fObj.x, fObj.y = StockBlocks[fObj.id].start_position.x + cfg.startX, StockBlocks[fObj.id].start_position.y
     if not check(fObj) then
       gui.backend.MessageBox:Create("GAME OVER", "Your score: "..GetScore()):Modify{ScreenWidth = cfg.mapWidth * 2, ScreenHeight = cfg.mapHeight}:Init():Paint()
       -- messageBox("GAME OVER","Your score: "..GetScore())
       -- gpu.setForeground(0xffffff)
       isRunning = false
     else
       clearLines()
     end
     if cfg.drawShadow then
       sObj = createShadow(fObj)
       drawObject(gCanvas, sObj, cfg.shadowColor)
     end
     drawObject(gCanvas, fObj)
     nextObj = createObject(nil, 1, 2)
     drawPredict(nextObj)
   end
 
   os.sleep(cfg.tickDelay)
 end
 
 function onKeyDown(ev, _, code1, code2, player)
   if (code1==113)and(code2==16) then
     isRunning = false -- TODO REMOVE
   elseif (code1==0) then
     if code2 == 203 then--left
       control.l = true
     elseif code2==200 then--up
       control.u = true
     elseif code2==205 then--right
       control.r = true
     elseif code2==208 then--down
       control.d = true
     end
   end
 end
 
 function onKeyUp(ev, _, code1, code2, player)
   if code2 == 203 then--left
     control.l = false
   elseif code2==200 then--up
     -- control.u = false
   elseif code2==205 then--right
     control.r = false
   elseif code2==208 then--down
     control.d = false
   end
 end
 -------------------- GUI --------------------
 local quit = false
 gui.Init()
 
 GameForm = gui.backend.Form:Create(cfg.mapWidth * 2 + 12, cfg.mapHeight,
   {
     canvas = gui.backend.Canvas:Create(1, 1, cfg.mapWidth * 2, cfg.mapHeight),
     panel = gui.CreateGroup(
     {
       OnPaint = function(self)
         gpu.setBackground(0x222222)
         gpu.fill(self.X, 1, self.Width, cfg.mapHeight, " ")
       end
     },
     {
       canvas = gui.backend.Canvas:Create(3, 1, 8, 4),
       gui.backend.Text:Create(1, 6, 12, "Score:"):Modify{BackColor = 0x222222},
       score = gui.backend.Text:Create(1, 7, 12, "0"):Modify{BackColor = 0x222222},
       -- gui.backend.CheckBox:Create(1, 9, 12, "Shadow", true):Modify{BackColor = 0x222222},
       gui.backend.Button:Create(1, 9, 12, 1, "New Game", function(self)
         -- if isRunning then
           -- self.Text = "Start"
         -- else
           -- self.Text = "Restart"
         -- end
         -- self:Paint()
         -- gpu.set(1, 1, self.Parent.Elements["pause"].X .. " " .. self.Parent.Elements["pause"].Y)os.sleep(1)
         self.Parent.Elements["pause"]:Modify{Text = "Pause"}:Paint()
         GameInit()
         DrawMap()
         isInited = true
         isRunning = true
       end),
       pause = gui.backend.Button:Create(1, 11, 12, 1, "Pause", function(self)
         if not isInited then
           return
         end
         if isRunning then
           self.Text = "Resume"
         else
           self.Text = "Pause"
         end
         -- isRunning = false
         isRunning = not isRunning
         self:Paint()
       end),
       gui.backend.Button:Create(1, 13, 12, 1, "Settings", function(self)
         -- self.Parent.Elements["pause"]:OnElementClick()
         isRunning = false
         isInited = false
         self.Parent.Elements["pause"].Text = "Pause"
         GameForm:Disable(true)
         SettingsForm:Enable():Paint()
       end),
       gui.backend.Button:Create(1, 15, 12, 1, "Exit", function() quit = true end),
     }, cfg.mapWidth * 2 + 1, gui.GetCenter(1, cfg.mapHeight, 15), 12, cfg.mapHeight),
   }
 ):Init()
 
 SettingsForm = gui.backend.Form:Create(20, 13,
   {
     gui.backend.Text:Create(1, 1, 20, "Settings"),
 
     gui.backend.Text:Create(1, 3, nil, "Width"),
     MapWidth = gui.backend.TextBox:Create(1, 4, 20, cfg.mapWidth .. "", "0123456789"),
     MapWidthError = gui.backend.Text:Create(1, 5, nil, ""):Modify{TextColor = 0xff0000},
 
     gui.backend.Text:Create(1, 6, nil, "Height"),
     MapHeight = gui.backend.TextBox:Create(1, 7, 20, cfg.mapHeight .. "", "0123456789"),
     MapHeightError = gui.backend.Text:Create(1, 8, nil, ""):Modify{TextColor = 0xff0000},
 
     DrawShadow = gui.backend.CheckBox:Create(1, 9, 0, "Draw Shadow", cfg.drawShadow),
 
     gui.backend.Button:Create(1, 11, 20, 3, "Back", function()
       cfg.mapWidth = SettingsForm.Elements["MapWidth"].Text + 0
       cfg.startX = gui.GetCenter(1, cfg.mapWidth, 1) - 1
       width = cfg.mapWidth + 10
       cfg.mapHeight = SettingsForm.Elements["MapHeight"].Text + 0
       cfg.drawShadow = SettingsForm.Elements["DrawShadow"].Checked
       SettingsForm.Elements["MapWidthError"]:Modify{Text = ""}:Paint()
       SettingsForm.Elements["MapWidth"]:Modify{TextColor = 0xffffff}:Paint()
       SettingsForm.Elements["MapHeightError"]:Modify{Text = ""}:Paint()
       SettingsForm.Elements["MapHeight"]:Modify{TextColor = 0xffffff}:Paint()
 
       local err, msg = ValidateConfig()
       if err ~= nil then
         SettingsForm.Elements[err]:Modify{Text = msg}:Paint()
         SettingsForm.Elements[unicode.sub(err, 1, -6)]:Modify{TextColor = 0xff0000}:Paint()
         return false
       end
 
       GameForm.Width = cfg.mapWidth * 2 + 12
       local offsetX = cfg.mapWidth * 2 + 1 - GameForm.Elements["panel"].X
       local offsetY = gui.GetCenter(1, cfg.mapHeight, 15) - GameForm.Elements["panel"].Y
       -- GameForm.Elements["panel"].X = cfg.mapWidth * 2 + 1
       for index, element in pairs(GameForm.Elements["panel"].Elements) do
         element.X = element.X + offsetX
         element.Y = element.Y + offsetY
       end
       GameForm.Elements["panel"].Elements["canvas"]:Init() -- kostil need fix
       GameForm.Elements["panel"].X = GameForm.Elements["panel"].X + offsetX
       GameForm.Elements["panel"].Y = GameForm.Elements["panel"].Y + offsetY
       GameForm.Height = cfg.mapHeight
       SettingsForm:Disable(true)
       GameForm:Enable():Paint()
     end),
   }
 ):Init()
 
 GameForm:Enable():Paint()
 
 gCanvas = GameForm.Elements["canvas"]
 pCanvas = GameForm.Elements["panel"].Elements["canvas"]
 scoreObj = GameForm.Elements["panel"].Elements["score"]
 
 
 -- GameInit()
 -- DrawMap()
 event.ignore("key_down", onKeyDown)
 event.listen("key_down", onKeyDown)
 event.ignore("key_up", onKeyUp)
 event.listen("key_up", onKeyUp)
 
 local suc, err = pcall(function()
   while not quit do
     if isRunning then
       GameHandle()
     else
       event.pull()
     end
   end
 end)
 
 if not suc then
   print(err)
   os.sleep(3)
 end
 
 gui.Destroy()
 event.ignore("key_down", onKeyDown)
 event.ignore("key_up", onKeyUp)
 gpu.setBackground(0x000000)
 gpu.setForeground(0xffffff)