main.lua

-- Generated by Haxe 4.0.0-rc.1+1fc84df26
local _hx_array_mt = {
  __newindex = function(t,k,v)
    local len = t.length
    t.length =  k >= len and (k + 1) or len
    rawset(t,k,v)
  end
}

local function _hx_tab_array(tab,length)
  tab.length = length
  return setmetatable(tab, _hx_array_mt)
end

local function _hx_anon_newindex(t,k,v) t.__fields__[k] = true; rawset(t,k,v); end
local _hx_anon_mt = {__newindex=_hx_anon_newindex}
local function _hx_a(...)
  local __fields__ = {};
  local ret = {__fields__ = __fields__};
  local max = select('#',...);
  local tab = {...};
  local cur = 1;
  while cur < max do
    local v = tab[cur];
    __fields__[v] = true;
    ret[v] = tab[cur+1];
    cur = cur + 2
  end
  return setmetatable(ret, _hx_anon_mt)
end

local function _hx_e()
  return setmetatable({__fields__ = {}}, _hx_anon_mt)
end

local function _hx_o(obj)
  return setmetatable(obj, _hx_anon_mt)
end

local function _hx_new(prototype)
  return setmetatable({__fields__ = {}}, {__newindex=_hx_anon_newindex, __index=prototype})
end

local _hxClasses = {}
local Int = _hx_e();
local Dynamic = _hx_e();
local Float = _hx_e();
local Bool = _hx_e();
local Class = _hx_e();
local Enum = _hx_e();

local Array = _hx_e()
__defold_support_Script = _hx_e()
local Block = _hx_e()
local Board = _hx_e()
local Connector = _hx_e()
local MagicFx = _hx_e()
local Main = _hx_e()
local Math = _hx_e()
local Messages = _hx_e()
local String = _hx_e()
local Std = _hx_e()
__defold_CollectionproxyMessages = _hx_e()
__defold_GoMessages = _hx_e()
__defold_SpriteMessages = _hx_e()
__defold_support_GuiScript = _hx_e()
__gui_NoDropRoom = _hx_e()
__gui_MainMenu = _hx_e()
__gui_Restart = _hx_e()
__gui_PresentLevel = _hx_e()
__gui_Board = _hx_e()
__gui_LevelComplete = _hx_e()
__defold_support_Init = _hx_e()
__lua_Boot = _hx_e()

local _hx_bind, _hx_bit, _hx_staticToInstance, _hx_funcToField, _hx_maxn, _hx_print, _hx_apply_self, _hx_box_mr, _hx_bit_clamp, _hx_table, _hx_bit_raw
local _hx_pcall_default = {};
local _hx_pcall_break = {};

Array.new = function() 
  local self = _hx_new(Array.prototype)
  Array.super(self)
  return self
end
Array.super = function(self) 
  _hx_tab_array(self, 0);
end
Array.prototype = _hx_a();
Array.prototype.concat = function(self,a) 
  local _g = _hx_tab_array({}, 0);
  local _g1 = 0;
  local _g2 = self;
  while (_g1 < _g2.length) do 
    local i = _g2[_g1];
    _g1 = _g1 + 1;
    _g:push(i);
  end;
  local _g3 = 0;
  while (_g3 < a.length) do 
    local i1 = a[_g3];
    _g3 = _g3 + 1;
    _g:push(i1);
  end;
  do return _g end
end
Array.prototype.join = function(self,sep) 
  local tbl = ({});
  local _gthis = self;
  local cur_length = 0;
  local i = _hx_o({__fields__={hasNext=true,next=true},hasNext=function(self) 
    do return cur_length < _gthis.length end;
  end,next=function(self) 
    cur_length = cur_length + 1;
    do return _gthis[cur_length - 1] end;
  end});
  while (i:hasNext()) do 
    _G.table.insert(tbl, Std.string(i:next()));
  end;
  do return _G.table.concat(tbl, sep) end
end
Array.prototype.pop = function(self) 
  if (self.length == 0) then 
    do return nil end;
  end;
  local ret = self[self.length - 1];
  self[self.length - 1] = nil;
  self.length = self.length - 1;
  do return ret end
end
Array.prototype.push = function(self,x) 
  self[self.length] = x;
  do return self.length end
end
Array.prototype.reverse = function(self) 
  local tmp;
  local i = 0;
  while (i < Std.int(self.length / 2)) do 
    tmp = self[i];
    self[i] = self[(self.length - i) - 1];
    self[(self.length - i) - 1] = tmp;
    i = i + 1;
  end;
end
Array.prototype.shift = function(self) 
  if (self.length == 0) then 
    do return nil end;
  end;
  local ret = self[0];
  if (self.length == 1) then 
    self[0] = nil;
  else
    if (self.length > 1) then 
      self[0] = self[1];
      _G.table.remove(self, 1);
    end;
  end;
  local tmp = self;
  tmp.length = tmp.length - 1;
  do return ret end
end
Array.prototype.slice = function(self,pos,_end) 
  if ((_end == nil) or (_end > self.length)) then 
    _end = self.length;
  else
    if (_end < 0) then 
      _end = _G.math.fmod((self.length - (_G.math.fmod(-_end, self.length))), self.length);
    end;
  end;
  if (pos < 0) then 
    pos = _G.math.fmod((self.length - (_G.math.fmod(-pos, self.length))), self.length);
  end;
  if ((pos > _end) or (pos > self.length)) then 
    do return _hx_tab_array({}, 0) end;
  end;
  local ret = _hx_tab_array({}, 0);
  local _g = pos;
  local _g1 = _end;
  while (_g < _g1) do 
    _g = _g + 1;
    ret:push(self[_g - 1]);
  end;
  do return ret end
end
Array.prototype.sort = function(self,f) 
  local i = 0;
  local l = self.length;
  while (i < l) do 
    local swap = false;
    local j = 0;
    local max = (l - i) - 1;
    while (j < max) do 
      if (f(self[j], self[j + 1]) > 0) then 
        local tmp = self[j + 1];
        self[j + 1] = self[j];
        self[j] = tmp;
        swap = true;
      end;
      j = j + 1;
    end;
    if (not swap) then 
      break;
    end;
    i = i + 1;
  end;
end
Array.prototype.splice = function(self,pos,len) 
  if ((len < 0) or (pos > self.length)) then 
    do return _hx_tab_array({}, 0) end;
  else
    if (pos < 0) then 
      pos = self.length - (_G.math.fmod(-pos, self.length));
    end;
  end;
  len = Math.min(len, self.length - pos);
  local ret = _hx_tab_array({}, 0);
  local _g = pos;
  local _g1 = pos + len;
  while (_g < _g1) do 
    _g = _g + 1;
    local i = _g - 1;
    ret:push(self[i]);
    self[i] = self[i + len];
  end;
  local _g2 = pos + len;
  local _g3 = self.length;
  while (_g2 < _g3) do 
    _g2 = _g2 + 1;
    local i1 = _g2 - 1;
    self[i1] = self[i1 + len];
  end;
  local tmp = self;
  tmp.length = tmp.length - len;
  do return ret end
end
Array.prototype.toString = function(self) 
  local tbl = ({});
  _G.table.insert(tbl, "[");
  _G.table.insert(tbl, self:join(","));
  _G.table.insert(tbl, "]");
  do return _G.table.concat(tbl, "") end
end
Array.prototype.unshift = function(self,x) 
  local len = self.length;
  local _g = 0;
  while (_g < len) do 
    _g = _g + 1;
    local i = _g - 1;
    self[len - i] = self[(len - i) - 1];
  end;
  self[0] = x;
end
Array.prototype.insert = function(self,pos,x) 
  if (pos > self.length) then 
    pos = self.length;
  end;
  if (pos < 0) then 
    pos = self.length + pos;
    if (pos < 0) then 
      pos = 0;
    end;
  end;
  local cur_len = self.length;
  while (cur_len > pos) do 
    self[cur_len] = self[cur_len - 1];
    cur_len = cur_len - 1;
  end;
  self[pos] = x;
end
Array.prototype.remove = function(self,x) 
  local _g = 0;
  local _g1 = self.length;
  while (_g < _g1) do 
    _g = _g + 1;
    local i = _g - 1;
    if (self[i] == x) then 
      local _g2 = i;
      local _g11 = self.length - 1;
      while (_g2 < _g11) do 
        _g2 = _g2 + 1;
        local j = _g2 - 1;
        self[j] = self[j + 1];
      end;
      self[self.length - 1] = nil;
      self.length = self.length - 1;
      do return true end;
    end;
  end;
  do return false end
end
Array.prototype.indexOf = function(self,x,fromIndex) 
  local _end = self.length;
  if (fromIndex == nil) then 
    fromIndex = 0;
  else
    if (fromIndex < 0) then 
      fromIndex = self.length + fromIndex;
      if (fromIndex < 0) then 
        fromIndex = 0;
      end;
    end;
  end;
  local _g = fromIndex;
  while (_g < _end) do 
    _g = _g + 1;
    local i = _g - 1;
    if (x == self[i]) then 
      do return i end;
    end;
  end;
  do return -1 end
