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 BonusStar = _hx_e()
local Factory = _hx_e()
local LargePlanets = _hx_e()
local Main = _hx_e()
local Math = _hx_e()
local Messages = _hx_e()
local SmallPlanets = _hx_e()
local Spaceship = _hx_e()
local Star = _hx_e()
local String = _hx_e()
local Std = _hx_e()
__defold_GoMessages = _hx_e()
__defold_PhysicsMessages = _hx_e()
__defold_RenderMessages = _hx_e()
__defold_SysMessages = _hx_e()
__defold_support_GuiScript = _hx_e()
__gui_Main = _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

BonusStar.new = function() 
  local self = _hx_new(BonusStar.prototype)
  BonusStar.super(self)
  return self
end
BonusStar.super = function(self) 
  __defold_support_Script.super(self);
end
BonusStar.prototype = _hx_a();
BonusStar.prototype.update = function(self,_,dt) 
  local p = _G.go.get_position();
  p.x = p.x + (BonusStar.speed * dt);
  if (p.x < -32) then 
    _G.go.delete();
  end;
  _G.go.set_position(p);
end
BonusStar.prototype.on_message = function(self,_,message_id,message,sender) 
  if (message_id == __defold_PhysicsMessages.collision_response) then 
    _G.msg.post("main#gui", Messages.AddScore, _hx_o({__fields__={amount=true},amount=BonusStar.score}));
    _G.go.delete();
  end;
end
BonusStar.__super__ = __defold_support_Script
setmetatable(BonusStar.prototype,{__index=__defold_support_Script.prototype})

Factory.new = function() 
  local self = _hx_new(Factory.prototype)
  Factory.super(self)
  return self
end
Factory.super = function(self) 
  __defold_support_Script.super(self);
end
Factory.prototype = _hx_a();
Factory.prototype.init = function(self,data) 
  data.timer = 1 / Factory.frequency;
  _G.math.randomseed(0);
end
Factory.prototype.update = function(self,data,dt) 
  data.timer = data.timer - dt;
  if (data.timer <= 0) then 
    data.timer = 1 / Factory.frequency;
    local p = _G.go.get_position();
    p.y = _G.vmath.lerp(_G.math.random(), Factory.min_y, Factory.max_y);
    local component = "#star_factory";
    if (_G.math.random() < Factory.bonus_prob) then 
      component = "#bonus_factory";
    end;
    _G.factory.create(component, p);
  end;
end
Factory.__super__ = __defold_support_Script
setmetatable(Factory.prototype,{__index=__defold_support_Script.prototype})

LargePlanets.new = function() 
  local self = _hx_new(LargePlanets.prototype)
  LargePlanets.super(self)
  return self
end
LargePlanets.super = function(self) 
  __defold_support_Script.super(self);
end
LargePlanets.prototype = _hx_a();
LargePlanets.prototype.update = function(self,_,dt) 
  local p = _G.go.get_position();
  p.x = p.x + (LargePlanets.speed * dt);
  if (p.x <= -2560) then 
    p.x = 2560;
  end;
  _G.go.set_position(p);
end
LargePlanets.__super__ = __defold_support_Script
setmetatable(LargePlanets.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,_) 
  _G.msg.post("@render:", __defold_RenderMessages.clear_color, _hx_o({__fields__={color=true},color=_G.vmath.vector4(0.52, 0.80, 1, 0)}));
  _G.msg.post(".", __defold_GoMessages.acquire_input_focus);
end
Main.prototype.on_input = function(self,_,action_id,action) 
  if ((action_id == _G.hash("ok")) and action.pressed) then 
    _G.print("OK");
  else
    if ((action_id == _G.hash("profiler_toggle")) and action.pressed) then 
      _G.msg.post("@system:", __defold_SysMessages.toggle_profile);
      do return true end;
    end;
  end;
  do return false 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 = {}

SmallPlanets.new = function() 
  local self = _hx_new(SmallPlanets.prototype)
  SmallPlanets.super(self)
  return self
