/zoeplat

STRICT = true

DEBUG = true

RECORD = true

PLAYBACK = false

require 'zoetrope'

__ = require 'underscore'

--inspect = require 'inspect'

require 'pepperprof'

util = {

   dim = function(dir)

      if dir == 'x' then

         return 'width'

      elseif dir == 'y' then

         return 'height'

      else

         if STRICT then error('dir '..dir) end

      end

   end

}

Player = Animation:extend {

   image = 'data/player.png',

   height = 32,

   width = 32,

   sequences = {

      stand = { frames = { 1 }, fps = 1 },

      walk = { frames = { 2, 3 }, fps = 5 },

      jump = { frames = { 4 }, fps = 1 },

      climbLeft = { frames = { 5, 6 }, fps = 5 },

      climbRight = { frames = { 7, 8 }, fps = 5 }

   },

   collisions = {},

   onWall = false,

   leftWallAt = 0,

   onNew = function (self)

              self.velocity.y = 0

              self.maxVelocity.y = 400

           end,

   doPhysics = function (self, dir, elapsed)

                  local vel = self.velocity

                  local acc = self.acceleration

                  local drag = self.drag

                  local minVel = self.minVelocity

                  local maxVel = self.maxVelocity

                  -- check existence of properties

                  if STRICT then

                     assert(vel, 'active sprite has no velocity property')

                     assert(acc, 'active sprite has no acceleration property')

                     assert(drag, 'active sprite has no drag property')

                     assert(minVel, 'active sprite has no minVelocity property')

                     assert(maxVel, 'active sprite has no maxVelocity property')

                     assert(__.include({'x','y','rotation'}, dir), 'direction should be x, y, or rotation')

                  end

                  vel.x = vel.x or 0

                  vel.y = vel.y or 0

                  vel.rotation = vel.rotation or 0

                  -- physics

                  if acc[dir] and acc[dir] ~= 0 then

                     vel[dir] = vel[dir] + acc[dir] * elapsed

                  else

                     if drag[dir] then

                        if vel[dir] > 0 then

                           vel[dir] = vel[dir] - drag[dir] * elapsed

                           if vel[dir] < 0 then vel[dir] = 0 end

                        elseif vel[dir] < 0 then

                           vel[dir] = vel[dir] + drag[dir] * elapsed

                           if vel[dir] > 0 then vel[dir] = 0 end

                        end

                     end

                  end

                  if minVel[dir] and vel[dir] < minVel[dir] then vel[dir] = minVel[dir] end

                  if maxVel[dir] and vel[dir] > maxVel[dir] then vel[dir] = maxVel[dir] end

                  -- ugly hack for falling through floor on really slow frames

                  if math.abs(vel[dir] * elapsed) > 32 then

                     print('skip')

                     return

                  end

                  if vel[dir] ~= 0 then self[dir] = self[dir] + vel[dir] * elapsed end

                  if self[dir] < 0 then self[dir] = 0 end

                  local edge = the.view.map[util.dim(dir)] -

                               the.player[util.dim(dir)]

                  -- TODO: take map position into account

                  if self[dir] > edge then self[dir] = edge end

               end,

   onStartFrame = function (self)

                     -- this is all in startframe so it happens before

                     -- physics calc at beginning of update

                     -- jumping/falling updates could go in EndFrame...

                     self.falling = self.velocity.y > 0

                     if self.falling then self.jumping = false end

                     --print(self.jumping, self.falling)

                     if (not self.onGround) and (not self.onWall) then

                        self:play('jump')

                     end

                     self.acceleration.y = 800

                     if self.onWall then

                        self.acceleration.y = 0

                        if self.onWall == 'right' then

                           self:play('climbRight')

                        elseif self.onWall == 'left' then

                           self:play('climbLeft')

                        end

                        if the.keys:pressed('up') then

                           self.velocity.y = -200

                        elseif the.keys:pressed('down') then

                           self.velocity.y = 200

                        else

                           self.velocity.y = 0

                           self:freeze(self.sequences[self.currentName].frames[1])

                        end

                     end

                     if the.keys:pressed('left') then

                        self.velocity.x = -200

                        if self.onGround then self:play('walk') end

                        if self.onWall == 'right' then

                           self.onWall = false

                           self.leftWallAt = love.timer.getTime()

                        end

                     elseif the.keys:pressed('right') then

                        self.velocity.x = 200

                        if self.onGround then self:play('walk') end

                        if self.onWall == 'left' then

                           self.onWall = false

                           self.leftWallAt = love.timer.getTime()

                        end

                     else

                        if not self.onWall then

                           if self.onGround then self:play('stand') end

                           self.velocity.x = 0

                        end

                     end

                     if the.keys:justPressed('up') and

                      (self.onGround or the.console.visible or

                       (love.timer.getTime() - self.leftWallAt < .1) ) then

                        self.velocity.y = -400

                        self.jumping = true

                     end

                  end,

   update = function (self, elapsed)

               -- NOTE: this is an override, not a callback

               self:doPhysics('x', elapsed)

               self:collide(the.view.map)

               -- handle X collisions

               self.onWall = false

               for _, col in ipairs(self.collisions) do

                  col.other:displaceDir(self, 'x')

                  if self.velocity.x > 0 then

                     self.onWall = 'right'

                  elseif self.velocity.x < 0 then

                     self.onWall = 'left'

                  else

                     print 'x ??'

                  end

               end

               self.onGround = false -- right before Y collision callbacks

               self:doPhysics('y', elapsed)

               self:collide(the.view.map)

               -- handle Y collisions

               for _, col in ipairs(self.collisions) do

                  if self.velocity.y > 0 then

                     self.onGround = true

                  end

                  col.other:displaceDir(self, 'y')

                  self.velocity.y = 0

                  self.jumping = false

               end

               -- text blob

               if not self.text then

                  self.text = Text:new{wordWrap = true, width = 50, tint = {0,0,0}}

                  self.textfill = Fill:new{width = 54, border = {0,0,255}}

                  --the.view:add(self.textfill)

                  --the.view:add(self.text)

               end

               self.text.text = "Blah blah big text etc etc wrapping"

               self.text:centerAround(self.x+16, self.y+16, 'horizontal')

               _, texth = self.text:getSize()

               self.text.y = self.y - texth - 4

               self.textfill.x = self.text.x - 2

               self.textfill.y = self.text.y - 2

               self.textfill.height = texth + 4

               Animation.update(self, elapsed)

            end,

   collide = function (self, ...)

                self.collisions = {}

                Animation.collide(self, ...)

                -- I could return a true/false value here if I wanted to...

             end,

   onCollide = function (self, other, xOverlap, yOverlap)

                  if other == the.view.map then return end

                  table.insert(self.collisions, {other = other,

                                                 xOverlap = xOverlap,

                                                 yOverlap = yOverlap })

               end

}

