/traderous

To get this branch, use:
bzr branch http://9ix.org/bzr/traderous

« back to all changes in this revision

Viewing changes to main.lua

  • Committer: Josh C
  • Date: 2013-06-16 00:13:58 UTC
  • Revision ID: josh@9ix.org-20130616001358-dw3n864y37fgw1hs
buy/sell

Show diffs side-by-side

added added

removed removed

Lines of Context:
2
2
DEBUG = true
3
3
 
4
4
require 'zoetrope'
5
 
--__ = require 'underscore'
6
5
vector = require 'vector'
 
6
--inspect = require 'inspect'
7
7
 
8
8
require 'group'
9
9
 
10
10
require 'version'
11
11
require 'wrap_tile'
 
12
require 'mirror'
12
13
require 'player'
13
14
require 'enemy'
14
15
require 'cursor'
15
16
require 'bullet'
16
17
require 'rock'
 
18
require 'boom'
 
19
require 'planet'
 
20
require 'trade_view'
17
21
 
18
22
util = {
19
23
   signOf = function(value)
22
26
               else
23
27
                  return -1
24
28
               end
25
 
            end
 
29
            end,
 
30
   shortestVector = function(from, to)
 
31
                       if STRICT then
 
32
                          if from.x < the.app.width / 2 or
 
33
                             from.x > the.bg.width - the.app.width / 2 or
 
34
                             from.y < the.app.height / 2 or
 
35
                             from.y > the.bg.height - the.app.height / 2 then
 
36
                             error('"from" coordinate out of bounds: X='..from.x..' Y='..from.y)
 
37
                          end
 
38
 
 
39
                          if to.x < the.app.width / 2 or
 
40
                             to.x > the.bg.width - the.app.width / 2 or
 
41
                             to.y < the.app.height / 2 or
 
42
                             to.y > the.bg.height - the.app.height / 2 then
 
43
                             error('"to" coordinate out of bounds: X='..to.x..' Y='..to.y)
 
44
                          end
 
45
                       end
 
46
 
 
47
                       -- normalize grid to account for mirror zones
 
48
                       local fx = from.x - the.app.width / 2
 
49
                       local fy = from.y - the.app.height / 2
 
50
                       local tx = to.x - the.app.width / 2
 
51
                       local ty = to.y - the.app.height / 2
 
52
 
 
53
                       local short = {}
 
54
 
 
55
                       -- pick shorter x
 
56
                       if math.abs(tx - fx) < math.abs(tx - fx - (the.bg.width - the.app.width)) then
 
57
                          -- straight path is shorter
 
58
                          short.x = tx - fx
 
59
                       else
 
60
                          short.x = tx - fx - (the.bg.width - the.app.width)
 
61
                       end
 
62
 
 
63
                       -- pick shorter y
 
64
                       if math.abs(ty - fy) < math.abs(ty - fy - (the.bg.height - the.app.height)) then
 
65
                          -- straight path is shorter
 
66
                          short.y = ty - fy
 
67
                       else
 
68
                          short.y = ty - fy - (the.bg.height - the.app.height)
 
69
                       end
 
70
 
 
71
                       return vector.new(short.x, short.y)
 
72
                    end
26
73
}
27
74
 