end
Array.prototype.lastIndexOf = function(self,x,fromIndex) 
  if ((fromIndex == nil) or (fromIndex >= self.length)) then 
    fromIndex = self.length - 1;
  else
    if (fromIndex < 0) then 
      fromIndex = self.length + fromIndex;
      if (fromIndex < 0) then 
        do return -1 end;
      end;
    end;
  end;
  local i = fromIndex;
  while (i >= 0) do 
    if (self[i] == x) then 
      do return i end;
    else
      i = i - 1;
    end;
  end;
  do return -1 end
end
Array.prototype.copy = function(self) 
  local _g = _hx_tab_array({}, 0);
  local _g1 = 0;
  local _g2 = self;
  while (_g1 < _g2.length) do 
    local i = _g2[_g1];
    _g1 = _g1 + 1;
    _g:push(i);
  end;
  do return _g end
end
Array.prototype.map = function(self,f) 
  local _g = _hx_tab_array({}, 0);
  local _g1 = 0;
  local _g2 = self;
  while (_g1 < _g2.length) do 
    local i = _g2[_g1];
    _g1 = _g1 + 1;
    _g:push(f(i));
  end;
  do return _g end
end
Array.prototype.filter = function(self,f) 
  local _g = _hx_tab_array({}, 0);
  local _g1 = 0;
  local _g2 = self;
  while (_g1 < _g2.length) do 
    local i = _g2[_g1];
    _g1 = _g1 + 1;
    if (f(i)) then 
      _g:push(i);
    end;
  end;
  do return _g end
end
Array.prototype.iterator = function(self) 
  local _gthis = self;
  local cur_length = 0;
  do return _hx_o({__fields__={hasNext=true,next=true},hasNext=function(self) 
    do return cur_length < _gthis.length end;
  end,next=function(self) 
    cur_length = cur_length + 1;
    do return _gthis[cur_length - 1] end;
  end}) end
end
Array.prototype.resize = function(self,len) 
  if (self.length < len) then 
    self.length = len;
  else
    if (self.length > len) then 
      local _g = len;
      local _g1 = self.length;
      while (_g < _g1) do 
        _g = _g + 1;
        self[_g - 1] = nil;
      end;
      self.length = len;
    end;
  end;
end

__defold_support_Script.new = function() 
  local self = _hx_new()
  __defold_support_Script.super(self)
  return self
end
__defold_support_Script.super = function(self) 
end

Block.new = function() 
  local self = _hx_new(Block.prototype)
  Block.super(self)
  return self
end
Block.super = function(self) 
  __defold_support_Script.super(self);
end
Block.prototype = _hx_a();
Block.prototype.init = function(self,_self) 
  _G.go.set_scale(0.18);
  _self.fx1 = nil;
  _self.fx2 = nil;
  _G.msg.post("#cover", __defold_GoMessages.disable);
  if (_self.color ~= nil) then 
    _G.msg.post("#sprite", __defold_SpriteMessages.play_animation, _hx_o({__fields__={id=true},id=_self.color}));
  else
    _G.msg.post("#sprite", __defold_GoMessages.disable);
  end;
end
Block.prototype.final_ = function(self,_self) 
  if (_self.fx1 ~= nil) then 
    _G.go.delete(_self.fx1);
  end;
  if (_self.fx2 ~= nil) then 
    _G.go.delete(_self.fx2);
  end;
  if (_self.cover ~= nil) then 
    _G.go.delete(_self.cover);
  end;
end
Block.prototype.on_message = function(self,_self,message_id,message,_) 
  local message_id1 = message_id;
  if (message_id1) == Messages.lights_off or (message_id1) == Messages.lights_on then 
    _G.msg.post(_self.fx1, message_id);
    _G.msg.post(_self.fx2, message_id);
  elseif (message_id1) == Messages.make_magic then 
    _self.color = _G.hash("magic");
    _G.msg.post("#cover", __defold_GoMessages.enable);
    _G.msg.post("#sprite", __defold_GoMessages.enable);
    _G.msg.post("#sprite", __defold_SpriteMessages.play_animation, _hx_o({__fields__={id=true},id=_G.hash("magic-sphere_layer1")}));
    local hleft = _G.hash("left");
    local hright = _G.hash("right");
    _self.fx1 = _G.factory.create("#fxfactory", _G.vmath.vector3(0, 0, 0), nil, ({direction = hleft}));
    _self.fx2 = _G.factory.create("#fxfactory", _G.vmath.vector3(0, 0, 0), nil, ({direction = hright}));
    _G.msg.post(_self.fx1, __defold_GoMessages.set_parent, _hx_o({__fields__={parent_id=true,keep_world_transform=true},parent_id=_G.go.get_id(),keep_world_transform=0}));
    _G.msg.post(_self.fx2, __defold_GoMessages.set_parent, _hx_o({__fields__={parent_id=true,keep_world_transform=true},parent_id=_G.go.get_id(),keep_world_transform=0}));
    _G.go.set(_self.fx1, "position.z", 0.01);
    _G.go.set(_self.fx1, "scale", 1);
    _G.go.set(_self.fx2, "position.z", 0.02);
    _G.go.set(_self.fx2, "scale", 1); end;
end
Block.__super__ = __defold_support_Script
setmetatable(Block.prototype,{__index=__defold_support_Script.prototype})

Board.new = function() 
  local self = _hx_new(Board.prototype)
  Board.super(self)
  return self
end
Board.super = function(self) 
  __defold_support_Script.super(self);
end
Board.build_blocklist = function(_self) 
  _self.blocks = _hx_tab_array({}, 0);
  local _g = 0;
  local _g1 = _self.board.length;
  while (_g < _g1) do 
    _g = _g + 1;
    local col = _self.board[_g - 1];
    local _g2 = 0;
    local _g11 = col.length;
    while (_g2 < _g11) do 
      _g2 = _g2 + 1;
      local b = col[_g2 - 1];
      if (b ~= nil) then 
        _self.blocks:push(_hx_o({__fields__={id=true,color=true,x=true,y=true},id=b.id,color=b.color,x=b.x,y=b.y}));
      end;
    end;
  end;
