/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'

require 'planet'

require 'trade_view'

require 'shield'

require 'pause_view'

require 'game_over'

require 'names'

require 'good'

util = {

   signOf = function(value)

               if value >= 0 then

                  return 1

               else

                  return -1

               end

            end,

}

GameView = View:extend {

   onNew = function (self)

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

              the.storage:load()

              --if not the.storage.data.highScore then

              --   print('initializing storage')

              --   the.storage.data = {highScore = 0}

              --end

              the.bullets = Group:new()

              the.interface = Group:new()

              the.planets = Group:new()

              the.planetLabels = Group:new()

              the.indicators = Group:new()

              the.enemies = Group:new()

              -- init bg before build/load since planets need to know bg size

              the.bg = Tile:new{

                 image = 'data/stars3.png',

                 width = 27320,

                 height = 15360

              }

              self:add(the.bg)

              if self.newWorld or not the.storage.data.player then

                 the.storage.data = {planets = {}}

                 -- build planets from random

                 for _ = 1, math.random(5, 7) do

                    local planet = Planet: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),

                       rotation = math.random() * math.pi

                    }

                    the.planets:add(planet)

                    table.insert(the.storage.data.planets, {

                                    x = planet.x,

                                    y = planet.y,

                                    rotation = planet.rotation,

                                    goods = planet.goods,

                                    name = planet.name

                                 })

                 end

                 Good:stockPlanets()

                 -- build fresh player

                 local player = SpacePlayer:new{x=the.bg.width / 2, y=the.bg.height / 2}

                 the.player = player

                 the.storage.data.player = {x = player.x,

                                            y = player.y,

                                            money = player.money,

                                            goods = player.goods,

                                            cargoSpace = player.cargoSpace

                                         }

                 the.storage:save()

              else

                 -- load planets with x, y, goods

                 for _, planetData in ipairs(the.storage.data.planets) do

                    the.planets:add(Planet:new(planetData))

                 end

                 -- load player with cargo, money, position

                 the.player = SpacePlayer:new(the.storage.data.player)

                 -- reload storage as we've turned it all into objects

                 the.storage:load()

              end

              self:add(the.planets)

              self:add(the.planetLabels)

              self:add(the.player)

              self:add(the.player.thrust)

              self:add(the.player.shield)

              self:add(the.enemies)

              for _ = 1, 20 do

                 local e = Enemy:new{x = math.random(the.bg.width),

                                     y = math.random(the.bg.height)}

                 --local e = Enemy:new{x=the.bg.width / 2, y=the.bg.height / 2}

                 the.enemies:add(e)

                 self:add(e.thrust) -- why doesn't this work in Enemy.new?

                 self:add(e.shield)

              end

              self:add(the.bullets)

              self:add(the.indicators)

              self:add(the.interface)

              the.cursor = Cursor:new()

              self:add(the.cursor)

              love.mouse.setGrab(true)

              love.mouse.setVisible(false)

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

              self.focus = the.player

           end,

   onUpdate = function(self, dt)

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

                    PauseView:new():activate()

                 end

                 the.bullets:collide(the.planets)

                 the.bullets:collide(the.player)

                 the.bullets:collide(the.enemies)

              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,

   draw = function (self, x, y)

             View.draw(self, x, y)

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

          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 {

   name = 'Traderous',

   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('num planets', '#the.planets.sprites')

                 self.console:watch('num enemies', 'the.enemies:count()')

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

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

                 --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 not (DEBUG and the.console.visible) then

                    if the.keys:justPressed('return') and the.keys:pressed('alt') then

                       love.graphics.toggleFullscreen()

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

                       local ss = love.graphics.newScreenshot()

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

                    elseif the.keys:justPressed('f11') then

                       love.graphics.toggleFullscreen()

                    end

                 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

}

realRun = love.run

function love.run()

   -- should fail silently if it can't go to fullscreen...

   love.graphics.toggleFullscreen()

   realRun()

end