/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-04 23:27:03 UTC
  • Revision ID: josh@9ix.org-20130304232703-nob2mg5wbo5co5is
basic tiles, map, player, movement

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
 
 
22
 
Player = Animation:extend {
 
5
 
 
6
Player = Tile:extend {
23
7
   image = 'data/player.png',
24
 
   height = 32,
25
 
   width = 32,
26
 
   sequences = {
27
 
      stand = { frames = { 1 }, fps = 1 },
28
 
      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 }
32
 
   },
33
 
   collisions = {},
34
 
   onWall = false,
35
 
   leftWallAt = 0,
36
 
   onNew = function (self)
37
 
              self.velocity.y = 0
38
 
              self.maxVelocity.y = 400
39
 
           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
 
   onStartFrame = function (self)
96
 
                     -- this is all in startframe so it happens before
97
 
                     -- physics calc at beginning of update
98
 
 
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
 
 
108
 
                     self.acceleration.y = 800
109
 
 
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
 
                     if the.keys:pressed('left') then
130
 
                        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
136
 
                     elseif the.keys:pressed('right') then
137
 
                        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
143
 
                     else
144
 
                        if not self.onWall then
145
 
                           if self.onGround then self:play('stand') end
146
 
                           self.velocity.x = 0
147
 
                        end
148
 
                     end
149
 
 
150
 
                     if the.keys:justPressed('up') and
151
 
                      (self.onGround or the.console.visible or
152
 
                       (love.timer.getTime() - self.leftWallAt < .1) ) then
153
 
                        self.velocity.y = -400
154
 
                        self.jumping = true
155
 
                     end
156
 
                  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
 
   onCollide = function (self, other, xOverlap, yOverlap)
214
 
                  if other == the.view.map then return end
215
 
 
216
 
                  table.insert(self.collisions, {other = other,
217
 
                                                 xOverlap = xOverlap,
218
 
                                                 yOverlap = yOverlap })
219
 
               end
 
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
220
18
}
221
19
 
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
20
GameView = View:extend {
255
21
   onNew = function (self)
256
22
              self:loadLayers('data/map.lua')
257
23
              self.focus = the.player
258
24
              self:clampTo(self.map)
 
25
           end,
259
26
 
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()
 
27
   onUpdate = function (self, dt)
 
28
                 self.map:subdisplace(the.player)
270
29
              end
271
 
           end,
272
 
   onUpdate = function (self)
273
 
                 --print('drawTook: ', the.drawTook)
274
 
                 --print('tick')
275
 
                 --the.player:collide(self.map)
276
 
                 --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
283
30
}
284
31
 
285
32
the.app = App:new {
286
 
   record = true,
287
33
   onRun = function (self)
288
34
              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
35
           end,
299
36
   onUpdate = function (self, dt)
300
37
                 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()
 
38
                    love.event.quit()
321
39
                 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'
 
40
              end
 
41
}
 
 
b'\\ No newline at end of file'