end
Board.magic_blocks = function(_self) 
  local magic = _hx_tab_array({}, 0);
  local block = _self.board[0][0];
  if ((block ~= nil) and (block.color == _G.hash("magic"))) then 
    magic:push(block);
  end;
  local block1 = _self.board[0][1];
  if ((block1 ~= nil) and (block1.color == _G.hash("magic"))) then 
    magic:push(block1);
  end;
  local block2 = _self.board[0][2];
  if ((block2 ~= nil) and (block2.color == _G.hash("magic"))) then 
    magic:push(block2);
  end;
  local block3 = _self.board[0][3];
  if ((block3 ~= nil) and (block3.color == _G.hash("magic"))) then 
    magic:push(block3);
  end;
  local block4 = _self.board[0][4];
  if ((block4 ~= nil) and (block4.color == _G.hash("magic"))) then 
    magic:push(block4);
  end;
  local block5 = _self.board[0][5];
  if ((block5 ~= nil) and (block5.color == _G.hash("magic"))) then 
    magic:push(block5);
  end;
  local block6 = _self.board[0][6];
  if ((block6 ~= nil) and (block6.color == _G.hash("magic"))) then 
    magic:push(block6);
  end;
  local block7 = _self.board[0][7];
  if ((block7 ~= nil) and (block7.color == _G.hash("magic"))) then 
    magic:push(block7);
  end;
  local block8 = _self.board[0][8];
  if ((block8 ~= nil) and (block8.color == _G.hash("magic"))) then 
    magic:push(block8);
  end;
  local block9 = _self.board[1][0];
  if ((block9 ~= nil) and (block9.color == _G.hash("magic"))) then 
    magic:push(block9);
  end;
  local block10 = _self.board[1][1];
  if ((block10 ~= nil) and (block10.color == _G.hash("magic"))) then 
    magic:push(block10);
  end;
  local block11 = _self.board[1][2];
  if ((block11 ~= nil) and (block11.color == _G.hash("magic"))) then 
    magic:push(block11);
  end;
  local block12 = _self.board[1][3];
  if ((block12 ~= nil) and (block12.color == _G.hash("magic"))) then 
    magic:push(block12);
  end;
  local block13 = _self.board[1][4];
  if ((block13 ~= nil) and (block13.color == _G.hash("magic"))) then 
    magic:push(block13);
  end;
  local block14 = _self.board[1][5];
  if ((block14 ~= nil) and (block14.color == _G.hash("magic"))) then 
    magic:push(block14);
  end;
  local block15 = _self.board[1][6];
  if ((block15 ~= nil) and (block15.color == _G.hash("magic"))) then 
    magic:push(block15);
  end;
  local block16 = _self.board[1][7];
  if ((block16 ~= nil) and (block16.color == _G.hash("magic"))) then 
    magic:push(block16);
  end;
  local block17 = _self.board[1][8];
  if ((block17 ~= nil) and (block17.color == _G.hash("magic"))) then 
    magic:push(block17);
  end;
  local block18 = _self.board[2][0];
  if ((block18 ~= nil) and (block18.color == _G.hash("magic"))) then 
    magic:push(block18);
  end;
  local block19 = _self.board[2][1];
  if ((block19 ~= nil) and (block19.color == _G.hash("magic"))) then 
    magic:push(block19);
  end;
  local block20 = _self.board[2][2];
  if ((block20 ~= nil) and (block20.color == _G.hash("magic"))) then 
    magic:push(block20);
  end;
  local block21 = _self.board[2][3];
  if ((block21 ~= nil) and (block21.color == _G.hash("magic"))) then 
    magic:push(block21);
  end;
  local block22 = _self.board[2][4];
  if ((block22 ~= nil) and (block22.color == _G.hash("magic"))) then 
    magic:push(block22);
  end;
  local block23 = _self.board[2][5];
  if ((block23 ~= nil) and (block23.color == _G.hash("magic"))) then 
    magic:push(block23);
  end;
  local block24 = _self.board[2][6];
  if ((block24 ~= nil) and (block24.color == _G.hash("magic"))) then 
    magic:push(block24);
  end;
  local block25 = _self.board[2][7];
  if ((block25 ~= nil) and (block25.color == _G.hash("magic"))) then 
    magic:push(block25);
  end;
  local block26 = _self.board[2][8];
  if ((block26 ~= nil) and (block26.color == _G.hash("magic"))) then 
    magic:push(block26);
  end;
  local block27 = _self.board[3][0];
  if ((block27 ~= nil) and (block27.color == _G.hash("magic"))) then 
    magic:push(block27);
  end;
  local block28 = _self.board[3][1];
  if ((block28 ~= nil) and (block28.color == _G.hash("magic"))) then 
    magic:push(block28);
  end;
  local block29 = _self.board[3][2];
  if ((block29 ~= nil) and (block29.color == _G.hash("magic"))) then 
    magic:push(block29);
  end;
  local block30 = _self.board[3][3];
  if ((block30 ~= nil) and (block30.color == _G.hash("magic"))) then 
    magic:push(block30);
  end;
  local block31 = _self.board[3][4];
  if ((block31 ~= nil) and (block31.color == _G.hash("magic"))) then 
    magic:push(block31);
  end;
  local block32 = _self.board[3][5];
  if ((block32 ~= nil) and (block32.color == _G.hash("magic"))) then 
    magic:push(block32);
  end;
  local block33 = _self.board[3][6];
  if ((block33 ~= nil) and (block33.color == _G.hash("magic"))) then 
    magic:push(block33);
  end;
  local block34 = _self.board[3][7];
  if ((block34 ~= nil) and (block34.color == _G.hash("magic"))) then 
    magic:push(block34);
  end;
  local block35 = _self.board[3][8];
  if ((block35 ~= nil) and (block35.color == _G.hash("magic"))) then 
    magic:push(block35);
  end;
  local block36 = _self.board[4][0];
  if ((block36 ~= nil) and (block36.color == _G.hash("magic"))) then 
    magic:push(block36);
  end;
  local block37 = _self.board[4][1];
  if ((block37 ~= nil) and (block37.color == _G.hash("magic"))) then 
    magic:push(block37);
  end;
  local block38 = _self.board[4][2];
  if ((block38 ~= nil) and (block38.color == _G.hash("magic"))) then 
    magic:push(block38);
  end;
  local block39 = _self.board[4][3];
  if ((block39 ~= nil) and (block39.color == _G.hash("magic"))) then 
    magic:push(block39);
  end;
  local block40 = _self.board[4][4];
  if ((block40 ~= nil) and (block40.color == _G.hash("magic"))) then 
    magic:push(block40);
  end;
  local block41 = _self.board[4][5];
  if ((block41 ~= nil) and (block41.color == _G.hash("magic"))) then 
    magic:push(block41);
  end;
  local block42 = _self.board[4][6];
  if ((block42 ~= nil) and (block42.color == _G.hash("magic"))) then 
    magic:push(block42);
  end;
  local block43 = _self.board[4][7];
  if ((block43 ~= nil) and (block43.color == _G.hash("magic"))) then 
    magic:push(block43);
  end;
  local block44 = _self.board[4][8];
  if ((block44 ~= nil) and (block44.color == _G.hash("magic"))) then 
    magic:push(block44);
  end;
  local block45 = _self.board[5][0];
  if ((block45 ~= nil) and (block45.color == _G.hash("magic"))) then 
    magic:push(block45);
  end;
  local block46 = _self.board[5][1];
  if ((block46 ~= nil) and (block46.color == _G.hash("magic"))) then 
    magic:push(block46);
  end;
  local block47 = _self.board[5][2];
  if ((block47 ~= nil) and (block47.color == _G.hash("magic"))) then 
    magic:push(block47);
  end;
  local block48 = _self.board[5][3];
  if ((block48 ~= nil) and (block48.color == _G.hash("magic"))) then 
    magic:push(block48);
  end;
  local block49 = _self.board[5][4];
  if ((block49 ~= nil) and (block49.color == _G.hash("magic"))) then 
    magic:push(block49);
  end;
  local block50 = _self.board[5][5];
  if ((block50 ~= nil) and (block50.color == _G.hash("magic"))) then 
    magic:push(block50);
  end;
  local block51 = _self.board[5][6];
  if ((block51 ~= nil) and (block51.color == _G.hash("magic"))) then 
    magic:push(block51);
  end;
  local block52 = _self.board[5][7];
  if ((block52 ~= nil) and (block52.color == _G.hash("magic"))) then 
    magic:push(block52);
  end;
  local block53 = _self.board[5][8];
  if ((block53 ~= nil) and (block53.color == _G.hash("magic"))) then 
    magic:push(block53);
  end;
  local block54 = _self.board[6][0];
  if ((block54 ~= nil) and (block54.color == _G.hash("magic"))) then 
    magic:push(block54);
  end;
  local block55 = _self.board[6][1];
  if ((block55 ~= nil) and (block55.color == _G.hash("magic"))) then 
    magic:push(block55);
  end;
  local block56 = _self.board[6][2];
  if ((block56 ~= nil) and (block56.color == _G.hash("magic"))) then 
    magic:push(block56);
  end;
  local block57 = _self.board[6][3];
  if ((block57 ~= nil) and (block57.color == _G.hash("magic"))) then 
    magic:push(block57);
  end;
  local block58 = _self.board[6][4];
  if ((block58 ~= nil) and (block58.color == _G.hash("magic"))) then 
    magic:push(block58);
  end;
  local block59 = _self.board[6][5];
  if ((block59 ~= nil) and (block59.color == _G.hash("magic"))) then 
    magic:push(block59);
  end;
  local block60 = _self.board[6][6];
  if ((block60 ~= nil) and (block60.color == _G.hash("magic"))) then 
    magic:push(block60);
  end;
  local block61 = _self.board[6][7];
  if ((block61 ~= nil) and (block61.color == _G.hash("magic"))) then 
    magic:push(block61);
  end;
  local block62 = _self.board[6][8];
  if ((block62 ~= nil) and (block62.color == _G.hash("magic"))) then 
    magic:push(block62);
  end;
  do return magic end;
end
Board.count_magic_regions = function(blocks) 
  local maxr = 0;
  local _g = 0;
  while (_g < blocks.length) do 
    local m = blocks[_g];
    _g = _g + 1;
    if (m.region > maxr) then 
      maxr = m.region;
    end;
  end;
  do return maxr end;
end
Board.adjacent_magic_blocks = function(blocks,block) 
  do return blocks:filter(function(e) 
    if (not ((block.x == e.x) and (_G.math.abs(block.y - e.y) == 1))) then 
      if (block.y == e.y) then 
        do return _G.math.abs(block.x - e.x) == 1 end;
      else
        do return false end;
      end;
    else
      do return true end;
    end;
  end) end;
end
Board.mark_neighbors = function(blocks,block,region) 
  local neighbors = Board.adjacent_magic_blocks(blocks, block);
  local _g = 0;
  while (_g < neighbors.length) do 
    local m = neighbors[_g];
    _g = _g + 1;
    if (m.region == nil) then 
      m.region = region;
      Board.mark_neighbors(blocks, m, region);
    end;
  end;
end
Board.mark_magic_regions = function(_self) 
  local m_blocks = Board.magic_blocks(_self);
  local _g = 0;
  while (_g < m_blocks.length) do 
    local m = m_blocks[_g];
    _g = _g + 1;
    m.region = nil;
    m.neighbors = Board.adjacent_magic_blocks(m_blocks, m).length;
  end;
  local region = 1;
  local _g1 = 0;
  while (_g1 < m_blocks.length) do 
    local m1 = m_blocks[_g1];
    _g1 = _g1 + 1;
    if (m1.region == nil) then 
      m1.region = region;
      Board.mark_neighbors(m_blocks, m1, region);
      region = region + 1;
    end;
  end;
  do return m_blocks end;
end
Board.highlight_magic = function(blocks) 
  local _g = 0;
  while (_g < blocks.length) do 
    local m = blocks[_g];
    _g = _g + 1;
    if (m.neighbors > 0) then 
      _G.msg.post(m.id, Messages.lights_on);
    else
      _G.msg.post(m.id, Messages.lights_off);
    end;
  end;
