/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'
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',
 
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,
8
37
   onNew = function (self)
9
38
              self.velocity.y = 0
10
39
              self.maxVelocity.y = 400
11
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,
12
96
   onStartFrame = function (self)
13
97
                     -- this is all in startframe so it happens before
14
98
                     -- physics calc at beginning of update
15
99
 
16
 
                     self.velocity.x = 0
 
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
 
17
109
                     self.acceleration.y = 800
18
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
 
19
130
                     if the.keys:pressed('left') then
20
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
21
137
                     elseif the.keys:pressed('right') then
22
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
23
149
                     end
24
150
 
25
 
                     if the.keys:justPressed('up') then
 
151
                     if the.keys:justPressed('up') and
 
152
                      (self.onGround or the.console.visible or
 
153
                       (love.timer.getTime() - self.leftWallAt < .1) ) then
26
154
                        self.velocity.y = -400
 
155
                        self.jumping = true
27
156
                     end
28
157
                  end,
29
 
   onUpdate = function (self)
30
 
                 -- this is called after physics, so this makes sense here
31
 
                 the.view.map:subdisplace(self)
32
 
              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,
 
214
   onCollide = function (self, other, xOverlap, yOverlap)
 
215
                  if other == the.view.map then return end
 
216
 
 
217
                  table.insert(self.collisions, {other = other,
 
218
                                                 xOverlap = xOverlap,
 
219
                                                 yOverlap = yOverlap })
 
220
               end
33
221
}
34
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
 
35
257
GameView = View:extend {
36
258
   onNew = function (self)
37
259
              self:loadLayers('data/map.lua')
38
260
              self.focus = the.player
39
261
              self:clampTo(self.map)
40
 
           end
 
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
 
274
           end,
 
275
   onUpdate = function (self)
 
276
                 --print('drawTook: ', the.drawTook)
 
277
                 --print('tick')
 
278
                 --the.player:collide(self.map)
 
279
                 --self.map:collide(the.player)
 
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
41
286
}
42
287
 
43
288
the.app = App:new {
44
289
   onRun = function (self)
45
290
              self.view = GameView:new()
 
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()
46
300
           end,
47
301
   onUpdate = function (self, dt)
48
302
                 if the.keys:justPressed('escape') then
49
 
                    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()
50
323
                 end
51
 
              end
52
 
}
 
 
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
}