/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-03-09 04:06:46 UTC
  • Revision ID: josh@9ix.org-20130309040646-2hvgxi5b87baez5g
make player an animation

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