/zoeplat

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

« back to all changes in this revision

Viewing changes to main.lua

  • Committer: Josh C
  • Date: 2013-04-10 00:42:25 UTC
  • Revision ID: josh@9ix.org-20130410004225-ok7v6kq2g632mqmv
playing with text (disabled)

Show diffs side-by-side

added added

removed removed

Lines of Context:
main.lua
1
1
STRICT = true
2
2
DEBUG = true
 
3
RECORD = true
 
4
PLAYBACK = false
3
5
 
4
6
require 'zoetrope'
 
7
__ = require 'underscore'
5
8
--inspect = require 'inspect'
6
 
--_ = require 'underscore'
 
9
require 'pepperprof'
 
10
 
 
11
util = {
 
12
   dim = function(dir)
 
13
      if dir == 'x' then
 
14
         return 'width'
 
15
      elseif dir == 'y' then
 
16
         return 'height'
 
17
      else
 
18
         if STRICT then error('dir '..dir) end
 
19
      end
 
20
   end
 
21
}
7
22
 
8
23
Player = Animation:extend {
9
24
   image = 'data/player.png',
12
27
   sequences = {
13
28
      stand = { frames = { 1 }, fps = 1 },
14
29
      walk = { frames = { 2, 3 }, fps = 5 },
15
 
      jump = { frames = { 4 }, fps = 1 }
 
30
      jump = { frames = { 4 }, fps = 1 },
 
31
      climbLeft = { frames = { 5, 6 }, fps = 5 },
 
32
      climbRight = { frames = { 7, 8 }, fps = 5 }
16
33
   },
 
34
   collisions = {},
 
35
   onWall = false,
 
36
   leftWallAt = 0,
17
37
   onNew = function (self)
18
38
              self.velocity.y = 0
19
39
              self.maxVelocity.y = 400
20
40
           end,
 
41
   doPhysics = function (self, dir, elapsed)
 
42
                  local vel = self.velocity
 
43
                  local acc = self.acceleration
 
44
                  local drag = self.drag
 
45
                  local minVel = self.minVelocity
 
46
                  local maxVel = self.maxVelocity
 
47
 
 
48
                  -- check existence of properties
 
49
 
 
50
                  if STRICT then
 
51
                     assert(vel, 'active sprite has no velocity property')
 
52
                     assert(acc, 'active sprite has no acceleration property')
 
53
                     assert(drag, 'active sprite has no drag property')
 
54
                     assert(minVel, 'active sprite has no minVelocity property')
 
55
                     assert(maxVel, 'active sprite has no maxVelocity property')
 
56
                     assert(__.include({'x','y','rotation'}, dir), 'direction should be x, y, or rotation')
 
57
                  end
 
58
 
 
59
                  vel.x = vel.x or 0
 
60
                  vel.y = vel.y or 0
 
61
                  vel.rotation = vel.rotation or 0
 
62
 
 
63
                  -- physics
 
64
 
 
65
                  if acc[dir] and acc[dir] ~= 0 then
 
66
                     vel[dir] = vel[dir] + acc[dir] * elapsed
 
67
                  else
 
68
                     if drag[dir] then
 
69
                        if vel[dir] > 0 then
 
70
                           vel[dir] = vel[dir] - drag[dir] * elapsed
 
71
                           if vel[dir] < 0 then vel[dir] = 0 end
 
72
                        elseif vel[dir] < 0 then
 
73
                           vel[dir] = vel[dir] + drag[dir] * elapsed
 
74
                           if vel[dir] > 0 then vel[dir] = 0 end
 
75
                        end
 
76
                     end
 
77
                  end
 
78
 
 
79
                  if minVel[dir] and vel[dir] < minVel[dir] then vel[dir] = minVel[dir] end
 
80
                  if maxVel[dir] and vel[dir] > maxVel[dir] then vel[dir] = maxVel[dir] end
 
81
 
 
82
                  -- ugly hack for falling through floor on really slow frames
 
83
                  if math.abs(vel[dir] * elapsed) > 32 then
 
84
                     print('skip')
 
85
                     return
 
86
                  end
 
87
 
 
88
                  if vel[dir] ~= 0 then self[dir] = self[dir] + vel[dir] * elapsed end
 
89
 
 
90
                  if self[dir] < 0 then self[dir] = 0 end
 
91
                  local edge = the.view.map[util.dim(dir)] -
 
92
                               the.player[util.dim(dir)]
 
93
                  -- TODO: take map position into account
 
94
                  if self[dir] > edge then self[dir] = edge end
 
95
               end,
21
96
   onStartFrame = function (self)
22
97
                     -- this is all in startframe so it happens before
23
98
                     -- physics calc at beginning of update
27
102
                     if self.falling then self.jumping = false end
28
103
                     --print(self.jumping, self.falling)
29
104
 
30
 
                     self.velocity.x = 0
 
105
                     if (not self.onGround) and (not self.onWall) then
 
106
                        self:play('jump')
 
107
                     end
 
108
 
31
109
                     self.acceleration.y = 800
32
110
 
 
111
                     if self.onWall then
 
112
                        self.acceleration.y = 0
 
113
 
 
114
                        if self.onWall == 'right' then
 
115
                           self:play('climbRight')
 
116
                        elseif self.onWall == 'left' then
 
117
                           self:play('climbLeft')
 
118
                        end
 
119
 
 
120
                        if the.keys:pressed('up') then
 
121
                           self.velocity.y = -200
 
122
                        elseif the.keys:pressed('down') then
 
123
                           self.velocity.y = 200
 
124
                        else
 
125
                           self.velocity.y = 0
 
126
                           self:freeze(self.sequences[self.currentName].frames[1])
 
127
                        end
 
128
                     end
 
129
 
33
130
                     if the.keys:pressed('left') then
34
131
                        self.velocity.x = -200
35
 
                        if self:onGround() then self:play('walk') end
 
132
                        if self.onGround then self:play('walk') end
 
133
                        if self.onWall == 'right' then
 
134
                           self.onWall = false
 
135
                           self.leftWallAt = love.timer.getTime()
 
136
                        end
36
137
                     elseif the.keys:pressed('right') then
37
138
                        self.velocity.x = 200
38
 
                        if self:onGround() then self:play('walk') end
 
139
                        if self.onGround then self:play('walk') end
 
140
                        if self.onWall == 'left' then
 
141
                           self.onWall = false
 
142
                           self.leftWallAt = love.timer.getTime()
 
143
                        end
39
144
                     else
40
 
                        if self:onGround() then self:play('stand') end
 
145
                        if not self.onWall then
 
146
                           if self.onGround then self:play('stand') end
 
147
                           self.velocity.x = 0
 
148
                        end
41
149
                     end
42
150
 
43
 
                     if the.keys:justPressed('up') and self:onGround() then
 
151
                     if the.keys:justPressed('up') and
 
152
                      (self.onGround or the.console.visible or
 
153
                       (love.timer.getTime() - self.leftWallAt < .1) ) then
44
154
                        self.velocity.y = -400
45
155
                        self.jumping = true
46
 
                        self:play('jump')
47
156
                     end
48
157
                  end,
49
 
   onEndFrame = function (self)
50
 
                   --print(self.velocity.y)
51
 
                end,
 
158
   update = function (self, elapsed)
 
159
               -- NOTE: this is an override, not a callback
 
160
 
 
161
               self:doPhysics('x', elapsed)
 
162
               self:collide(the.view.map)
 
163
 
 
164
               -- handle X collisions
 
165
               self.onWall = false
 
166
               for _, col in ipairs(self.collisions) do
 
167
                  col.other:displaceDir(self, 'x')
 
168
                  if self.velocity.x > 0 then
 
169
                     self.onWall = 'right'
 
170
                  elseif self.velocity.x < 0 then
 
171
                     self.onWall = 'left'
 
172
                  else
 
173
                     print 'x ??'
 
174
                  end
 
175
               end
 
176
 
 
177
               self.onGround = false -- right before Y collision callbacks
 
178
               self:doPhysics('y', elapsed)
 
179
               self:collide(the.view.map)
 
180
 
 
181
               -- handle Y collisions
 
182
               for _, col in ipairs(self.collisions) do
 
183
                  if self.velocity.y > 0 then
 
184
                     self.onGround = true
 
185
                  end
 
186
 
 
187
                  col.other:displaceDir(self, 'y')
 
188
                  self.velocity.y = 0
 
189
                  self.jumping = false
 
190
               end
 
191
 
 
192
               -- text blob
 
193
               if not self.text then
 
194
                  self.text = Text:new{wordWrap = true, width = 50, tint = {0,0,0}}
 
195
                  self.textfill = Fill:new{width = 54, border = {0,0,255}}
 
196
                  --the.view:add(self.textfill)
 
197
                  --the.view:add(self.text)
 
198
               end
 
199
               self.text.text = "Blah blah big text etc etc wrapping"
 
200
               self.text:centerAround(self.x+16, self.y+16, 'horizontal')
 
201
               _, texth = self.text:getSize()
 
202
               self.text.y = self.y - texth - 4
 
203
               self.textfill.x = self.text.x - 2
 
204
               self.textfill.y = self.text.y - 2
 
205
               self.textfill.height = texth + 4
 
206
 
 
207
               Animation.update(self, elapsed)
 
208
            end,
 
209
   collide = function (self, ...)
 
210
                self.collisions = {}
 
211
                Animation.collide(self, ...)
 
212
                -- I could return a true/false value here if I wanted to...
 
213
             end,
52
214
   onCollide = function (self, other, xOverlap, yOverlap)
53
 
                  -- seriously, why does this even fire?
54
215
                  if other == the.view.map then return end
55
216
 
56
 
                  --print(string.format('col s{x=%i y=%i w=%i h=%i} %s', self.x, self.y, self.width, self.height, tostring(other)))
57
 
                  --print('vel.x:'..self.velocity.x.." vel.y:"..self.velocity.y)
58
 
 
59
 
                  -- assumption: any other collision is with a solid map tile
60
 
                  if yOverlap > xOverlap then
61
 
                     other:displace(self)
62
 
                  elseif xOverlap > yOverlap then
63
 
                     -- check if we've moved since collisions were generated
64
 
                     local xov, yov = self:overlap(other.x, other.y,
65
 
                                                   other.width, other.height)
66
 
                     if xov ~= 0 and yov ~= 0 then
67
 
                        self.velocity.y = 0
68
 
                        other:displace(self)
69
 
                        self.jumping = false
70
 
                     end
71
 
                  else
72
 
                     print('??')
73
 
                  end
74
 
 
75
 
               end,
76
 
   onGround = function (self)
77
 
                 return (not self.jumping) and (not self.falling)
78
 
              end
 
217
                  table.insert(self.collisions, {other = other,
 
218
                                                 xOverlap = xOverlap,
 
219
                                                 yOverlap = yOverlap })
 
220
               end
79
221
}
80
222
 
 
223
-- displace on a specific axis (monkey patch Sprite)
 