end
Board.clear_board = function(_self) 
  local _g = 0;
  local _g1 = _self.board;
  while (_g < _g1.length) do 
    local col = _g1[_g];
    _g = _g + 1;
    local _g2 = 0;
    local _g11 = col.length;
    while (_g2 < _g11) do 
      _g2 = _g2 + 1;
      local i = _g2 - 1;
      if (col[i] ~= nil) then 
        _G.go.delete(col[i].id);
        col[i] = nil;
      end;
    end;
  end;
end
Board.same_color_neighbors = function(_self,x,y) 
  do return _self.blocks:filter(function(v) 
    if (((v.id ~= _self.board[x][y].id) and (((v.x == x) or (v.x == (x - 1))) or (v.x == (x + 1)))) and (((v.y == y) or (v.y == (y - 1))) or (v.y == (y + 1)))) then 
      do return v.color == _self.board[x][y].color end;
    else
      do return false end;
    end;
  end) end;
end
Board.remove_chain = function(_self) 
  local _g = 0;
  local _g1 = _self.chain;
  while (_g < _g1.length) do 
    local c = _g1[_g];
    _g = _g + 1;
    _self.board[c.x][c.y] = Board.REMOVING_BLOCK;
    _G.go.delete(c.id);
  end;
  _self.chain = _hx_tab_array({}, 0);
end
Board.nilremoved = function(_self) 
  local _g = 0;
  local _g1 = _self.board;
  while (_g < _g1.length) do 
    local col = _g1[_g];
    _g = _g + 1;
    local _g2 = 0;
    local _g11 = col.length;
    while (_g2 < _g11) do 
      _g2 = _g2 + 1;
      local i = _g2 - 1;
      if (col[i] == Board.REMOVING_BLOCK) then 
        col[i] = nil;
      end;
    end;
  end;
end
Board.in_blocklist = function(blocks,block) 
  local _g = 0;
  while (_g < blocks.length) do 
    local b = blocks[_g];
    _g = _g + 1;
    if (b.id == block) then 
      do return true end;
    end;
  end;
  do return false end;
end
Board.dropspots = function(_self) 
  local spots = _hx_tab_array({}, 0);
  local _g = 0;
  while (_g < 7) do 
    _g = _g + 1;
    local x = _g - 1;
    local _g1 = 0;
    while (_g1 < 9) do 
      _g1 = _g1 + 1;
      local y = _g1 - 1;
      if (_self.board[x][y] == nil) then 
        spots:push(_hx_o({__fields__={x=true,y=true},x=x,y=y}));
        break;
      end;
    end;
  end;
  local _g11 = 1;
  local _g2 = spots.length - 3;
  while (_g11 < _g2) do 
    _g11 = _g11 + 1;
    spots:splice(Std.random(spots.length), 1);
  end;
  do return spots end;
end
Board.drop = function(_self,spots) 
  local _g = 0;
  while (_g < spots.length) do 
    local s = spots[_g];
    _g = _g + 1;
    local pos = _G.vmath.vector3();
    pos.x = 80. + (80 * s.x);
    pos.y = 1000;
    local c = Board.colors[Std.random(Board.colors.length)];
    local id = _G.factory.create("#blockfactory", pos, nil, ({color = c}));
    _G.go.animate(id, "position.y", _G.go.PLAYBACK_ONCE_FORWARD, 90. + (80 * s.y), _G.go.EASING_OUTBOUNCE, 0.5);
    _G.go.set(id, "position.z", (s.x * -0.1) + (s.y * 0.01));
    _self.board[s.x][s.y] = _hx_o({__fields__={id=true,color=true,x=true,y=true},id=id,color=c,x=s.x,y=s.y});
  end;
  Board.build_blocklist(_self);
end
Board.slide_board = function(_self) 
  local _g = 0;
  while (_g < 7) do 
    _g = _g + 1;
    local x = _g - 1;
    local dy = 0;
    local _g1 = 0;
    while (_g1 < 9) do 
      _g1 = _g1 + 1;
      local y = _g1 - 1;
      if (_self.board[x][y] ~= nil) then 
        if (dy > 0) then 
          _self.board[x][y - dy] = _self.board[x][y];
          _self.board[x][y] = nil;
          _self.board[x][y - dy].y = _self.board[x][y - dy].y - dy;
          _G.go.animate(_self.board[x][y - dy].id, "position.y", _G.go.PLAYBACK_ONCE_FORWARD, 90. + (80 * (y - dy)), _G.go.EASING_OUTBOUNCE, 0.3);
          _G.go.set(_self.board[x][y - dy].id, "position.z", (x * -0.1) + ((y - dy) * 0.01));
        end;
      else
        dy = dy + 1;
      end;
    end;
  end;
  Board.build_blocklist(_self);
end
Board.build_board = function(_self) 
  _G.math.randomseed(_G.os.time());
  local pos = _G.vmath.vector3();
  local _g = 0;
  while (_g < 7) do 
    _g = _g + 1;
    local x = _g - 1;
    pos.x = 80. + (80 * x);
    _self.board[x] = _hx_tab_array({}, 0);
    local _g1 = 0;
    while (_g1 < 9) do 
      _g1 = _g1 + 1;
      local y = _g1 - 1;
      pos.y = 90. + (80 * y);
      pos.z = (x * -0.1) + (y * 0.01);
      local c = Board.colors[Std.random(Board.colors.length)];
      local id = _G.factory.create("#blockfactory", pos, nil, ({color = c}));
      _self.board[x][y] = _hx_o({__fields__={id=true,color=true,x=true,y=true},id=id,color=c,x=x,y=y});
    end;
  end;
  local y1 = 0;
  local step = Std.int(9 / _self.num_magic);
  while (y1 < 9) do 
    local set = false;
    while (not set) do 
      local rand_y = Std.int(_G.math.random(_G.math.floor(y1), Math.min(8, _G.math.floor(y1 + (9 / _self.num_magic)))));
      local rand_x = Std.int(_G.math.random(0, 6));
      if (_self.board[rand_x][rand_y].color ~= _G.hash("magic")) then 
        _G.msg.post(_self.board[rand_x][rand_y].id, Messages.make_magic);
        _self.board[rand_x][rand_y].color = _G.hash("magic");
        set = true;
      end;
    end;
    y1 = y1 + step;
  end;
  Board.build_blocklist(_self);
  local magic_blocks = Board.mark_magic_regions(_self);
  if (Board.count_magic_regions(magic_blocks) == 1) then 
    Board.clear_board(_self);
    Board.build_board(_self);
  end;
  Board.highlight_magic(magic_blocks);
end
Board.slide_magic_blocks = function(_self) 
  local _g = 0;
  while (_g < 9) do 
    _g = _g + 1;
    local y = _g - 1;
    local row_m = _hx_tab_array({}, 0);
    local _g1 = 0;
    while (_g1 < 7) do 
      _g1 = _g1 + 1;
      local x = _g1 - 1;
      if (((_self.board[x][y] ~= nil) and (_self.board[x][y] ~= Board.REMOVING_BLOCK)) and (_self.board[x][y].color == _G.hash("magic"))) then 
        row_m:push(_self.board[x][y]);
      end;
    end;
    local mc = row_m.length + 1;
    while (row_m.length < mc) do 
      mc = row_m.length;
      local _g11 = 0;
      local _g2 = row_m.length;
      while (_g11 < _g2) do 
        _g11 = _g11 + 1;
        local i = _g11 - 1;
        local x1 = row_m[i].x;
        if ((y > 0) and (_self.board[x1][y - 1] == Board.REMOVING_BLOCK)) then 
          row_m[i] = nil;
        else
          if ((x1 > 0) and (_self.board[x1 - 1][y] == Board.REMOVING_BLOCK)) then 
            _self.board[x1 - 1][y] = _self.board[x1][y];
            _self.board[x1 - 1][y].x = x1 - 1;
            _G.go.animate(_self.board[x1][y].id, "position.x", _G.go.PLAYBACK_ONCE_FORWARD, 80. + (80 * (x1 - 1)), _G.go.EASING_OUTBOUNCE, 0.3);
            _G.go.set(_self.board[x1][y].id, "position.z", ((x1 - 1) * -0.1) + (y * 0.01));
            _self.board[x1][y] = Board.REMOVING_BLOCK;
            row_m[i] = nil;
          else
            if ((x1 < 6) and (_self.board[x1 + 1][y] == Board.REMOVING_BLOCK)) then 
              _self.board[x1 + 1][y] = _self.board[x1][y];
              _self.board[x1 + 1][y].x = x1 + 1;
              _G.go.animate(_self.board[x1 + 1][y].id, "position.x", _G.go.PLAYBACK_ONCE_FORWARD, 80. + (80 * (x1 + 1)), _G.go.EASING_OUTBOUNCE, 0.3);
              _G.go.set(_self.board[x1 + 1][y].id, "position.z", ((x1 + 1) * -0.1) + (y * 0.01));
              _self.board[x1][y] = Board.REMOVING_BLOCK;
              row_m[i] = nil;
            end;
          end;
        end;
      end;
    end;
  end;
