/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:41:47 UTC
  • Revision ID: josh@9ix.org-20130410004147-fj20d61atq2cgyqb
record/playback system (doesn't really work)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
STRICT = true
2
2
DEBUG = true
 
3
RECORD = true
 
4
PLAYBACK = false
3
5
 
4
6
require 'zoetrope'
5
 
 
6
 
Player = Tile:extend {
 
7
__ = require 'underscore'
 
8
--inspect = require 'inspect'
 
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
}
 
22
 
 
23
Player = Animation:extend {
7
24
   image = 'data/player.png',
8
 
   onUpdate = function (self)
9
 
                 self.velocity.x = 0
10
 
                 self.velocity.y = 0
11
 
 
12
 
                 if the.keys:pressed('left') then
13
 
                    self.velocity.x = -200
14
 
                 elseif the.keys:pressed('right') then
15
 
                    self.velocity.x = 200
16
 
                 end
17
 
              end
 
25
   height = 32,
 
26
   width = 32,
 
27
   sequences = {
 
28
      stand = { frames = { 1 }, fps = 1 },
 
29
      walk = { frames = { 2, 3 }, fps = 5 },
 
30
      jump = { frames = { 4 }, fps = 1 },
 
31
      climbLeft = { frames = { 5, 6 }, fps = 5 },
 
32
      climbRight = { frames = { 7, 8 }, fps = 5 }
 
33
   },
 
34
   collisions = {},
 
35
   onWall = false,
 
36
   leftWallAt = 0,
 
37
   onNew = function (self)
 
38
              self.velocity.y = 0
 
39
              self.maxVelocity.y = 400
 
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,
 
96
   onStartFrame = function (self)
 
97
                     -- this is all in startframe so it happens before
 
98
                     -- physics calc at beginning of update
 
99
 
 
100
                     -- jumping/falling updates could go in EndFrame...
 
101
                     self.falling = self.velocity.y > 0
 
102
                     if self.falling then self.jumping = false end
 
103
                     --print(self.jumping, self.falling)
 
104
 
 
105
                     if (not self.onGround) and (not self.onWall) then
 
106
                        self:play('jump')
 
107
                     end
 
108
 
 
109
                     self.acceleration.y = 800
 
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
 
 
130
                     if the.keys:pressed('left') then
 
131
                        self.velocity.x = -200
 
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
 
137
                     elseif the.keys:pressed('right') then
 
138
                        self.velocity.x = 200
 
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
 
144
                     else
 
145
                        if not self.onWall then
 
146
                           if self.onGround then self:play('stand') end
 
147
                           self.velocity.x = 0
 
148
                        end
 
149
                     end
 
150
 
 
151
                     if the.keys:justPressed('up') and
 
152
                      (self.onGround or the.console.visible or
 
153
                       (love.timer.getTime() - self.leftWallAt < .1) ) then
 
154
                        self.velocity.y = -400
 
155
                        self.jumping = true
 
156
                     end
 
157
                  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
               Animation.update(self, elapsed)
 
193
            end,
 
194
   collide = function (self, ...)
 
195
                self.collisions = {}
 
196
                Animation.collide(self, ...)
 
197
                -- I could return a true/false value here if I wanted to...
 
198
             end,
 
199
   onCollide = function (self, other, xOverlap, yOverlap)
 
200
                  if other == the.view.map then return end
 
201
 
 
202
                  table.insert(self.collisions, {other = other,
 
203
                                                 xOverlap = xOverlap,
 
204
                                                 yOverlap = yOverlap })
 
205
               end
18
206
}
19
207
 
 
208
-- displace on a specific axis (monkey patch Sprite)
 
209
function Sprite:displaceDir(other, dir)
 
210
   if not self.solid or self == other or not other.solid then return end
 
211
   if STRICT then assert(other:instanceOf(Sprite), 'asked to displace a non-sprite') end
 
212
 
 
213
   if other.sprites then
 
214
      -- handle groups
 
215
 
 
216
      for _, spr in pairs(other.sprites) do
 
217
         self:displace(spr, dir)
 
218
      end
 
219
   else
 
220
      -- handle sprites
 
221
      local dim = util.dim(dir)
 
222
 
 
223
      local negMove = (other[dir] - self[dir]) + other[dim]
 
224
      local posMove = (self[dir] + self[dim]) - other[dir]
 
225
 
 
226
      -- TODO: re-add hinting?
 
227
      if negMove < posMove then
 
228
         chg = - negMove
 
229
      else
 
230
         chg = posMove
 
231
      end
 
232
   end
 
233
 
 
234
   other[dir] = other[dir] + chg
 
235
end
 
236
 
 
237
-- don't use zoetrope physics
 
238
function Sprite:update (elapsed)
 
239
   if self.onUpdate then self:onUpdate(elapsed) end
 
240
end
 
241
 
20
242
GameView = View:extend {
21
243
   onNew = function (self)
22
244
              self:loadLayers('data/map.lua')
23
245
              self.focus = the.player
24
246
              self:clampTo(self.map)
 
247
 
 
248
              the.recorder = Recorder:new{mousePosInterval = 9999}
 
249
              the.app.meta:add(the.recorder)
 
250
              if RECORD then
 
251
                 the.recorder:startRecording()
 
252
              elseif PLAYBACK then
 
253
                 local storage = Storage:new{filename = 'record.lua'}
 
254
                 storage:load()
 
255
                 --print(inspect(storage.data))
 
256
                 the.recorder.record = storage.data
 
257
                 the.recorder:startPlaying()
 
258
              end
25
259
           end,
 
260
   onUpdate = function (self)
 
261
                 --print('drawTook: ', the.drawTook)
 
262
                 --print('tick')
 
263
                 --the.player:collide(self.map)
 
264
                 --self.map:collide(the.player)
 
265
              end,
 
266
   -- draw = function (self, x, y)
 
267
   --           View.draw(self, x, y)
26
268
 
27
 
   onUpdate = function (self, dt)
28
 
                 self.map:subdisplace(the.player)
29
 
              end
 
269
   --           love.graphics.print('FPS:' .. love.timer.getFPS(), 20, 20)
 
270
   --        end
30
271
}
31
272
 
32
273
the.app = App:new {
33
274
   onRun = function (self)
34
275
              self.view = GameView:new()
 
276
              self.console:watch('onGround', 'the.player.onGround')
 
277
              self.console:watch('onWall', 'the.player.onWall')
 
278
              self.console:watch('updateTook', 'the.updateTook')
 
279
              self.console:watch('drawTook', 'the.drawTook')
 
280
              self.console:watch('recorder state', 'the.recorder.state')
 
281
 
 
282
              --the.profiler = newProfiler('time', 2000)
 
283
              --the.profiler = newProfiler()
 
284
              --the.profiler:start()
35
285
           end,
36
286
   onUpdate = function (self, dt)
37
287
                 if the.keys:justPressed('escape') then
38
 
                    love.event.quit()
 
288
                    if the.profiler then
 
289
                       the.profiler:stop()
 
290
                       local outfile = io.open( "profile.txt", "w+" )
 
291
                       the.profiler:report( outfile )
 
292
                       outfile:close()
 
293
                    end
 
294
 
 
295
                    if RECORD then
 
296
                       if not love.filesystem.remove('record.lua') then
 
297
                          error('could not remove record.lua')
 
298
                       end
 
299
                       local storage = Storage:new{
 
300
                          data = the.recorder.record,
 
301
                          filename = 'record.lua'
 
302
                       }
 
303
                       storage:save(false)
 
304
                       --print(inspect(the.recorder.record))
 
305
                    end
 
306
 
 
307
                    self.quit()
39
308
                 end
40
 
              end
41
 
}
 
 
b'\\ No newline at end of file'
 
309
              end,
 
310
   update = function (self, dt)
 
311
               the.updateStart = love.timer.getMicroTime()
 
312
               App.update(self, dt)
 
313
               if the.updateStart then
 
314
                  the.updateTook = love.timer.getMicroTime() - the.updateStart
 
315
               end
 
316
            end
 
317
}