224
function Sprite:displaceDir(other, dir)
 
225
   if not self.solid or self == other or not other.solid then return end
 
226
   if STRICT then assert(other:instanceOf(Sprite), 'asked to displace a non-sprite') end
 
227
 
 
228
   if other.sprites then
 
229
      -- handle groups
 
230
 
 
231
      for _, spr in pairs(other.sprites) do
 
232
         self:displace(spr, dir)
 
233
      end
 
234
   else
 
235
      -- handle sprites
 
236
      local dim = util.dim(dir)
 
237
 
 
238
      local negMove = (other[dir] - self[dir]) + other[dim]
 
239
      local posMove = (self[dir] + self[dim]) - other[dir]
 
240
 
 
241
      -- TODO: re-add hinting?
 
242
      if negMove < posMove then
 
243
         chg = - negMove
 
244
      else
 
245
         chg = posMove
 
246
      end
 
247
   end
 
248
 
 
249
   other[dir] = other[dir] + chg
 
250
end
 
251
 
 
252
-- don't use zoetrope physics
 
253
function Sprite:update (elapsed)
 
254
   if self.onUpdate then self:onUpdate(elapsed) end
 
255
end
 
256
 
81
257
GameView = View:extend {
82
258
   onNew = function (self)
83
259
              self:loadLayers('data/map.lua')
84
260
              self.focus = the.player
85
261
              self:clampTo(self.map)
 
262
 
 
263
              the.recorder = Recorder:new{mousePosInterval = 9999}
 
264
              the.app.meta:add(the.recorder)
 
265
              if RECORD then
 
266
                 the.recorder:startRecording()
 
267
              elseif PLAYBACK then
 
268
                 local storage = Storage:new{filename = 'record.lua'}
 
269
                 storage:load()
 
270
                 --print(inspect(storage.data))
 
271
                 the.recorder.record = storage.data
 
272
                 the.recorder:startPlaying()
 
273
              end
86
274
           end,
87
275
   onUpdate = function (self)
 
276
                 --print('drawTook: ', the.drawTook)
88
277
                 --print('tick')
89
 
                 the.player:collide(self.map)
 
278
                 --the.player:collide(self.map)
90
279
                 --self.map:collide(the.player)
91
 
              end
 
280
              end,
 
281
   -- draw = function (self, x, y)
 
282
   --           View.draw(self, x, y)
 
283
 
 
284
   --           love.graphics.print('FPS:' .. love.timer.getFPS(), 20, 20)
 
285
   --        end
92
286
}
93
287
 
