Update love and fennel

conf.lua

@@ -2,6 +2,5 @@ love.conf = function(t)
     t.gammacorrect = true
     t.title, t.identity = "Gravity:Fall", "gravity-fall"
     t.modules.joystick, t.modules.physics = false, false
-    t.version = "0.10.2"
+    t.version = "11.2"
  end
-

level.fnl

@@ -13,7 +13,7 @@
 (var level-switcher nil)
 (var level-replay nil)
 
-(defn find-mouse-intersect-planet [planets]
+(lambda find-mouse-intersect-planet [planets]
   (let [x (love.mouse.getX)
         y (love.mouse.getY)]
     (lume.first
@@ -24,10 +24,10 @@
                                  (<= y1 y y2))
                         p)))))))
 
-(defn launch-level [level]
+(lambda launch-level [level]
   (set level.state :in-flight))
 
-(defn reset-level [level]
+(lambda reset-level [level]
   (set level.state :awaiting-launch)
   (set level.duration 0)
   (set level.ship (ship.create level.level-info.ship.vx
@@ -37,13 +37,13 @@
   (each [k p (ipairs level.planets)]
     (planet.reset p)))
 
-(defn trigger-game-over [level]
+(lambda trigger-game-over [level]
   ;; when game is over due to crash, first the game state goes to
   ;; :crash, we need to tell the ship that it needs to animate to crash
   (set level.state :crashed)
   (ship.trigger-crash level.ship))
 
-(defn finish-level [level]
+(lambda finish-level [level]
   (ship.fall-into-vortex level.ship
                          [level.level-info.vortex.x
                           level.level-info.vortex.y])
@@ -57,10 +57,10 @@
          (set level-switcher switcher)
          (set level-replay replay)
 
-         (set bg-music (love.audio.newSource "assets/alone.mp3"))
+         (set bg-music (love.audio.newSource "assets/alone.mp3" "static"))
          (: bg-music :setLooping true)
 
-         (set victory-music (love.audio.newSource "assets/victory.mp3"))
+         (set victory-music (love.audio.newSource "assets/victory.mp3" "static"))
          (: victory-music :setVolume 0.3))
 
  :create (fn [level-info]
@@ -113,7 +113,7 @@
                 (and (= key "r")
                      (= level.state :complete))
                 (level-replay)))
- 
+
  :update (fn [level tt]
            ;; play music if we are not paying
            (when (and (not (: bg-music :isPlaying))
@@ -135,7 +135,7 @@
                     (math.min
                      10000
                      (+ level.survival-score-offered (math.floor (* tt 1000)))))
-               
+
                (set level.duration (+ level.duration tt))
 
                ;; apply any forces due to gravity on the ship
@@ -201,14 +201,14 @@
              ;; if there's a resource collision add score
              (set level.resource-score
                   (+ level.resource-score (* 50000 resource-collides)))
-             
+
              (when (and (= level.state :in-flight)
                         full-collide?)
                (trigger-game-over level))))
 
  :reset (fn [level]
           (reset-level level))
- 
+
  :draw (fn [level]
          (each [k p (ipairs level.planets)]
            (planet.draw p))

level.lua

@@ -9,28 +9,31 @@ local bg_music = nil
 local victory_music = nil
 local level_switcher = nil
 local level_replay = nil
-local function _0_(planets)
-  local x = love.mouse.getX()
-  local y = love.mouse.getY()
-  local function _1_(p)
-    local _2_ = planet.bounds(p)
-    local x1 = _2_[1]
-    local y1 = _2_[2]
-    local x2 = _2_[3]
-    local y2 = _2_[4]
-    if ((x1) <= (x) and ((x) <= (x2)) and (y1) <= (y) and ((y) <= (y2))) then
-      return p
+local function find_mouse_intersect_planet(planets)
+  assert((nil ~= planets), ("Missing argument %s on %s:%s"):format("planets", "level.fnl", 16))
+  do
+    local x = love.mouse.getX()
+    local y = love.mouse.getY()
+    local function _0_(p)
+      local _1_ = planet.bounds(p)
+      local x1 = _1_[1]
+      local y1 = _1_[2]
+      local x2 = _1_[3]
+      local y2 = _1_[4]
+      if (((x1 <= x) and (x <= x2)) and ((y1 <= y) and (y <= y2))) then
+        return p
+      end
     end
+    return lume.first(lume.filter(planets, _0_))
   end
-  return lume.first(lume.filter(planets, _1_))
 end
-local find_mouse_intersect_planet = _0_
-local function _1_(level)
+local function launch_level(level)
+  assert((nil ~= level), ("Missing argument %s on %s:%s"):format("level", "level.fnl", 27))
   level.state = "in-flight"
   return nil
 end
-local launch_level = _1_
-local function _2_(level)
+local function reset_level(level)
+  assert((nil ~= level), ("Missing argument %s on %s:%s"):format("level", "level.fnl", 30))
   level.state = "awaiting-launch"
   level.duration = 0
   level.ship = ship.create(level["level-info"].ship.vx, level["level-info"].ship.vy)
@@ -41,111 +44,110 @@ local function _2_(level)
   end
   return nil
 end
-local reset_level = _2_
-local function _3_(level)
+local function trigger_game_over(level)
+  assert((nil ~= level), ("Missing argument %s on %s:%s"):format("level", "level.fnl", 40))
   level.state = "crashed"
   return ship["trigger-crash"](level.ship)
 end
-local trigger_game_over = _3_
-local function _4_(level)
-  ship["fall-into-vortex"](level.ship, ({level["level-info"].vortex.x, level["level-info"].vortex.y}))
+local function finish_level(level)
+  assert((nil ~= level), ("Missing argument %s on %s:%s"):format("level", "level.fnl", 46))
+  ship["fall-into-vortex"](level.ship, {level["level-info"].vortex.x, level["level-info"].vortex.y})
   level.state = "complete"
   return nil
 end
-local finish_level = _4_
-local function _5_(level_info)
-  local planets = ({})
+local function _0_(level_info)
+  local planets = {}
   for k, p in ipairs(level_info.planets) do
     table.insert(planets, planet.create(p.size, p.distance, p.resources, p.tile))
   end
   util.pp(planets)
-  return ({["level-info"] = level_info, ["resource-score"] = 0, ["speed-up"] = 1, ["survival-score-offered"] = 0, duration = 0, planets = planets, ship = ship.create(level_info.ship.vx, level_info.ship.vy), state = "awaiting-launch", vortex = vortex.create(level_info.vortex.x, level_info.vortex.y, level_info.vortex.radius)})
+  return {["level-info"] = level_info, ["resource-score"] = 0, ["speed-up"] = 1, ["survival-score-offered"] = 0, duration = 0, planets = planets, ship = ship.create(level_info.ship.vx, level_info.ship.vy), state = "awaiting-launch", vortex = vortex.create(level_info.vortex.x, level_info.vortex.y, level_info.vortex.radius)}
 end
-local function _6_(level)
+local function _1_(level)
   for k, p in ipairs(level.planets) do
     planet.draw(p)
   end
   ship.draw(level.ship)
   vortex.draw(level.vortex)
   return hud.draw(level)
 end
-local function _7_(level, key, unicode)
-  if (key) == ("s") then
+local function _2_(level, key, unicode)
+  if (key == "s") then
     local new_s = (level["speed-up"] + 1)
-    local function _8_()
-      if (new_s) > (4) then
+    local function _3_()
+      if (new_s > 4) then
         return 1
       else
         return new_s
       end
     end
-    level["speed-up"] = _8_()
+    level["speed-up"] = _3_()
     return nil
-  elseif ((key) == ("space") and (level.state) == ("awaiting-launch")) then
+  elseif ((key == "space") and (level.state == "awaiting-launch")) then
     return launch_level(level)
-  elseif ((key) == ("space") and (level.state) == ("in-flight")) then
+  elseif ((key == "space") and (level.state == "in-flight")) then
     return reset_level(level)
-  elseif ((key) == ("space") and (level.state) == ("in-flight")) then
+  elseif ((key == "space") and (level.state == "in-flight")) then
     return reset_level(level)
-  elseif ((key) == ("space") and (level.state) == ("crashed")) then
+  elseif ((key == "space") and (level.state == "crashed")) then
     return reset_level(level)
-  elseif ((key) == ("space") and (level.state) == ("complete")) then
+  elseif ((key == "space") and (level.state == "complete")) then
     return level_switcher()
-  elseif ((key) == ("r") and (level.state) == ("complete")) then
+  elseif ((key == "r") and (level.state == "complete")) then
     return level_replay()
   end
 end
-local function _8_(switcher, replay)
+local function _3_(switcher, replay)
   planet.load()
   ship.load()
   hud.load()
   level_switcher = switcher
   level_replay = replay
-  bg_music = love.audio.newSource("assets/alone.mp3")
+  bg_music = love.audio.newSource("assets/alone.mp3", "static")
   bg_music:setLooping(true)
-  victory_music = love.audio.newSource("assets/victory.mp3")
+  victory_music = love.audio.newSource("assets/victory.mp3", "static")
   return victory_music:setVolume(0.29999999999999999)
 end
-local function _9_(level)
+local function _4_(level)
   return reset_level(level)
 end
-local function _10_(level, tt)
-  local function _11_()
-    if (not bg_music:isPlaying() and (level.state) == ("awaiting-launch")) then
+local function _5_(level, tt)
+  local function _6_()
+    if (not bg_music:isPlaying() and (level.state == "awaiting-launch")) then
       victory_music:stop()
       return bg_music:play()
     end
   end
-  _11_()
-  local function _12_()
-    if (bg_music:isPlaying() and (level.state) == ("complete")) then
+  _6_()
+  local function _7_()
+    if (bg_music:isPlaying() and (level.state == "complete")) then
       victory_music:play()
       return bg_music:stop()
     end
   end
-  _12_()
+  _7_()
   do
     local t = (tt * level["speed-up"])
-    local function _13_()
-      if (level.state) == ("in-flight") then
+    local function _8_()
+      if (level.state == "in-flight") then
         level["survival-score-offered"] = math.min(10000, (level["survival-score-offered"] + math.floor((tt * 1000))))
         level.duration = (level.duration + tt)
         ship["apply-planetary-forces"](level.ship, level.planets)
         return ship["update-forces"](level.ship, t)
       end
     end
-    _13_()
-    local function _14_()
-      if (level.state) == ("awaiting-launch") then
-        local function _14_()
+    _8_()
+    local function _9_()
+      if (level.state == "awaiting-launch") then
+        local function _9_()
           if love.mouse.isDown(1) then
             if not tracking_info then
               local p = find_mouse_intersect_planet(level.planets)
               if p then
                 print("found planet:", p)
                 love.mouse.setGrabbed(true)
                 planet["mark-highlight"](p)
-                tracking_info = ({planet = p, x = love.mouse.getX(), y = love.mouse.getY()})
+                tracking_info = {planet = p, x = love.mouse.getX(), y = love.mouse.getY()}
                 return nil
               end
             end
@@ -158,7 +160,7 @@ local function _10_(level, tt)
             end
           end
         end
-        _14_()
+        _9_()
         if tracking_info then
           local mx = love.mouse.getX()
           local my = love.mouse.getY()
@@ -171,7 +173,7 @@ local function _10_(level, tt)
         end
       end
     end
-    _14_()
+    _9_()
     for k, p in ipairs(level.planets) do
       planet.update(p, t)
     end
@@ -181,31 +183,31 @@ local function _10_(level, tt)
   do
     local vortex_bounds = vortex["center-and-radius"](level.vortex)
     local ship_bounds = ship["center-and-radius"](level.ship)
-    local function _13_()
-      if (util["sphere-collision"](vortex_bounds, ship_bounds) and (level.state) == ("in-flight")) then
+    local function _8_()
+      if (util["sphere-collision"](vortex_bounds, ship_bounds) and (level.state == "in-flight")) then
         return finish_level(level)
       end
     end
-    _13_()
+    _8_()
   end
   do
     local ship_center_and_radius = ship["center-and-radius"](level.ship)
-    local function _13_(p)
+    local function _8_(p)
       return planet.collide(p, ship_center_and_radius)
     end
-    local coll_status = lume.map(level.planets, _13_)
-    local function _14_(s)
-      return (s) == ("full-collide")
+    local coll_status = lume.map(level.planets, _8_)
+    local function _9_(s)
+      return (s == "full-collide")
     end
-    local full_collide_3f = lume.first(lume.filter(coll_status, _14_))
-    local function _15_(s)
-      return (s) == ("resource-collide")
+    local full_collide_3f = lume.first(lume.filter(coll_status, _9_))
+    local function _10_(s)
+      return (s == "resource-collide")
     end
-    local resource_collides = #lume.filter(coll_status, _15_)
+    local resource_collides = #lume.filter(coll_status, _10_)
     level["resource-score"] = (level["resource-score"] + (50000 * resource_collides))
-    if ((level.state) == ("in-flight") and full_collide_3f) then
+    if ((level.state == "in-flight") and full_collide_3f) then
       return trigger_game_over(level)
     end
   end
 end
-return ({create = _5_, draw = _6_, keypressed = _7_, load = _8_, reset = _9_, update = _10_})
+return {create = _0_, draw = _1_, keypressed = _2_, load = _3_, reset = _4_, update = _5_}