end
SmallPlanets.super = function(self) 
  __defold_support_Script.super(self);
end
SmallPlanets.prototype = _hx_a();
SmallPlanets.prototype.update = function(self,_,dt) 
  local p = _G.go.get_position();
  p.x = p.x + (SmallPlanets.speed * dt);
  if (p.x <= -1280) then 
    p.x = 1280;
  end;
  _G.go.set_position(p);
end
SmallPlanets.__super__ = __defold_support_Script
setmetatable(SmallPlanets.prototype,{__index=__defold_support_Script.prototype})

Spaceship.new = function() 
  local self = _hx_new(Spaceship.prototype)
  Spaceship.super(self)
  return self
end
Spaceship.super = function(self) 
  __defold_support_Script.super(self);
end
Spaceship.prototype = _hx_a();
Spaceship.prototype.init = function(self,data) 
  _G.msg.post(".", __defold_GoMessages.acquire_input_focus);
  data.speed = 0;
  _G.go.set(".", "euler.z", -5);
  _G.go.animate(".", "euler.z", _G.go.PLAYBACK_LOOP_PINGPONG, 5, _G.go.EASING_INOUTSINE, 2);
end
Spaceship.prototype.update = function(self,data,dt) 
  local p = _G.go.get_position();
  p.y = p.y + (data.speed * dt);
  if (p.y < Spaceship.min_y) then 
    p.y = _hx_funcToField(Spaceship.min_y);
  else
    if (p.y > Spaceship.max_y) then 
      p.y = _hx_funcToField(Spaceship.max_y);
    end;
  end;
  _G.go.set_position(p);
  data.speed = 0;
end
Spaceship.prototype.on_input = function(self,data,action_id,action) 
  if (action_id == _G.hash("up")) then 
    data.speed = _hx_funcToField(Spaceship.max_speed);
  else
    if (action_id == _G.hash("down")) then 
      data.speed = -Spaceship.max_speed;
    end;
  end;
  do return false end
end
Spaceship.__super__ = __defold_support_Script
setmetatable(Spaceship.prototype,{__index=__defold_support_Script.prototype})

Star.new = function() 
  local self = _hx_new(Star.prototype)
  Star.super(self)
  return self
end
Star.super = function(self) 
  __defold_support_Script.super(self);
end
Star.prototype = _hx_a();
Star.prototype.update = function(self,_,dt) 
  local p = _G.go.get_position();
  p.x = p.x + (Star.speed * dt);
  if (p.x < -32) then 
    _G.go.delete();
  end;
  _G.go.set_position(p);
end
Star.prototype.on_message = function(self,_,message_id,message,sender) 
  if (message_id == __defold_PhysicsMessages.collision_response) then 
    _G.msg.post("main#gui", Messages.AddScore, _hx_o({__fields__={amount=true},amount=Star.score}));
    _G.go.delete();
  end;
end
Star.__super__ = __defold_support_Script
setmetatable(Star.prototype,{__index=__defold_support_Script.prototype})

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

__defold_GoMessages.new = {}

__defold_PhysicsMessages.new = {}

__defold_RenderMessages.new = {}

__defold_SysMessages.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_Main.new = function() 
  local self = _hx_new(__gui_Main.prototype)
  __gui_Main.super(self)
  return self
end
__gui_Main.super = function(self) 
  __defold_support_GuiScript.super(self);
end
__gui_Main.prototype = _hx_a();
__gui_Main.prototype.init = function(self,data) 
  data.score = 0;
  data.score_node = _G.gui.get_node("score");
end
__gui_Main.prototype.scale_down = function(self,data,node) 
  _G.gui.animate(node, _G.gui.PROP_SCALE, _G.vmath.vector4(1.0, 1.0, 1.0, 0), _G.gui.EASING_OUT, 0.05);