94
288
the.app = App:new {
95
289
   onRun = function (self)
96
290
              self.view = GameView:new()
97
 
              --print(inspect(_(the.app):keys()))
 
291
              self.console:watch('onGround', 'the.player.onGround')
 
292
              self.console:watch('onWall', 'the.player.onWall')
 
293
              self.console:watch('updateTook', 'the.updateTook')
 
294
              self.console:watch('drawTook', 'the.drawTook')
 
295
              self.console:watch('recorder state', 'the.recorder.state')
 
296
 
 
297
              --the.profiler = newProfiler('time', 2000)
 
298
              --the.profiler = newProfiler()
 
299
              --the.profiler:start()
98
300
           end,
99
301
   onUpdate = function (self, dt)
100
 
                 -- TODO: make this not work if debug console is active
101
302
                 if the.keys:justPressed('escape') then
102
 
                    love.event.quit()
 
303
                    if the.profiler then
 
304
                       the.profiler:stop()
 
305
                       local outfile = io.open( "profile.txt", "w+" )
 
306
                       the.profiler:report( outfile )
 
307
                       outfile:close()
 
308
                    end
 
309
 
 
310
                    if RECORD then
 
311
                       if not love.filesystem.remove('record.lua') then
 
312
                          error('could not remove record.lua')
 
313
                       end
 
314
                       local storage = Storage:new{
 
315
                          data = the.recorder.record,
 
316
                          filename = 'record.lua'
 
317
                       }
 
318
                       storage:save(false)
 
319
                       --print(inspect(the.recorder.record))
 
320
                    end
 
321
 
 
322
                    self.quit()
103
323
                 end
104
 
              end
105
 
}
 
 
b'\\ No newline at end of file'
 
324
              end,
 
325
   update = function (self, dt)
 
326
               the.updateStart = love.timer.getMicroTime()
 
327
               App.update(self, dt)
 
328
               if the.updateStart then
 
329
                  the.updateTook = love.timer.getMicroTime() - the.updateStart
 
330
               end
 
331
            end
 
332
}