28
75
GameView = View:extend {
39
86
              --    end
40
87
              -- end
41
88
 
 
89
              the.storage = Storage:new{filename = 'scores.lua'}
 
90
              the.storage:load()
 
91
              if not the.storage.data.highScore then
 
92
                 print('initializing storage')
 
93
                 the.storage.data = {highScore = 0}
 
94
              end
 
95
 
 
96
              --the.rockColliders = Group:new()
 
97
              the.bullets = Group:new()
 
98
              the.mirrors = Group:new()
 
99
              --the.rocks = Group:new()
 
100
              the.interface = Group:new()
 
101
              the.planets = Group:new()
 
102
              the.indicators = Group:new()
 
103
 
42
104
              the.bg = Tile:new{
43
105
                 image = 'data/stars3.png',
44
 
                 -- 1366x768 * 3
45
 
                 width = 4098,
46
 
                 height = 2304
 
106
                 width = 13660,
 
107
                 height = 7680
47
108
              }
48
109
              self:add(the.bg)
49
110
 
 
111
              self:add(the.planets)
 
112
 
50
113
              --the.player = CrystalPlayer:new{x=400,y=300}
51
 
              the.player = SpacePlayer:new{x=1366,y=768}
 
114
              the.player = SpacePlayer:new{x=the.bg.width / 2, y=the.bg.height / 2}
52
115
              self:add(the.player)
53
 
 
54
 
              self:add(Enemy:new{x=400, y=300})
 
116
              self:add(the.player.thrust)
 
117
 
 
118
              --self:add(Enemy:new{x=400, y=300})
 
119
 
 
120
              self:add(the.bullets)
 
121
              --self:add(the.rockColliders)
 
122
              self:add(the.mirrors)
 
123
              --self:add(the.rocks)
 
124
              self:add(the.indicators)
 
125
              self:add(the.interface)
 
126
 
 
127
              for _ = 1, math.random(6) do
 
128
                 local planet = Planet:new{
 
129
                    x = math.random(the.app.width / 2,
 
130
                                    the.bg.width - the.app.width / 2),
 
131
                    y = math.random(the.app.height / 2,
 
132
                                    the.bg.height - the.app.height / 2),
 
133
                    rotation = math.random() * math.pi
 
134
                 }
 
135
                 the.planets:add(planet)
 
136
              end
55
137
 
56
138
              the.cursor = Cursor:new()
57
139
              self:add(the.cursor)
58
140
 
 
141
              the.score = Text:new{
 
142
                 x = 8,
 
143
                 y = 8,
 
144
                 width = the.app.width,
 
145
                 --align = 'center',
 
146
                 font = 25}
 
147
              --the.interface:add(the.score)
 
148
 
 
149
              local hs = the.storage.data.highScore
 
150
              local m = hs / 60
 
151
              local s = hs % 60
 
152
 
 
153
              the.highScore = Text:new{
 
154
                 x = -8,
 
155
                 y = 8,
 
156
                 width = the.app.width,
 
157
                 align = 'right',
 
158
                 font = 25,
 
159
                 text = string.format('High Score: %d:%02d', m, s)
 
160
              }
 
161
              --the.interface:add(the.highScore)
 
162
 
 
163
              the.over = Text:new{
 
164
                 y = the.app.height / 2,
 
165
                 width = the.app.width,
 
166
                 align = 'center',
 
167
                 font = 25,
 
168
                 text = "Game Over",
 
169
                 visible = false
 
170
              }
 
171
              the.interface:add(the.over)
 
172
 
 
173
 
 
174
              the.instructions = Text:new{
 
175
                 y = the.app.height / 2 + 32,
 
176
                 width = the.app.width,
 
177
                 align = 'center',
 
178
                 font = 12,
 
179
                 text = "Press Enter to start a new game\nPress Q to quit",
 
180
                 visible = false
 
181
              }
 
182
              the.interface:add(the.instructions)
 
183
 
59
184
              love.mouse.setGrab(true)
60
185
              love.mouse.setVisible(false)
 
186
              love.mouse.setPosition(the.app.width / 2, the.app.height / 2)
61
187
 
62
188
              --self:loadLayers('data/map.lua')
63
189
              self.focus = the.player
66
192
              self.gameStart = love.timer.getTime()
67
193
           end,
68
194
   onUpdate = function(self, dt)
69
 
                 if love.timer.getTime() > self.lastRock + self.rockInterval then
70
 
                    local rock = Rock:new{
71
 
                       x = math.random(the.bg.width),
72
 
                       y = math.random(the.bg.height),
73
 
                       velocity = {
74
 
                          x = math.random(-300, 300),
75
 
                          y = math.random(-300, 300),
76
 
                          rotation = math.random(-7, 7)
77
 
                       },
78
 
                       scale = math.random() + 0.5
79
 
                    }
80
 
                    self:add(rock)
 
195
                 if false and the.player.active and love.timer.getTime() > self.lastRock + self.rockInterval then
 
196
                    local unseenRock = nil
 
197
                    while not unseenRock do
 
198
                       local rock = Rock:new{
 
199
                          x = math.random(the.app.width / 2,
 
200
                                          the.bg.width - the.app.width / 2),
 
201
                          y = math.random(the.app.height / 2,
 
202
                                          the.bg.height - the.app.height / 2),
 
203
                          velocity = {
 
204
                             x = math.random(-300, 300),
 
205
                             y = math.random(-300, 300),
 
206
                             rotation = math.random(-7, 7)
 
207
                          },
 
208
                          scale = math.random() + 0.5
 
209
                       }
 
210
 
 
211
                       local rockToPlayer = util.shortestVector(rock, the.player)
 
212
                       if math.abs(rockToPlayer.x) > the.app.width / 2 + rock.width * rock.scale and
 
213
                           math.abs(rockToPlayer.y) > the.app.height / 2 + rock.height * rock.scale then
 
214
                         unseenRock = rock
 
215
                        end
 
216
                    end
 
217
 
 
218
                    the.rocks:add(unseenRock)
81
219
 
82
220
                    self.lastRock = love.timer.getTime()
83
221
                 end
 
222
 
 
223
                 the.bullets:collide(the.rockColliders)
 
224
 
 
225
                 -- this should really go somewhere else...
 
226
                 for _, planet in ipairs(the.planets.sprites) do
 
227
                    local indx, indy
 
228
                    local pvec = vector.new(
 
229
                       planet.x - the.player.x + planet.width / 2,
 
230
                       planet.y - the.player.y + planet.height / 2 )
 
231
 
 
232
                    -- TODO: is there a better way to specify the
 
233
                    -- screen rectangle?
 
234
                    if planet:intersects(the.player.x - the.app.width / 2,
 
235
                                         the.player.y - the.app.height / 2,
 
236
                                         the.app.width,
 
237
                                         the.app.height) then
 
238
                       -- planet is on the screen
 
239
                       planet.indicator.visible = false
 
240
                    else
 
241
                       planet.indicator.visible = true
 
242
 
 
243
                       if math.abs(pvec.x) / math.abs(pvec.y) > the.app.width / the.app.height then
 
244
                          indx = (the.app.width / 2 - 10) * util.signOf(pvec.x) + 8
 
245
                          indy = (the.app.width / 2 - 10) * pvec.y / math.abs(pvec.x)
 
246
                       else
 
247
                          indy = (the.app.height / 2 - 10) * util.signOf(pvec.y) + 8
 
248
                          indx = (the.app.height / 2 - 10) * pvec.x / math.abs(pvec.y)
 
249
                       end
 
250
 
 
251
                       planet.indicator.x = the.player.x + indx
 
252
                       planet.indicator.y = the.player.y + indy
 
253
                    end
 
254
                 end
 
255
 
 
256
                 -- for _, mirror in ipairs(the.mirrors.sprites) do
 
257
                 --    if not mirror.of then
 
258
                 --       print('mirror:' .. inspect(mirror))
 
259
                 --       error('mirror OF NOTHING')
 
260
                 --    end
 
261
                 -- end
84
262
              end,
 
263
   onEndFrame = function(self)
 
264
                   the.interface.translate.x = the.player.x - the.app.width / 2 + the.player.width / 2
 
265
                   the.interface.translate.y = the.player.y - the.app.height / 2 + the.player.height / 2
 
266
 
 
267
                   if the.player.active then
 
268
                      self:updateScore()
 
269
                   end
 
270
                end,
85
271
   draw = function (self, x, y)
86
272
             View.draw(self, x, y)
87
 
             love.graphics.print('FPS:' .. love.timer.getFPS(), 20, 20)
88
 
          end
 
273
             --love.graphics.print('FPS:' .. love.timer.getFPS(), 20, 20)
 
274
          end,
 
275
   updateScore = function(self)
 
276
                    local t = love.timer.getTime() - self.gameStart
 
277
                    local m = t / 60
 
278
                    local s = t % 60
 
279
 
 
280
                    the.score.text = string.format('Score: %d:%02d', m, s)
 
281
                    --the.score.y = the.player.y - the.app.height / 2 + the.player.height
 
282
                    --the.score.x = the.player.x - the.app.width / 2 + the.player.width
 
283
 
 
284
                    --the.highScore.y = the.player.y - the.app.height / 2 + the.player.height
 
285
                    --the.highScore.x = the.player.x - the.app.width / 2
 
286
                 end
89
287
}
90
288
 