end
Board.prototype = _hx_a();
Board.prototype.init = function(self,_self) 
  _self.board = _hx_tab_array({}, 0);
  _self.blocks = _hx_tab_array({}, 0);
  _self.chain = _hx_tab_array({}, 0);
  _self.connectors = _hx_tab_array({}, 0);
  _self.num_magic = 3;
  _self.drops = 1;
  _self.dragging = false;
end
Board.prototype.on_message = function(self,_self,message_id,message,_) 
  if (message_id) == Messages.drop then 
    local s = Board.dropspots(_self);
    if (s.length == 0) then 
      _G.msg.post("no_drop_room#gui", Messages.show);
    else
      if (_self.drops > 0) then 
        Board.drop(_self, s);
        _self.drops = _self.drops - 1;
        _G.msg.post("#gui", Messages.set_drop_counter, _hx_o({__fields__={drops=true},drops=_self.drops}));
      end;
    end;
  elseif (message_id) == Messages.level_completed then 
    _G.msg.post(".", __defold_GoMessages.release_input_focus);
    local _g = 0;
    local _g1 = Board.magic_blocks(_self);
    while (_g < _g1.length) do 
      local m = _g1[_g];
      _g = _g + 1;
      _G.go.set_scale(0.17, m.id);
      _G.go.animate(m.id, "scale", _G.go.PLAYBACK_LOOP_PINGPONG, 0.19, _G.go.EASING_INSINE, 0.5, 0);
    end;
    _G.msg.post("level_complete#gui", Messages.show);
  elseif (message_id) == Messages.next_level then 
    Board.clear_board(_self);
    _self.drops = _self.drops + 1;
    _G.msg.post("#", Messages.start_level, _hx_o({__fields__={difficulty=true},difficulty=_self.num_magic}));
  elseif (message_id) == Messages.restart_level then 
    Board.clear_board(_self);
    Board.build_board(_self);
    _self.drops = 1;
    _G.msg.post("#gui", Messages.set_drop_counter, _hx_o({__fields__={drops=true},drops=_self.drops}));
    _G.msg.post(".", __defold_GoMessages.acquire_input_focus);
  elseif (message_id) == Messages.start_level then 
    _self.num_magic = message.difficulty + 1;
    Board.build_board(_self);
    _G.msg.post("#gui", Messages.set_drop_counter, _hx_o({__fields__={drops=true},drops=_self.drops}));
    _G.msg.post("present_level#gui", __gui_PresentLevel.ShowMessage, _hx_o({__fields__={level=true},level=message.difficulty}));
    _G.go.animate("#", "timer", _G.go.PLAYBACK_ONCE_FORWARD, 1, _G.go.EASING_LINEAR, 2, 0, function(_1,_2,_3) 
      _G.msg.post("present_level#gui", Messages.hide);
      _G.msg.post(".", __defold_GoMessages.acquire_input_focus);
    end); end;
end
Board.prototype.on_input = function(self,_self,action_id,action) 
  if (action_id ~= _G.hash("touch")) then 
    do return false end;
  end;
  if (action.value == 1) then 
    local x = _G.math.floor((action.x - 40) / 80);
    local y = _G.math.floor((action.y - 40) / 80);
    if (((((x < 0) or (x >= 7)) or (y < 0)) or (y >= 9)) or (_self.board[x][y] == nil)) then 
      do return false end;
    end;
    if (_self.board[x][y].color == _G.hash("magic")) then 
      do return false end;
    end;
    if (action.pressed) then 
      _self.neighbors = Board.same_color_neighbors(_self, x, y);
      _self.chain = _hx_tab_array({[0]=_self.board[x][y]}, 1);
      local p = _G.go.get_position(_self.board[x][y].id);
      local b = Board.centeroff;
      _self.connectors:push(_G.factory.create("#connectorfactory", (p) + (b)));
      _self.dragging = true;
    else
      if (_self.dragging) then 
        if (Board.in_blocklist(_self.neighbors, _self.board[x][y].id) and not Board.in_blocklist(_self.chain, _self.board[x][y].id)) then 
          _self.chain:push(_self.board[x][y]);
          _self.neighbors = Board.same_color_neighbors(_self, x, y);
          local p1 = _G.go.get_position(_self.board[x][y].id);
          local b1 = Board.centeroff;
          local id = _G.factory.create("#connectorfactory", (p1) + (b1));
          _self.connectors:push(id);
        end;
      end;
    end;
  else
    if (action.released) then 
      _self.dragging = false;
      if (_self.chain.length > 1) then 
        Board.remove_chain(_self);
        Board.slide_magic_blocks(_self);
        Board.nilremoved(_self);
        Board.slide_board(_self);
        local magic_blocks = Board.mark_magic_regions(_self);
        if (Board.count_magic_regions(magic_blocks) == 1) then 
          _G.msg.post("#", Messages.level_completed);
        end;
        Board.highlight_magic(magic_blocks);
      end;
      local _g = 0;
      local _g1 = _self.connectors;
      while (_g < _g1.length) do 
        local c = _g1[_g];
        _g = _g + 1;
        _G.go.delete(c);
      end;
      _self.connectors = _hx_tab_array({}, 0);
    end;
  end;
  do return false end
end
Board.__super__ = __defold_support_Script
setmetatable(Board.prototype,{__index=__defold_support_Script.prototype})

Connector.new = function() 
  local self = _hx_new(Connector.prototype)
  Connector.super(self)
  return self
end
Connector.super = function(self) 
  __defold_support_Script.super(self);
end
Connector.prototype = _hx_a();
Connector.prototype.init = function(self,_) 
  _G.go.set_scale(0.18);
  _G.go.set(".", "position.z", 1);
end
Connector.__super__ = __defold_support_Script
setmetatable(Connector.prototype,{__index=__defold_support_Script.prototype})

MagicFx.new = function() 
  local self = _hx_new(MagicFx.prototype)
  MagicFx.super(self)
  return self
end
MagicFx.super = function(self) 
  __defold_support_Script.super(self);
end
MagicFx.prototype = _hx_a();
MagicFx.prototype.init = function(self,_self) 
  _G.msg.post("#", Messages.lights_off);
  if (_self.direction == _G.hash("left")) then 
    _G.go.set(".", "euler.z", 0);
    _G.go.animate(".", "euler.z", _G.go.PLAYBACK_LOOP_FORWARD, 360, _G.go.EASING_LINEAR, 5 + _G.math.random());
  else
    _G.go.set(".", "euler.z", 0);
    _G.go.animate(".", "euler.z", _G.go.PLAYBACK_LOOP_FORWARD, -360, _G.go.EASING_LINEAR, 4 + _G.math.random());
  end;
end
MagicFx.prototype.on_message = function(self,_self,message_id,message,_) 
  if (message_id) == Messages.lights_off then 
    _G.msg.post("#light", __defold_GoMessages.disable);
  elseif (message_id) == Messages.lights_on then 
    _G.msg.post("#light", __defold_GoMessages.enable); end;
end
MagicFx.__super__ = __defold_support_Script
setmetatable(MagicFx.prototype,{__index=__defold_support_Script.prototype})

Main.new = function() 
  local self = _hx_new(Main.prototype)
  Main.super(self)
  return self
end
Main.super = function(self) 
  __defold_support_Script.super(self);
end
Main.prototype = _hx_a();
Main.prototype.init = function(self,_self) 
  _G.msg.post("#", Messages.to_main_menu);
  _self.state = "MAIN_MENU";
  _G.particlefx.play("#particlefx");
end
Main.prototype.on_message = function(self,_self,message_id,message,sender) 
  if (message_id) == __defold_CollectionproxyMessages.proxy_loaded then 
    _G.msg.post(sender, __defold_CollectionproxyMessages.init);
    _G.msg.post("board:/board#script", Messages.start_level, _hx_o({__fields__={difficulty=true},difficulty=1}));
    _G.msg.post(sender, __defold_GoMessages.enable);
    _self.state = "GAME_RUNNING";
  elseif (message_id) == Messages.start_game then 
    _G.msg.post("#background", __defold_GoMessages.disable);
    _G.msg.post("#boardproxy", __defold_CollectionproxyMessages.load);
    _G.msg.post("#menu", __defold_GoMessages.disable);
  elseif (message_id) == Messages.to_main_menu then 
    if (_self.state ~= "MAIN_MENU") then 
      _G.msg.post("#boardproxy", __defold_CollectionproxyMessages.unload);
    end;
    _G.msg.post("main:/main#menu", __defold_GoMessages.enable);
    _G.msg.post("#background", __defold_GoMessages.enable);
    _self.state = "MAIN_MENU"; end;
end
Main.__super__ = __defold_support_Script
setmetatable(Main.prototype,{__index=__defold_support_Script.prototype})

Math.new = {}
Math.isNaN = function(f) 
  do return f ~= f end;
end
Math.isFinite = function(f) 
  if (f > -_G.math.huge) then 
    do return f < _G.math.huge end;
  else
    do return false end;
  end;