end
__gui_Main.prototype.on_message = function(self,data,message_id,message,sender) 
  if (message_id == Messages.AddScore) then 
    data.score = data.score + message.amount;
    _G.gui.set_text(data.score_node, Std.string(data.score));
    _G.gui.animate(data.score_node, _G.gui.PROP_SCALE, _G.vmath.vector4(1.2, 1.2, 1.2, 0), _G.gui.EASING_OUT, 0.1, 0.0, _hx_bind(self,self.scale_down));
  end;
end
__gui_Main.__super__ = __defold_support_GuiScript
setmetatable(__gui_Main.prototype,{__index=__defold_support_GuiScript.prototype})

__defold_support_Init.new = {}
__defold_support_Init.init = function(exports) 
  local script = LargePlanets.new();
  exports.LargePlanets_update = function(_,dt) 
    script:update(_, dt);
  end;
  local script1 = Main.new();
  exports.Main_init = function(_1) 
    script1:init(_1);
  end;
  exports.Main_on_input = function(_2,action_id,action) 
    do return script1:on_input(_2, action_id, action) end;
  end;
  local script2 = BonusStar.new();
  exports.BonusStar_update = function(_3,dt1) 
    script2:update(_3, dt1);
  end;
  exports.BonusStar_on_message = function(_4,message_id,message,sender) 
    script2:on_message(_4, message_id, message, sender);
  end;
  local script3 = Spaceship.new();
  exports.Spaceship_init = function(data) 
    script3:init(data);
  end;
  exports.Spaceship_update = function(data1,dt2) 
    script3:update(data1, dt2);
  end;
  exports.Spaceship_on_input = function(data2,action_id1,action1) 
    do return script3:on_input(data2, action_id1, action1) end;
  end;
  local script4 = Star.new();
  exports.Star_update = function(_5,dt3) 
    script4:update(_5, dt3);
  end;
  exports.Star_on_message = function(_6,message_id1,message1,sender1) 
    script4:on_message(_6, message_id1, message1, sender1);
  end;
  local script5 = Factory.new();
  exports.Factory_init = function(data3) 
    script5:init(data3);
  end;
  exports.Factory_update = function(data4,dt4) 
    script5:update(data4, dt4);
  end;
  local script6 = __gui_Main.new();
  exports.gui_Main_init = function(data5) 
    script6:init(data5);
  end;
  exports.gui_Main_on_message = function(data6,message_id2,message2,sender2) 
    script6:on_message(data6, message_id2, message2, sender2);
  end;
  local script7 = SmallPlanets.new();
  exports.SmallPlanets_update = function(_7,dt5) 
    script7:update(_7, dt5);
  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()
  BonusStar.score = 5000;
  BonusStar.speed = -240;
  Factory.frequency = 0.5;
  Factory.bonus_prob = 0.2;
  Factory.min_y = 60;
  Factory.max_y = 600;
  LargePlanets.speed = -60;
  Messages.AddScore = _G.hash("add_score");
  SmallPlanets.speed = -30;
  Spaceship.max_speed = 150;
  Spaceship.min_y = 60;
  Spaceship.max_y = 600;
  Star.score = 1000;
  Star.speed = -240;
  __defold_GoMessages.acquire_input_focus = _G.hash("acquire_input_focus");
  __defold_PhysicsMessages.collision_response = _G.hash("collision_response");
  __defold_RenderMessages.clear_color = _G.hash("clear_color");
  __defold_SysMessages.toggle_profile = _G.hash("toggle_profile");
  __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

_hx_bind = function(o,m)
  if m == nil then return nil end;
  local f;
  if o._hx__closures == nil then
    _G.rawset(o, '_hx__closures', {});
  else 
    f = o._hx__closures[m];
  end
  if (f == nil) then
    f = function(...) return m(o, ...) end;
    o._hx__closures[m] = f;
  end
  return f;
end
_hx_funcToField = function(f)
  if type(f) == 'function' then 
    return function(self,...) 
      return f(...) 
    end
  else 
    return f
  end
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();