/ld27

STRICT = false

DEBUG = false

if SDL then

  print = SDL.log

end

--lovebird = require 'lovebird'

require 'zoetrope'

--require 'pepperprof'

--inspect = require 'inspect'

require 'sprite'

require 'util'

require 'version'

require 'player'

require 'goal'

require 'pause_view'

require 'win_view'

GameView = View:extend {

   gameStart = 0,

   switchSounds = {},

   onNew = function (self)

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

              self.focus = the.player

              self:clampTo(self.bg)

              the.app:setScaling(self)

              self.mazes = {self.maze1, self.maze2, self.maze3}

              self.bgs = {self.bg, self.bg, self.bg2}

              for _, maze in ipairs(self.mazes) do maze:die() end

              for _, bg in ipairs(self.bgs) do bg.visible = false end

              self.maze1.moveMod = 1

              self.maze2.moveMod = 0.55

              self.maze3.moveMod = -1

              self.maze1.playerScale = 1

              self.maze2.playerScale = 0.5

              self.maze3.playerScale = 1

              self.goals = {{},{},{}}

              the.goalsAchieved = 0

              for _, obj in ipairs(self.objects.sprites) do

                 if obj:instanceOf(Goal) then

                    obj.visible = false

                    table.insert(self.goals[tonumber(obj.map)], obj)

                 end

              end

              local sndFiles = {'data/Explosion2.wav', 'data/Explosion3.wav', 'data/Hit_Hurt3.wav'}

              for _, sndFile in ipairs(sndFiles) do

                 local snd = love.audio.newSource(sndFile, 'static')

                 table.insert(self.switchSounds, snd)

              end

              --the.interface = Group:new()

              --self:add(the.interface)

              self:switchMaze()

              -- profiling...

              --the.profiler = newProfiler()

              --the.profiler:start()

              self.gameStart = love.timer.getTime()

              self.lastChange = love.timer.getTime()

           end,

   onUpdate = function(self, dt)

                 if the.player.active and love.timer.getTime() > self.lastChange + 10 then

                    -- switch maze

                    self:switchMaze()

                 end

                 if not (DEBUG and the.console.visible) then

                    for _, goal in ipairs(the.activeGoals) do

                       the.player.collider:collide(goal)

                    end

                 end

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

                    PauseView:new():activate()

                 --elseif the.keys:justPressed('w') then

                 --   WinView:new():activate()

                 end

              end,

   switchMaze = function(self)

                   if the.activeMaze then

                      repeat

                         newMaze = math.random(3)

                      until self.mazes[newMaze] ~= the.activeMaze

                      the.activeMaze:die()

                      the.activeMaze = self.mazes[newMaze]

                      the.activeBg.visible = false

                      the.activeBg = self.bgs[newMaze]

                      for _, goal in ipairs(the.activeGoals) do

                         goal.visible = false

                      end

                      the.activeGoals = self.goals[newMaze]

                      love.audio.play(self.switchSounds[math.random(#self.switchSounds)])

                   else

                      the.activeMaze = self.maze2

                      the.activeBg = self.bg

                      the.activeGoals = self.goals[2]

                   end

                   the.activeMaze:revive()

                   the.activeBg.visible = true

                   for _, goal in ipairs(the.activeGoals) do

                      goal.visible = true

                   end

                   the.player.scale = the.activeMaze.playerScale

                   the.player.collider.width = the.player.width * the.activeMaze.playerScale

                   the.player.collider.height = the.player.height * the.activeMaze.playerScale

                   self._fx = {0,0,0,0}

                   self.tween:start(self._fx, 4, 175, 10, 'quadIn')

                   self.lastChange = love.timer.getTime()

                end,

   onEndFrame = function(self)

                   --the.interface.translate.x = the.player.x - the.app.width / 2 + the.player.width / 2

                   --the.interface.translate.y = the.player.y - the.app.height / 2 + the.player.height / 2

                end

}

MenuScreen = View:extend {

   bg = Tile:new{image = 'data/intro.png', x = 0, y = 0},

   onNew = function(self)

              the.app:setScaling(self)

              self:add(self.bg)

              --self.title:centerAround(400, 200)

              local nr = 'data/NewRocker-Regular.otf'

              self:add(Text:new{

                          text = 'Treasures of the Decimaze',

                          --x = 0,

                          y = 100,

                          width = self.bg.width,

                          font = {nr, 48},

                          align = 'center',

                          tint = {0,0,0}

                       })

              self:add(Text:new{

                          text = 'Find the 4 lost shinies!',

                          y = 170,

                          width = self.bg.width,

                          font = {nr, 28},

                          align = 'center',

                          tint = {0,0,0}

                       })

              self:add(Text:new{

                          text = 'Use the arrow keys to move',

                          y = 375,

                          width = self.bg.width,

                          font = {nr, 24},

                          align = 'center',

                          tint = {0,0,0}

                       })

              self:add(Text:new{

                          text = 'Press a key to start',

                          y = 425,

                          width = self.bg.width,

                          font = {nr, 24},

                          align = 'center',

                          tint = {0,0,0}

                       })

           end,

   onUpdate = function(self, elapsed)

     if the.keys:allJustPressed() or the.mouse:pressed() then

       the.app.view = GameView:new()

     end

   end

}

the.app = App:new {

   width = 800,

   height = 600,

   name = "Treasures of the Decimaze",

   onRun = function (self)

              print('Version: ' .. VERSION)

              self.view = MenuScreen:new()

              self:setScaling()

              if DEBUG then

                 self.console:watch('VERSION', 'VERSION')

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

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

                 -- back off that dark overlay a bit

                 self.console.fill.fill[4] = 75

              end

           end,

   onUpdate = function (self, dt)

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

                    local ss = love.graphics.newScreenshot()

                    ss:encode('screenshot-' ..love.timer.getTime()..'.png')

                 end

              end,

   update = function(self, dt)

     if lovebird then

       fps = love.timer.getFPS()

       lovebird.update()

     end

     App.update(self, dt)

   end,

   setScaling = function(self, view)

     local view = view or the.app.view

     local winw, winh = love.window.getMode()

     --if love.window.getFullscreen() then

     if winw == self.width and winh == self.height then

       self.scale = 1

       view.realTranslate = { x=0, y=0 }

       love.graphics.setScissor()

     else

       --self.scale = math.min(

       --  math.floor(winw / the.app.viewWidth),

       --  math.floor(winh / the.app.viewHeight)

       --)

       if winh >= 1050 then

         self.scale = 1.5

       elseif winh < the.app.height then

         self.scale = winh / the.app.height

       end

       view.realTranslate.x = math.floor((winw - self.width * self.scale) / 2)

       view.realTranslate.y = math.floor((winh - self.height * self.scale) / 2)

       --print('translate: ' .. view.realTranslate.x .. ', ' .. view.realTranslate.y)

       love.graphics.setColor(0,0,0)

       love.graphics.rectangle('fill', 0, 0, winw, winh)

       love.graphics.setScissor( view.realTranslate.x,

                                 view.realTranslate.y,

                                 self.width * self.scale,

                                 self.height * self.scale)

     end

     view.scale = self.scale

   end

}

function love.resize(w, h)

  print('love.resize')

  the.app:setScaling()

end