Fixing fullscreen bug

analytics.lua

@@ -1,6 +1,10 @@
-local analytics_version = 2
+local analytics = {}
 
-analytics = {
+local analytics_version = 3
+
+local analytic_data_cap = 999999 -- prevents overflow
+
+local analytics_data = {
              -- The lastly used version
              version                       = analytics_version,
 
@@ -10,6 +14,10 @@ analytics = {
                   destroyed_panels = 0,
                   -- the amount of sent garbage
                   sent_garbage_lines = 0,
+                  -- the amount of times the cursor was moved
+                  move_count = 0,
+                  -- the amount of times the panels were swapped
+                  swap_count = 0,
                   -- 1 to 12, then 13+, 1 is obviously meaningless
                   reached_chains = { },
                   -- 1 to 40, 1 to 3 being meaningless
@@ -22,6 +30,10 @@ analytics = {
                   destroyed_panels = 0,
                   -- the amount of sent garbage
                   sent_garbage_lines = 0,
+                  -- the amount of times the cursor was moved
+                  move_count = 0,
+                  -- the amount of times the panels were swapped
+                  swap_count = 0,
                   -- 1 to 12, then 13+, 1 is obviously meaningless
                   reached_chains = { },
                   -- 1 to 40, 1 to 3 being meaningless
@@ -32,6 +44,8 @@ analytics = {
 local function analytic_clear(analytic)
   analytic.destroyed_panels = 0
   analytic.sent_garbage_lines = 0
+  analytic.move_count = 0
+  analytic.swap_count = 0
   analytic.reached_chains = {}
   analytic.used_combos = {}
 end
@@ -69,27 +83,49 @@ local function refresh_sent_garbage_lines(analytic)
   analytic.sent_garbage_lines = sent_garbage_lines_count
 end
 
-function analytics_init() pcall(function()
+function analytics.init() pcall(function()
   if not config.enable_analytics then
     return
   end
 
-  local file = love.filesystem.newFile("analytics.json")
-  file:open("r")
+  local read_data = {}
+  local analytics_file, err = love.filesystem.newFile("analytics.json", "r")
+  if analytics_file then
+    local teh_json = analytics_file:read(analytics_file:getSize())
+    for k,v in pairs(json.decode(teh_json)) do
+      read_data[k] = v
+    end
+  end
 
-  local teh_json = file:read(file:getSize())
-  for k,v in pairs(json.decode(teh_json)) do
-    analytics[k] = v
+  if read_data.version and type(read_data.version) == "number" then
+    analytics_data.version = read_data.version
+  end
+  local analytics_filters = { "last_game", "overall" }
+  local number_params = { "destroyed_panels", "sent_garbage_lines", "move_count", "swap_count" }
+  local table_params = { "reached_chains", "used_combos" }
+  for _,analytic in pairs(analytics_filters) do
+    if read_data[analytic] and type(read_data[analytic]) == "table" then
+      for n,param in pairs(number_params) do
+        if read_data[analytic][param] and type(read_data[analytic][param]) == "number" then
+          analytics_data[analytic][param] = math.min(read_data[analytic][param],analytic_data_cap)
+        end
+      end
+      for m,param in pairs(table_params) do
+        if read_data[analytic][param] and type(read_data[analytic][param]) == "table" then
+          analytics_data[analytic][param] = read_data[analytic][param]
+        end
+      end
+    end
   end
 
-  analytic_clear(analytics.last_game)
+  analytic_clear(analytics_data.last_game)
 
   -- do stuff regarding version compatibility here, before we patch it
-  if analytics.version < 2 then
-    refresh_sent_garbage_lines(analytics.overall)
+  if analytics_data.version < 2 then
+    refresh_sent_garbage_lines(analytics_data.overall)
   end
 
-  analytics.version = analytics_version
+  analytics_data.version = analytics_version
   file:close()
 end) end
 
@@ -98,13 +134,15 @@ local function output_pretty_analytics() pcall(function()
     return
   end
 
-  local analytics_filters = { analytics.last_game, analytics.overall } 
+  local analytics_filters = { analytics_data.last_game, analytics_data.overall } 
   local titles = { "Last game\n-------------------------------------\n", "Overall\n-------------------------------------\n" }
   local text = ""
   for i,analytic in pairs(analytics_filters) do
     text = text..titles[i]
     text = text.."Destroyed "..analytic.destroyed_panels.." panels.\n"
     text = text.."Sent "..analytic.sent_garbage_lines.." lines of garbage.\n"
+    text = text.."Moved "..analytic.move_count.." times.\n"
+    text = text.."Swapped "..analytic.swap_count.." times.\n"
     text = text.."Performed combos:\n"
     for k,v in pairs(analytic.used_combos) do
       if k then
@@ -127,91 +165,121 @@ local function output_pretty_analytics() pcall(function()
 end) end
 
 
-function analytics_draw(x,y)  
+function analytics.draw(x,y)  
   if not config.enable_analytics then
     return
   end
 
-  gprint("Panels destroyed: "..analytics.last_game.destroyed_panels, x, y)
+  gprint("Panels destroyed: "..analytics_data.last_game.destroyed_panels, x, y)
+  y = y+15
+
+  gprint("Sent garbage lines: "..analytics_data.last_game.sent_garbage_lines, x, y)
+  y = y+15
+
+  gprint("Moved "..analytics_data.last_game.move_count.." times", x, y)
   y = y+15
 
-  gprint("Sent garbage lines: "..analytics.last_game.sent_garbage_lines, x, y)
+  gprint("Swapped "..analytics_data.last_game.swap_count.." times", x, y)
   y = y+15
 
   local ycombo = y
   for i=2,13 do
-    local chain_amount = analytics.last_game.reached_chains[i] or 0
+    local chain_amount = analytics_data.last_game.reached_chains[i] or 0
     gprint("x"..i..": "..chain_amount, x, y)
     y = y+15
   end
 
-  local chain_above_13 = compute_above_13(analytics.last_game)
+  local chain_above_13 = compute_above_13(analytics_data.last_game)
   gprint("x?: "..chain_above_13, x, y)
 
   local xcombo = x + 50
   for i=4,15 do
-    local combo_amount = analytics.last_game.used_combos[i] or 0
+    local combo_amount = analytics_data.last_game.used_combos[i] or 0
     gprint("c"..i..": "..combo_amount, xcombo, ycombo)
     ycombo = ycombo+15
   end
 end
 
-function write_analytics_files() pcall(function()
+local function write_analytics_files() pcall(function()
   if not config.enable_analytics then
     return
   end
 
   local file = love.filesystem.newFile("analytics.json")
   file:open("w")
-  file:write(json.encode(analytics))
+  file:write(json.encode(analytics_data))
   file:close()
 
   output_pretty_analytics()
 end) end
 
-function analytics_register_destroyed_panels(amount)
+function analytics.register_destroyed_panels(amount)
   if not config.enable_analytics then
     return
   end
 
-  local analytics_filters = { analytics.last_game, analytics.overall }
+  local analytics_filters = { analytics_data.last_game, analytics_data.overall }
   for _,analytic in pairs(analytics_filters) do
     analytic.destroyed_panels = analytic.destroyed_panels + amount
     if amount > 3 then
       if not analytic.used_combos[amount] then
         analytic.used_combos[amount] = 1
       else
-        analytic.used_combos[amount] = analytic.used_combos[amount] + 1
+        analytic.used_combos[amount] = math.min(analytic.used_combos[amount]+1,analytic_data_cap)
       end
       analytic.sent_garbage_lines = analytic.sent_garbage_lines + amount_of_garbages_lines_per_combo[amount]
     end
   end
 end
 
-function analytics_register_chain(size)
+function analytics.register_chain(size)
   if not config.enable_analytics then
     return
   end
 
   local max_size = math.min(size, 13)
 
-  local analytics_filters = { analytics.last_game, analytics.overall }
+  local analytics_filters = { analytics_data.last_game, analytics_data.overall }
   for _,analytic in pairs(analytics_filters) do
     if not analytic.reached_chains[size] then
       analytic.reached_chains[size] = 1
     else
-      analytic.reached_chains[size] = analytic.reached_chains[size]+1
+      analytic.reached_chains[size] = math.min(analytic.reached_chains[size]+1,analytic_data_cap)
     end
     size = math.min(size, 13)
     analytic.sent_garbage_lines = analytic.sent_garbage_lines + (max_size-1)
   end
 end
 
-function analytics_game_ends()
+function analytics.register_swap()
+  if not config.enable_analytics then
+    return
+  end
+
+  local analytics_filters = { analytics_data.last_game, analytics_data.overall }
+  for _,analytic in pairs(analytics_filters) do
+    analytic.swap_count = math.min(analytic.swap_count + 1,analytic_data_cap)
+  end
+end
+
+function analytics.register_move()
+  if not config.enable_analytics then
+    return
+  end
+
+  local analytics_filters = { analytics_data.last_game, analytics_data.overall }
+  for _,analytic in pairs(analytics_filters) do
+    analytic.move_count = math.min(analytic.move_count + 1,analytic_data_cap)
+  end
+end
+
+function analytics.game_ends()
   if not config.enable_analytics then
     return
   end
 
   write_analytics_files()
-  analytic_clear(analytics.last_game)
-end
+  analytic_clear(analytics_data.last_game)
+end
+
+return analytics

auto_updater/README.txt

@@ -0,0 +1,9 @@
+Here is the process to publish the auto_updater: 
+- configure UPDATER_NAME in main.lua
+- configure updater_config.lua with the server_url
+- copy the last version of the game here in this folder "any-name.love"
+- make the exe auto_updater, publish with a name like "panel.zip" or "panel-beta.zip", ...
+
+Here is the process to release a version of the game:
+- make a love file
+- upload it to the server with a name like "panel-beta-DATE_HOUR.love"

auto_updater/_config.lua

@@ -0,0 +1,7 @@
+updater_config = {
+    auto_update= true,
+    launch_check_interval= 6 * 3600, -- in seconds (default 6h) will check for updates at launch if interval has passed (it will always check for updates ingame in background)
+    launch_check_timeout= 0.4, -- in seconds (default 400ms) time before aborting the check for updates request at launch, it will always take all the time needed ingame in background
+    server_url= "http://panelattack.com/updates",
+    force_version= "", -- ex: "panel-2019-11-17.love"
+}

auto_updater/class.lua

@@ -0,0 +1,12 @@
+function class(init)
+  local c,mt = {},{}
+  c.__index = c
+  mt.__call = function(class_tbl, ...)
+    local obj = {}
+    setmetatable(obj,c)
+    init(obj,...)
+    return obj
+  end
+  setmetatable(c, mt)
+  return c
+end