-- displace on a specific axis (monkey patch Sprite)

function Sprite:displaceDir(other, dir)

   if not self.solid or self == other or not other.solid then return end

   if STRICT then assert(other:instanceOf(Sprite), 'asked to displace a non-sprite') end

   if other.sprites then

      -- handle groups

      for _, spr in pairs(other.sprites) do

         self:displace(spr, dir)

      end

   else

      -- handle sprites

      local dim = util.dim(dir)

      local negMove = (other[dir] - self[dir]) + other[dim]

      local posMove = (self[dir] + self[dim]) - other[dir]

      -- TODO: re-add hinting?

      if negMove < posMove then

         chg = - negMove

      else

         chg = posMove

      end

   end

   other[dir] = other[dir] + chg

end

-- don't use zoetrope physics

function Sprite:update (elapsed)

   if self.onUpdate then self:onUpdate(elapsed) end

end

GameView = View:extend {

   onNew = function (self)

              self:loadLayers('data/map.lua')

              self.focus = the.player

              self:clampTo(self.map)

              the.recorder = Recorder:new{mousePosInterval = 9999}

              the.app.meta:add(the.recorder)

              if RECORD then

                 the.recorder:startRecording()

              elseif PLAYBACK then

                 local storage = Storage:new{filename = 'record.lua'}

                 storage:load()

                 --print(inspect(storage.data))

                 the.recorder.record = storage.data

                 the.recorder:startPlaying()

              end

           end,

   onUpdate = function (self)

                 --print('drawTook: ', the.drawTook)

                 --print('tick')

                 --the.player:collide(self.map)

                 --self.map:collide(the.player)

              end,

   -- draw = function (self, x, y)

   --           View.draw(self, x, y)

   --           love.graphics.print('FPS:' .. love.timer.getFPS(), 20, 20)

   --        end

}

the.app = App:new {

   onRun = function (self)

              self.view = GameView:new()

              self.console:watch('onGround', 'the.player.onGround')

              self.console:watch('onWall', 'the.player.onWall')

              self.console:watch('updateTook', 'the.updateTook')

              self.console:watch('drawTook', 'the.drawTook')

              self.console:watch('recorder state', 'the.recorder.state')

              --the.profiler = newProfiler('time', 2000)

              --the.profiler = newProfiler()

              --the.profiler:start()

           end,

   onUpdate = function (self, dt)

                 if the.keys:justPressed('escape') then

                    if the.profiler then

                       the.profiler:stop()

                       local outfile = io.open( "profile.txt", "w+" )

                       the.profiler:report( outfile )

                       outfile:close()

                    end

                    if RECORD then

                       if not love.filesystem.remove('record.lua') then

                          error('could not remove record.lua')

                       end

                       local storage = Storage:new{

                          data = the.recorder.record,

                          filename = 'record.lua'

                       }

                       storage:save(false)

                       --print(inspect(the.recorder.record))

                    end

                    self.quit()

                 end

              end,

   update = function (self, dt)

               the.updateStart = love.timer.getMicroTime()

               App.update(self, dt)

               if the.updateStart then

                  the.updateTook = love.timer.getMicroTime() - the.updateStart

               end

            end

}