/traderous

STRICT = true

DEBUG = true

require 'zoetrope'

vector = require 'vector'

--inspect = require 'inspect'

require 'group'

require 'version'

require 'wrap_tile'

require 'mirror'

require 'player'

require 'enemy'

require 'cursor'

require 'bullet'

require 'rock'

require 'boom'

util = {

   signOf = function(value)

               if value >= 0 then

                  return 1

               else

                  return -1

               end

            end,

   shortestVector = function(from, to)

                       if STRICT then

                          if from.x < the.app.width / 2 or

                             from.x > the.bg.width - the.app.width / 2 or

                             from.y < the.app.height / 2 or

                             from.y > the.bg.height - the.app.height / 2 then

                             error('"from" coordinate out of bounds: X='..from.x..' Y='..from.y)

                          end

                          if to.x < the.app.width / 2 or

                             to.x > the.bg.width - the.app.width / 2 or

                             to.y < the.app.height / 2 or

                             to.y > the.bg.height - the.app.height / 2 then

                             error('"to" coordinate out of bounds: X='..to.x..' Y='..to.y)

                          end

                       end

                       -- normalize grid to account for mirror zones

                       local fx = from.x - the.app.width / 2

                       local fy = from.y - the.app.height / 2

                       local tx = to.x - the.app.width / 2

                       local ty = to.y - the.app.height / 2

                       local short = {}

                       -- pick shorter x

                       if math.abs(tx - fx) < math.abs(tx - fx - (the.bg.width - the.app.width)) then

                          -- straight path is shorter

                          short.x = tx - fx

                       else

                          short.x = tx - fx - (the.bg.width - the.app.width)

                       end

                       -- pick shorter y

                       if math.abs(ty - fy) < math.abs(ty - fy - (the.bg.height - the.app.height)) then

                          -- straight path is shorter

                          short.y = ty - fy

                       else

                          short.y = ty - fy - (the.bg.height - the.app.height)

                       end

                       return vector.new(short.x, short.y)

                    end

}

GameView = View:extend {

   lastRock = 0,

   rockInterval = 1,

   gameStart = 0,

   onNew = function (self)

              -- for x = 1,30 do

              --    for y = 1,30 do

              --       self:add(Fill:new{x=x*400, y=y*400,

              --                         width = 32, height = 32,

              --                         fill = {0,0,255}

              --                      })

              --    end

              -- end

              the.storage = Storage:new{filename = 'scores.lua'}

              the.storage:load()

              if not the.storage.data.highScore then

                 print('initializing storage')

                 the.storage.data = {highScore = 0}

              end

              the.rockColliders = Group:new()

              the.bullets = Group:new()

              the.mirrors = Group:new()

              the.rocks = Group:new()

              the.bg = Tile:new{

                 image = 'data/stars3.png',

                 -- 1366x768 * 3

                 width = 4098,

                 height = 2304

              }

              self:add(the.bg)

              --the.player = CrystalPlayer:new{x=400,y=300}

              the.player = SpacePlayer:new{x=1366,y=768}

              self:add(the.player)

              --self:add(Enemy:new{x=400, y=300})

              self:add(the.bullets)

              self:add(the.rockColliders)

              self:add(the.mirrors)

              self:add(the.rocks)

              the.cursor = Cursor:new()

              self:add(the.cursor)

              the.score = Text:new{

                 width = the.app.width,

                 align = 'center',

                 font = 25}

              self:add(the.score)

              local hs = the.storage.data.highScore

              local m = hs / 60

              local s = hs % 60

              the.highScore = Text:new{

                 width = the.app.width,

                 align = 'right',

                 font = 25,

                 text = string.format('High Score: %d:%02d', m, s)

              }

              self:add(the.highScore)

              love.mouse.setGrab(true)

              love.mouse.setVisible(false)

              love.mouse.setPosition(the.app.width / 2, the.app.height / 2)

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

              self.focus = the.player

              --self:clampTo(self.map)

              self.gameStart = love.timer.getTime()

           end,

   onUpdate = function(self, dt)

                 if the.player.active and love.timer.getTime() > self.lastRock + self.rockInterval then

                    local unseenRock = nil

                    while not unseenRock do

                       local rock = Rock:new{

                          x = math.random(the.app.width / 2,

                                          the.bg.width - the.app.width / 2),

                          y = math.random(the.app.height / 2,

                                          the.bg.height - the.app.height / 2),

                          velocity = {

                             x = math.random(-300, 300),

                             y = math.random(-300, 300),

                             rotation = math.random(-7, 7)

                          },

                          scale = math.random() + 0.5

                       }

                       local rockToPlayer = util.shortestVector(rock, the.player)

                       if math.abs(rockToPlayer.x) > the.app.width / 2 + rock.width * rock.scale and

                           math.abs(rockToPlayer.y) > the.app.height / 2 + rock.height * rock.scale then

                         unseenRock = rock

                        end

                    end

                    the.rocks:add(unseenRock)

                    self.lastRock = love.timer.getTime()

                 end

                 the.bullets:collide(the.rockColliders)

                 -- for _, mirror in ipairs(the.mirrors.sprites) do

                 --    if not mirror.of then

                 --       print('mirror:' .. inspect(mirror))

                 --       error('mirror OF NOTHING')

                 --    end

                 -- end

              end,

   onEndFrame = function(self)

                   if the.player.active then

                      self:updateScore()

                   end

                end,

   draw = function (self, x, y)

             View.draw(self, x, y)

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

          end,

   updateScore = function(self)

                    local t = love.timer.getTime() - self.gameStart

                    local m = t / 60

                    local s = t % 60

                    the.score.text = string.format('Score: %d:%02d', m, s)

                    the.score.y = the.player.y - the.app.height / 2 + the.player.height

                    the.score.x = the.player.x - the.app.width / 2

                    the.highScore.y = the.player.y - the.app.height / 2 + the.player.height

                    the.highScore.x = the.player.x - the.app.width / 2

                 end

}

MenuScreen = View:extend {

   title = Text:new{text = "Press a key to start", font = 48, wordWrap = false},

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

   onNew = function(self)

              self:add(self.title)

              self.title:centerAround(400, 200)

           end,

   onUpdate = function(self, elapsed)

                 if the.keys:allJustPressed() then

                    the.app.view = GameView:new()

                 end

              end

}

the.app = App:new {

   onRun = function (self)

              print('Version: ' .. VERSION)

              math.randomseed(os.time())

              self.view = GameView:new()

              if DEBUG then

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

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

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

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

                 self.console:watch('the.app.width', 'the.app.width')

                 self.console:watch('the.app.height', 'the.app.height')

                 self.console:watch('num mirrors', '#the.mirrors.sprites')

                 self.console:watch('num rocks', '#the.rocks.sprites')

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

                 -- back off that dark overlay a bit

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

              end

           end,

   onUpdate = function (self, dt)

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

                    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

}