/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:
main.lua
1
1
STRICT = true
2
2
DEBUG = true
 
3
RECORD = true
 
4
PLAYBACK = false
3
5
 
4
6
require 'zoetrope'
5
7
__ = require 'underscore'
6
8
--inspect = require 'inspect'
7
9
require 'pepperprof'
8
 
require 'getopt_alt'
9
 
 
10
 
require 'sprite'
11
 
require 'animation'
12
 
require 'player'
13
 
require 'balloon'
14
 
require 'version'
15
10
 
16
11
util = {
17
12
   dim = function(dir)
25
20
   end
26
21
}
27
22
 
 
23
Player = Animation:extend {
 
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,
 
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
 
206
}
 
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
 
28
242
GameView = View:extend {
29
243
   onNew = function (self)
30
244
              self:loadLayers('data/map.lua')
33
247
 
34
248
              the.recorder = Recorder:new{mousePosInterval = 9999}
35
249
              the.app.meta:add(the.recorder)
36
 
              if the.app.record then
 
250
              if RECORD then
37
251
                 the.recorder:startRecording()
38
 
              elseif the.app.playback then
 
252
              elseif PLAYBACK then
39
253
                 local storage = Storage:new{filename = 'record.lua'}
40
254
                 storage:load()
41
255
                 --print(inspect(storage.data))
56
270
   --        end
57
271
}
58
272
 
59
 
MenuScreen = View:extend {
60
 
   --title = Text:new{text = "Test Platform Game", font = 48, wordWrap = false},
61
 
   title = Tile:new{image = 'data/title.png', x = 0, y = 0},
62
 
   onNew = function(self)
63
 
              self:add(self.title)
64
 
              --self.title:centerAround(400, 200)
65
 
           end,
66
 
   onUpdate = function(self, elapsed)
67
 
                 if the.keys:allJustPressed() then
68
 
                    the.app.view = GameView:new()
69
 
                 end
70
 
              end
71
 
}
72
 
 
73
273
the.app = App:new {
74
 
   record = true,
75
274
   onRun = function (self)
76
 
              self.view = MenuScreen:new()
77
 
              if DEBUG then
78
 
                 self.console:watch('VERSION', 'VERSION')
79
 
                 self.console:watch('onGround', 'the.player.onGround')
80
 
                 self.console:watch('onWall', 'the.player.onWall')
81
 
                 self.console:watch('updateTook', 'the.updateTook')
82
 
                 self.console:watch('drawTook', 'the.drawTook')
83
 
                 self.console:watch('recorder state', 'the.recorder.state')
84
 
              end
 
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')
85
281
 
86
282
              --the.profiler = newProfiler('time', 2000)
87
283
              --the.profiler = newProfiler()
96
292
                       outfile:close()
97
293
                    end
98
294
 
99
 
                    if self.record and the.recorder then
 
295
                    if RECORD then
100
296
                       if not love.filesystem.remove('record.lua') then
101
 
                          print('could not remove record.lua')
 
297
                          error('could not remove record.lua')
102
298
                       end
103
299
                       local storage = Storage:new{
104
300
                          data = the.recorder.record,
119
315
               end
120
316
            end
121
317
}
122
 
 
123
 
function love.load (arg)
124
 
   opts = getopt(arg, '')
125
 
   if opts['p'] then
126
 
      the.app.playback = true
127
 
      the.app.record = false
128
 
   elseif opts['r'] then
129
 
      the.app.record = true
130
 
   end
131
 
 
132
 
   the.app:run()
133
 
end
 
 
b'\\ No newline at end of file'