end
Math.min = function(a,b) 
  if (Math.isNaN(a) or Math.isNaN(b)) then 
    do return (0/0) end;
  else
    do return _G.math.min(a, b) end;
  end;
end

Messages.new = {}

String.new = function(string) 
  local self = _hx_new(String.prototype)
  String.super(self,string)
  self = string
  return self
end
String.super = function(self,string) 
end
String.__index = function(s,k) 
  if (k == "length") then 
    do return _G.string.len(s) end;
  else
    local o = String.prototype;
    local field = k;
    if ((function() 
      local _hx_1
      if ((_G.type(o) == "string") and ((String.prototype[field] ~= nil) or (field == "length"))) then 
      _hx_1 = true; elseif (o.__fields__ ~= nil) then 
      _hx_1 = o.__fields__[field] ~= nil; else 
      _hx_1 = o[field] ~= nil; end
      return _hx_1
    end )()) then 
      do return String.prototype[k] end;
    else
      if (String.__oldindex ~= nil) then 
        if (_G.type(String.__oldindex) == "function") then 
          do return String.__oldindex(s, k) end;
        else
          if (_G.type(String.__oldindex) == "table") then 
            do return String.__oldindex[k] end;
          end;
        end;
        do return nil end;
      else
        do return nil end;
      end;
    end;
  end;
end
String.fromCharCode = function(code) 
  do return _G.string.char(code) end;
end
String.prototype = _hx_a();
String.prototype.toUpperCase = function(self) 
  do return _G.string.upper(self) end
end
String.prototype.toLowerCase = function(self) 
  do return _G.string.lower(self) end
end
String.prototype.indexOf = function(self,str,startIndex) 
  if (startIndex == nil) then 
    startIndex = 1;
  else
    startIndex = startIndex + 1;
  end;
  local r = _G.string.find(self, str, startIndex, true);
  if ((r ~= nil) and (r > 0)) then 
    do return r - 1 end;
  else
    do return -1 end;
  end;
end
String.prototype.lastIndexOf = function(self,str,startIndex) 
  local ret = -1;
  if (startIndex == nil) then 
    startIndex = #self;
  end;
  while (true) do 
    local startIndex1 = ret + 1;
    if (startIndex1 == nil) then 
      startIndex1 = 1;
    else
      startIndex1 = startIndex1 + 1;
    end;
    local r = _G.string.find(self, str, startIndex1, true);
    local p = (function() 
      local _hx_1
      if ((r ~= nil) and (r > 0)) then 
      _hx_1 = r - 1; else 
      _hx_1 = -1; end
      return _hx_1
    end )();
    if ((p == -1) or (p > startIndex)) then 
      break;
    end;
    ret = p;
  end;
  do return ret end