91
289
MenuScreen = View:extend {
109
307
              math.randomseed(os.time())
110
308
 
111
309
              self.view = GameView:new()
 
310
 
112
311
              if DEBUG then
113
312
                 self.console:watch('VERSION', 'VERSION')
114
313
                 self.console:watch('updateTook', 'the.updateTook')
116
315
                 self.console:watch('the.player.y', 'the.player.y')
117
316
                 self.console:watch('the.app.width', 'the.app.width')
118
317
                 self.console:watch('the.app.height', 'the.app.height')
 
318
                 self.console:watch('num mirrors', '#the.mirrors.sprites')
 
319
                 self.console:watch('num rocks', '#the.rocks.sprites')
 
320
                 self.console:watch('num planets', '#the.planets.sprites')
119
321
                 --self.console:watch('drawTook', 'the.drawTook')
120
322
 
121
323
                 -- back off that dark overlay a bit
123
325
              end
124
326
           end,
125
327
   onUpdate = function (self, dt)
126
 
                 if the.keys:justPressed('escape') then
127
 
                    self.quit()
 
328
                 if not (DEBUG and the.console.visible) then
 
329
                    if the.keys:justPressed('q') then
 
330
                       self.quit()
 
331
                    elseif the.keys:justPressed('return') then
 
332
                       if the.keys:pressed('alt') then
 
333
                          love.graphics.toggleFullscreen()
 
334
                       else
 
335
                          self.view = GameView:new()
 
336
                       end
 
337
                    elseif the.keys:justPressed('f1') then
 
338
                       local ss = love.graphics.newScreenshot()
 
339
                       ss:encode('screenshot-' ..love.timer.getTime()..'.png')
 
340
                    elseif the.keys:justPressed('f11') then
 
341
                       love.graphics.toggleFullscreen()
 
342
                    end
128
343
                 end
129
344
              end,
130
345
   update = function (self, dt)
135
350
               end
136
351
            end
137
352
}
 
353
 
 
354
realRun = love.run
 
355
function love.run()
 
356
   -- should fail silently if it can't go to fullscreen...
 
357
   love.graphics.toggleFullscreen()
 
358
 
 
359
   realRun()
 
360
end
 
 
b'\\ No newline at end of file'