end
String.prototype.split = function(self,delimiter) 
  local idx = 1;
  local ret = _hx_tab_array({}, 0);
  while (idx ~= nil) do 
    local newidx = 0;
    if (#delimiter > 0) then 
      newidx = _G.string.find(self, delimiter, idx, true);
    else
      if (idx >= #self) then 
        newidx = nil;
      else
        newidx = idx + 1;
      end;
    end;
    if (newidx ~= nil) then 
      ret:push(_G.string.sub(self, idx, newidx - 1));
      idx = newidx + #delimiter;
    else
      ret:push(_G.string.sub(self, idx, #self));
      idx = nil;
    end;
  end;
  do return ret end
end
String.prototype.toString = function(self) 
  do return self end
end
String.prototype.substring = function(self,startIndex,endIndex) 
  if (endIndex == nil) then 
    endIndex = #self;
  end;
  if (endIndex < 0) then 
    endIndex = 0;
  end;
  if (startIndex < 0) then 
    startIndex = 0;
  end;
  if (endIndex < startIndex) then 
    do return _G.string.sub(self, endIndex + 1, startIndex) end;
  else
    do return _G.string.sub(self, startIndex + 1, endIndex) end;
  end;
end
String.prototype.charAt = function(self,index) 
  do return _G.string.sub(self, index + 1, index + 1) end
end
String.prototype.charCodeAt = function(self,index) 
  do return _G.string.byte(self, index + 1) end
end
String.prototype.substr = function(self,pos,len) 
  if ((len == nil) or (len > (pos + #self))) then 
    len = #self;
  else
    if (len < 0) then 
      len = #self + len;
    end;
  end;
  if (pos < 0) then 
    pos = #self + pos;
  end;
  if (pos < 0) then 
    pos = 0;
  end;
  do return _G.string.sub(self, pos + 1, pos + len) end
end

Std.new = {}
Std.string = function(s) 
  do return __lua_Boot.__string_rec(s) end;
end
Std.int = function(x) 
  if (not Math.isFinite(x) or Math.isNaN(x)) then 
    do return 0 end;
  else
    do return _hx_bit_clamp(x) end;
  end;
end
Std.random = function(x) 
  if (x <= 0) then 
    do return 0 end;
  else
    do return _G.math.floor(_G.math.random() * x) end;
  end;
end

__defold_CollectionproxyMessages.new = {}

__defold_GoMessages.new = {}

__defold_SpriteMessages.new = {}

__defold_support_GuiScript.new = function() 
  local self = _hx_new()
  __defold_support_GuiScript.super(self)
  return self
end
__defold_support_GuiScript.super = function(self) 
end

__gui_NoDropRoom.new = function() 
  local self = _hx_new(__gui_NoDropRoom.prototype)
  __gui_NoDropRoom.super(self)
  return self
end
__gui_NoDropRoom.super = function(self) 
  __defold_support_GuiScript.super(self);
end
__gui_NoDropRoom.prototype = _hx_a();
__gui_NoDropRoom.prototype.init = function(self,_self) 
  _G.msg.post("#", Messages.hide);
  _self.t = 0;
end
__gui_NoDropRoom.prototype.update = function(self,_self,dt) 
  if (_self.t < 0) then 
    _G.msg.post("#", Messages.hide);
  else
    _self.t = _self.t - dt;
  end;
end
__gui_NoDropRoom.prototype.on_message = function(self,_self,message_id,message,_) 
  if (message_id) == Messages.hide then 
    _G.msg.post("#", __defold_GoMessages.disable);
  elseif (message_id) == Messages.show then 
    _self.t = 1;
    _G.msg.post("#", __defold_GoMessages.enable); end;
end
__gui_NoDropRoom.__super__ = __defold_support_GuiScript
setmetatable(__gui_NoDropRoom.prototype,{__index=__defold_support_GuiScript.prototype})

__gui_MainMenu.new = function() 
  local self = _hx_new(__gui_MainMenu.prototype)
  __gui_MainMenu.super(self)
  return self
end
__gui_MainMenu.super = function(self) 
  __defold_support_GuiScript.super(self);
end
__gui_MainMenu.prototype = _hx_a();
__gui_MainMenu.prototype.init = function(self,_) 
  _G.msg.post(".", __defold_GoMessages.acquire_input_focus);
  local bs = _hx_tab_array({[0]="brick1", "brick2", "brick3", "brick4", "brick5", "brick6"}, 6);
  local _g = 0;
  while (_g < bs.length) do 
    local b = bs[_g];
    _g = _g + 1;
    local n = _G.gui.get_node(b);
    local rt = (_G.math.random() * 3) + 1;
    local a = _G.math.random(-45, 45);
    _G.gui.set_color(n, _G.vmath.vector4(1, 1, 1, 0));
    _G.gui.animate(n, "position.y", -100 - _G.math.random(0, 50), _G.gui.EASING_INSINE, 1 + rt, 0, nil, _G.gui.PLAYBACK_LOOP_FORWARD);
    _G.gui.animate(n, "color.w", 1, _G.gui.EASING_INSINE, 1 + rt, 0, nil, _G.gui.PLAYBACK_LOOP_FORWARD);
    _G.gui.animate(n, "rotation.z", a, _G.gui.EASING_INSINE, 1 + rt, 0, nil, _G.gui.PLAYBACK_LOOP_FORWARD);
  end;
  _G.gui.animate(_G.gui.get_node("start"), "color.x", 1, _G.gui.EASING_INOUTSINE, 1, 0, nil, _G.gui.PLAYBACK_LOOP_PINGPONG);
end
__gui_MainMenu.prototype.on_input = function(self,_,action_id,action) 
  if ((action_id == _G.hash("touch")) and action.pressed) then 
    if (_G.gui.pick_node(_G.gui.get_node("start"), action.x, action.y)) then 
      _G.msg.post("/main#script", Messages.start_game);
    end;
  end;
  do return false end
end
__gui_MainMenu.__super__ = __defold_support_GuiScript
setmetatable(__gui_MainMenu.prototype,{__index=__defold_support_GuiScript.prototype})

__gui_Restart.new = function() 
  local self = _hx_new(__gui_Restart.prototype)
  __gui_Restart.super(self)
  return self
end
__gui_Restart.super = function(self) 
  __defold_support_GuiScript.super(self);
end
__gui_Restart.prototype = _hx_a();
__gui_Restart.prototype.on_message = function(self,_,message_id,message,_1) 
  if (message_id) == Messages.hide then 
    _G.msg.post("#", __defold_GoMessages.disable);
    _G.msg.post(".", __defold_GoMessages.release_input_focus);
  elseif (message_id) == Messages.show then 
    _G.msg.post("#", __defold_GoMessages.enable);
    _G.msg.post(".", __defold_GoMessages.acquire_input_focus); end;
end
__gui_Restart.prototype.on_input = function(self,_,action_id,action) 
  if ((action_id == _G.hash("touch")) and action.pressed) then 
    local yes = _G.gui.get_node("yes");
    local no = _G.gui.get_node("no");
    local quit = _G.gui.get_node("quit");
    if (_G.gui.pick_node(no, action.x, action.y)) then 
      _G.msg.post("#", Messages.hide);
      _G.msg.post("/board#gui", Messages.show);
    else
      if (_G.gui.pick_node(yes, action.x, action.y)) then 
        _G.msg.post("board:/board#script", Messages.restart_level);
        _G.msg.post("/board#gui", Messages.show);
        _G.msg.post("#", Messages.hide);
      else
        if (_G.gui.pick_node(quit, action.x, action.y)) then 
          _G.msg.post("main:/main#script", Messages.to_main_menu);
          _G.msg.post("#", Messages.hide);
        end;
      end;
    end;
  end;
  do return true end
end
__gui_Restart.__super__ = __defold_support_GuiScript
setmetatable(__gui_Restart.prototype,{__index=__defold_support_GuiScript.prototype})

__gui_PresentLevel.new = function() 
  local self = _hx_new(__gui_PresentLevel.prototype)
  __gui_PresentLevel.super(self)
  return self
end
__gui_PresentLevel.super = function(self) 
  __defold_support_GuiScript.super(self);
end
__gui_PresentLevel.prototype = _hx_a();
__gui_PresentLevel.prototype.init = function(self,_) 
  _G.msg.post("#", Messages.hide);
end
__gui_PresentLevel.prototype.on_message = function(self,_,message_id,message,_1) 
  if (message_id) == __gui_PresentLevel.ShowMessage then 
    _G.gui.set_text(_G.gui.get_node("message"), Std.string("Level ") .. Std.string(message.level));
    _G.msg.post("#", __defold_GoMessages.enable);
  elseif (message_id) == Messages.hide then 
    _G.msg.post("#", __defold_GoMessages.disable); end;
end
__gui_PresentLevel.__super__ = __defold_support_GuiScript
setmetatable(__gui_PresentLevel.prototype,{__index=__defold_support_GuiScript.prototype})

__gui_Board.new = function() 
  local self = _hx_new(__gui_Board.prototype)
  __gui_Board.super(self)
  return self
end
__gui_Board.super = function(self) 
  __defold_support_GuiScript.super(self);
end
__gui_Board.prototype = _hx_a();
__gui_Board.prototype.init = function(self,_) 
  _G.msg.post("#", Messages.show);
  _G.msg.post("/restart#gui", Messages.hide);
  _G.msg.post("/level_complete#gui", Messages.hide);
end
__gui_Board.prototype.on_message = function(self,_,message_id,message,_1) 
  if (message_id) == Messages.hide then 
    _G.msg.post("#", __defold_GoMessages.disable);
  elseif (message_id) == Messages.set_drop_counter then 
    _G.gui.set_text(_G.gui.get_node("drop_counter"), Std.string(message.drops) .. Std.string(" x"));
  elseif (message_id) == Messages.show then 
    _G.msg.post("#", __defold_GoMessages.enable); end;
end
__gui_Board.prototype.on_input = function(self,_,action_id,action) 
  if ((action_id == _G.hash("touch")) and action.pressed) then 
    local restart = _G.gui.get_node("restart");
    local drop = _G.gui.get_node("drop");
    if (_G.gui.pick_node(restart, action.x, action.y)) then 
      _G.msg.post("/restart#gui", Messages.show);
      _G.msg.post("#", Messages.hide);
    else
      if (_G.gui.pick_node(drop, action.x, action.y)) then 
        _G.msg.post("/board#script", Messages.drop);
      end;
    end;
  end;
  do return false end
end
__gui_Board.__super__ = __defold_support_GuiScript
setmetatable(__gui_Board.prototype,{__index=__defold_support_GuiScript.prototype})

__gui_LevelComplete.new = function() 
  local self = _hx_new(__gui_LevelComplete.prototype)
  __gui_LevelComplete.super(self)
  return self
end
__gui_LevelComplete.super = function(self) 
  __defold_support_GuiScript.super(self);
end
__gui_LevelComplete.prototype = _hx_a();
__gui_LevelComplete.prototype.init = function(self,_) 
  _G.msg.post("#", Messages.hide);
end
__gui_LevelComplete.prototype.on_message = function(self,_,message_id,_1,_2) 
  if (message_id) == Messages.hide then 
    _G.msg.post("#", __defold_GoMessages.disable);
    _G.msg.post(".", __defold_GoMessages.release_input_focus);
  elseif (message_id) == Messages.show then 
    _G.msg.post("#", __defold_GoMessages.enable);
    _G.msg.post(".", __defold_GoMessages.acquire_input_focus); end;
end
__gui_LevelComplete.prototype.on_input = function(self,_,action_id,action) 
  if ((action_id == _G.hash("touch")) and action.pressed) then 
    if (_G.gui.pick_node(_G.gui.get_node("continue"), action.x, action.y)) then 
      _G.msg.post("board#script", Messages.next_level);
      _G.msg.post("#", Messages.hide);
    end;
  end;
  do return true end
end
__gui_LevelComplete.__super__ = __defold_support_GuiScript
setmetatable(__gui_LevelComplete.prototype,{__index=__defold_support_GuiScript.prototype})

__defold_support_Init.new = {}
__defold_support_Init.init = function(exports) 
  local script = Board.new();
  exports.Board_init = function(_self) 
    script:init(_self);
  end;
  exports.Board_on_message = function(self1,message_id,message,_) 
    script:on_message(self1, message_id, message, _);
  end;
  exports.Board_on_input = function(self2,action_id,action) 
    do return script:on_input(self2, action_id, action) end;
  end;
  exports.Board_on_reload = function(_1) 
  end;
  local script1 = __gui_NoDropRoom.new();
  exports.gui_NoDropRoom_init = function(self3) 
    script1:init(self3);
  end;
  exports.gui_NoDropRoom_update = function(self4,dt) 
    script1:update(self4, dt);
  end;
  exports.gui_NoDropRoom_on_message = function(self5,message_id1,message1,_2) 
    script1:on_message(self5, message_id1, message1, _2);
  end;
  local script2 = __gui_MainMenu.new();
  exports.gui_MainMenu_init = function(_3) 
    script2:init(_3);
  end;
  exports.gui_MainMenu_on_input = function(_4,action_id1,action1) 
    do return script2:on_input(_4, action_id1, action1) end;
  end;
  local script3 = __gui_Restart.new();
  exports.gui_Restart_on_message = function(_5,message_id2,message2,_6) 
    script3:on_message(_6, message_id2, message2, _6);
  end;
  exports.gui_Restart_on_input = function(_7,action_id2,action2) 
    do return script3:on_input(_7, action_id2, action2) end;
  end;
  local script4 = __gui_PresentLevel.new();
  exports.gui_PresentLevel_init = function(_8) 
    script4:init(_8);
  end;
  exports.gui_PresentLevel_on_message = function(_9,message_id3,message3,_10) 
    script4:on_message(_10, message_id3, message3, _10);
  end;
  local script5 = Block.new();
  exports.Block_init = function(self6) 
    script5:init(self6);
  end;
  exports.Block_final_ = function(self7) 
    script5:final_(self7);
  end;
  exports.Block_on_message = function(self8,message_id4,message4,_11) 
    script5:on_message(self8, message_id4, message4, _11);
  end;
  local script6 = Main.new();
  exports.Main_init = function(self9) 
    script6:init(self9);
  end;
  exports.Main_on_message = function(self10,message_id5,message5,sender) 
    script6:on_message(self10, message_id5, message5, sender);
  end;
  local script7 = __gui_Board.new();
  exports.gui_Board_init = function(_12) 
    script7:init(_12);
  end;
  exports.gui_Board_on_message = function(_13,message_id6,message6,_14) 
    script7:on_message(_14, message_id6, message6, _14);
  end;
  exports.gui_Board_on_input = function(_15,action_id3,action3) 
    do return script7:on_input(_15, action_id3, action3) end;
  end;
  local script8 = Connector.new();
  exports.Connector_init = function(_16) 
    script8:init(_16);
  end;
  local script9 = __gui_LevelComplete.new();
  exports.gui_LevelComplete_init = function(_17) 
    script9:init(_17);
  end;
  exports.gui_LevelComplete_on_message = function(_18,message_id7,_19,_20) 
    script9:on_message(_20, message_id7, _20, _20);
  end;
  exports.gui_LevelComplete_on_input = function(_21,action_id4,action4) 
    do return script9:on_input(_21, action_id4, action4) end;
  end;
  local script10 = MagicFx.new();
  exports.MagicFx_init = function(self11) 
    script10:init(self11);
  end;
  exports.MagicFx_on_message = function(self12,message_id8,message7,_22) 
    script10:on_message(self12, message_id8, message7, _22);
  end;
end

__lua_Boot.new = {}
__lua_Boot.isArray = function(o) 
  if (_G.type(o) == "table") then 
    if ((o.__enum__ == nil) and (_G.getmetatable(o) ~= nil)) then 
      do return _G.getmetatable(o).__index == Array.prototype end;
    else
      do return false end;
    end;
  else
    do return false end;
  end;
end
__lua_Boot.printEnum = function(o,s) 
  if (o.length == 2) then 
    do return o[0] end;
  else
    local str = Std.string(Std.string(o[0])) .. Std.string("(");
    s = Std.string(s) .. Std.string("\t");
    local _g = 2;
    local _g1 = o.length;
    while (_g < _g1) do 
      _g = _g + 1;
      local i = _g - 1;
      if (i ~= 2) then 
        str = Std.string(str) .. Std.string((Std.string(",") .. Std.string(__lua_Boot.__string_rec(o[i], s))));
      else
        str = Std.string(str) .. Std.string(__lua_Boot.__string_rec(o[i], s));
      end;
    end;
    do return Std.string(str) .. Std.string(")") end;
  end;
end
__lua_Boot.printClassRec = function(c,result,s) 
  if (result == nil) then 
    result = "";
  end;
  local f = __lua_Boot.__string_rec;
  for k,v in pairs(c) do if result ~= '' then result = result .. ', ' end result = result .. k .. ':' .. f(v, s.. '	') end;
  do return result end;
end
__lua_Boot.__string_rec = function(o,s) 
  if (s == nil) then 
    s = "";
  end;
  local _g = type(o);
  if (_g) == "boolean" then 
    do return tostring(o) end;
  elseif (_g) == "function" then 
    do return "<function>" end;
  elseif (_g) == "nil" then 
    do return "null" end;
  elseif (_g) == "number" then 
    if (o == _G.math.huge) then 
      do return "Infinity" end;
    else
      if (o == -_G.math.huge) then 
        do return "-Infinity" end;
      else
        if (o == 0) then 
          do return "0" end;
        else
          if (o ~= o) then 
            do return "NaN" end;
          else
            do return tostring(o) end;
          end;
        end;
      end;
    end;
  elseif (_g) == "string" then 
    do return o end;
  elseif (_g) == "table" then 
    if (o.__enum__ ~= nil) then 
      do return __lua_Boot.printEnum(o, s) end;
    else
      if ((_hx_wrap_if_string_field(o,'toString') ~= nil) and not __lua_Boot.isArray(o)) then 
        do return _hx_wrap_if_string_field(o,'toString')(o) end;
      else
        if (__lua_Boot.isArray(o)) then 
          local o2 = o;
          if (#s > 5) then 
            do return "[...]" end;
          else
            local _g1 = _hx_tab_array({}, 0);
            local _g11 = 0;
            while (_g11 < o2.length) do 
              local i = o2[_g11];
              _g11 = _g11 + 1;
              _g1:push(__lua_Boot.__string_rec(i, Std.string(s) .. Std.string(1)));
            end;
            do return Std.string(Std.string("[") .. Std.string(_g1:join(","))) .. Std.string("]") end;
          end;
        else
          if (o.__class__ ~= nil) then 
            do return Std.string(Std.string("{") .. Std.string(__lua_Boot.printClassRec(o, "", Std.string(s) .. Std.string("\t")))) .. Std.string("}") end;
          else
            local fields = __lua_Boot.fieldIterator(o);
            local buffer = ({});
            local first = true;
            _G.table.insert(buffer, "{ ");
            local f = fields;
            while (f:hasNext()) do 
              local f1 = f:next();
              if (first) then 
                first = false;
              else
                _G.table.insert(buffer, ", ");
              end;
              _G.table.insert(buffer, Std.string(Std.string(Std.string("") .. Std.string(Std.string(f1))) .. Std.string(" : ")) .. Std.string(Std.string(o[f1])));
            end;
            _G.table.insert(buffer, " }");
            do return _G.table.concat(buffer, "") end;
          end;
        end;
      end;
    end;
  elseif (_g) == "thread" then 
    do return "<thread>" end;
  elseif (_g) == "userdata" then 
    local mt = _G.getmetatable(o);
    if ((mt ~= nil) and (mt.__tostring ~= nil)) then 
      do return _G.tostring(o) end;
    else
      do return "<userdata>" end;
    end;else
  _G.error("Unknown Lua type",0); end;
end
__lua_Boot.fieldIterator = function(o) 
  if (_G.type(o) ~= "table") then 
    do return _hx_o({__fields__={next=true,hasNext=true},next=function(self) 
      do return nil end;
    end,hasNext=function(self) 
      do return false end;
    end}) end;
  end;
  local tbl = (function() 
    local _hx_1
    if (o.__fields__ ~= nil) then 
    _hx_1 = o.__fields__; else 
    _hx_1 = o; end
    return _hx_1
  end )();
  local cur = _G.pairs(tbl);
  local next_valid = function(tbl1,val) 
    while (__lua_Boot.hiddenFields[val] ~= nil) do 
      val = cur(tbl1, val);
    end;
    do return val end;
  end;
  local cur_val = next_valid(tbl, cur(tbl, nil));
  do return _hx_o({__fields__={next=true,hasNext=true},next=function(self) 
    local ret = cur_val;
    cur_val = next_valid(tbl, cur(tbl, cur_val));
    do return ret end;
  end,hasNext=function(self) 
    do return cur_val ~= nil end;
  end}) end;
end
_hx_bit_clamp = function(v) 
  if v <= 2147483647 and v >= -2147483648 then
    if v > 0 then return _G.math.floor(v)
    else return _G.math.ceil(v)
    end
  end
  if v > 2251798999999999 then v = v*2 end;
  if (v ~= v or math.abs(v) == _G.math.huge) then return nil end
  return _hx_bit.band(v, 2147483647 ) - math.abs(_hx_bit.band(v, 2147483648))
end
pcall(require, 'bit')
if bit then
  _hx_bit = bit
else
  local _hx_bit_raw = _G.require('bit32')
  _hx_bit = setmetatable({}, { __index = _hx_bit_raw });
  _hx_bit.bnot = function(...) return _hx_bit_clamp(_hx_bit_raw.bnot(...)) end;
  _hx_bit.bxor = function(...) return _hx_bit_clamp(_hx_bit_raw.bxor(...)) end;
end
_hx_array_mt.__index = Array.prototype

local _hx_static_init = function()
  Board.REMOVING_BLOCK = _hx_o({__fields__={id=true,color=true,x=true,y=true},id=nil,color=nil,x=-1,y=-1});
  Board.centeroff = _G.vmath.vector3(8, -8, 0);
  Board.colors = _hx_tab_array({[0]=_G.hash("orange"), _G.hash("pink"), _G.hash("blue"), _G.hash("yellow"), _G.hash("green")}, 5);
  Messages.start_game = _G.hash("start_game");
  Messages.start_level = _G.hash("start_level");
  Messages.next_level = _G.hash("next_level");
  Messages.restart_level = _G.hash("restart_level");
  Messages.level_completed = _G.hash("level_completed");
  Messages.to_main_menu = _G.hash("to_main_menu");
  Messages.hide = _G.hash("hide");
  Messages.show = _G.hash("show");
  Messages.drop = _G.hash("drop");
  Messages.set_drop_counter = _G.hash("set_drop_counter");
  Messages.make_magic = _G.hash("make_magic");
  Messages.lights_on = _G.hash("lights_on");
  Messages.lights_off = _G.hash("lights_off");
  __defold_CollectionproxyMessages.init = _G.hash("init");
  __defold_CollectionproxyMessages.load = _G.hash("load");
  __defold_CollectionproxyMessages.proxy_loaded = _G.hash("proxy_loaded");
  __defold_CollectionproxyMessages.unload = _G.hash("unload");
  __defold_GoMessages.acquire_input_focus = _G.hash("acquire_input_focus");
  __defold_GoMessages.disable = _G.hash("disable");
  __defold_GoMessages.enable = _G.hash("enable");
  __defold_GoMessages.release_input_focus = _G.hash("release_input_focus");
  __defold_GoMessages.set_parent = _G.hash("set_parent");
  __defold_SpriteMessages.play_animation = _G.hash("play_animation");
  __gui_PresentLevel.ShowMessage = _G.hash("show");
  __lua_Boot.hiddenFields = {__id__=true, hx__closures=true, super=true, prototype=true, __fields__=true, __ifields__=true, __class__=true, __properties__=true}
  
  _hxdefold_ = _hxdefold_ or {}
  __defold_support_Init.init(_hxdefold_);
end

_G.math.randomseed(_G.os.time());
_hx_wrap_if_string_field = function(o, fld)
  if _G.type(o) == 'string' then
    if fld == 'length' then
      return _G.string.len(o)
    else
      return String.prototype[fld]
    end
  else
    return o[fld]
  end
end
_hx_static_init();