/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-15 01:54:31 UTC
  • Revision ID: josh@9ix.org-20130315015431-torvm0zhbk1rvkn3
wall jump

Show diffs side-by-side

added added

removed removed

Lines of Context:
4
4
require 'zoetrope'
5
5
__ = require 'underscore'
6
6
--inspect = require 'inspect'
7
 
require 'pepperprof'
8
 
require 'getopt_alt'
9
 
 
10
 
require 'sprite'
11
 
require 'animation'
12
 
require 'player'
13
 
require 'balloon'
14
 
 
15
 
util = {
16
 
   dim = function(dir)
 
7
 
 
8
Player = Animation:extend {
 
9
   image = 'data/player.png',
 
10
   height = 32,
 
11
   width = 32,
 
12
   sequences = {
 
13
      stand = { frames = { 1 }, fps = 1 },
 
14
      walk = { frames = { 2, 3 }, fps = 5 },
 
15
      jump = { frames = { 4 }, fps = 1 },
 
16
      climbLeft = { frames = { 5, 6 }, fps = 5 },
 
17
      climbRight = { frames = { 7, 8 }, fps = 5 }
 
18
   },
 
19
   collisions = {},
 
20
   onWall = false,
 
21
   leftWallAt = 0,
 
22
   onNew = function (self)
 
23
              self.velocity.y = 0
 
24
              self.maxVelocity.y = 400
 
25
           end,
 
26
   doPhysics = function (self, dir, elapsed)
 
27
                  local vel = self.velocity
 
28
                  local acc = self.acceleration
 
29
                  local drag = self.drag
 
30
                  local minVel = self.minVelocity
 
31
                  local maxVel = self.maxVelocity
 
32
 
 
33
                  -- check existence of properties
 
34
 
 
35
                  if STRICT then
 
36
                     assert(vel, 'active sprite has no velocity property')
 
37
                     assert(acc, 'active sprite has no acceleration property')
 
38
                     assert(drag, 'active sprite has no drag property')
 
39
                     assert(minVel, 'active sprite has no minVelocity property')
 
40
                     assert(maxVel, 'active sprite has no maxVelocity property')
 
41
                     assert(__.include({'x','y','rotation'}, dir), 'direction should be x, y, or rotation')
 
42
                  end
 
43
 
 
44
                  vel.x = vel.x or 0
 
45
                  vel.y = vel.y or 0
 
46
                  vel.rotation = vel.rotation or 0
 
47
 
 
48
                  -- physics
 
49
 
 
50
                  if acc[dir] and acc[dir] ~= 0 then
 
51
                     vel[dir] = vel[dir] + acc[dir] * elapsed
 
52
                  else
 
53
                     if drag[dir] then
 
54
                        if vel[dir] > 0 then
 
55
                           vel[dir] = vel[dir] - drag[dir] * elapsed
 
56
                           if vel[dir] < 0 then vel[dir] = 0 end
 
57
                        elseif vel[dir] < 0 then
 
58
                           vel[dir] = vel[dir] + drag[dir] * elapsed
 
59
                           if vel[dir] > 0 then vel[dir] = 0 end
 
60
                        end
 
61
                     end
 
62
                  end
 
63
 
 
64
                  if minVel[dir] and vel[dir] < minVel[dir] then vel[dir] = minVel[dir] end
 
65
                  if maxVel[dir] and vel[dir] > maxVel[dir] then vel[dir] = maxVel[dir] end
 
66
 
 
67
                  if vel[dir] ~= 0 then self[dir] = self[dir] + vel[dir] * elapsed end
 
68
               end,
 
69
   onStartFrame = function (self)
 
70
                     -- this is all in startframe so it happens before
 
71
                     -- physics calc at beginning of update
 
72
 
 
73
                     -- jumping/falling updates could go in EndFrame...
 
74
                     self.falling = self.velocity.y > 0
 
75
                     if self.falling then self.jumping = false end
 
76
                     --print(self.jumping, self.falling)
 
77
 
 
78
                     if (not self.onGround) and (not self.onWall) then
 
79
                        self:play('jump')
 
80
                     end
 
81
 
 
82
                     self.acceleration.y = 800
 
83
 
 
84
                     if self.onWall then
 
85
                        self.acceleration.y = 0
 
86
 
 
87
                        if self.onWall == 'right' then
 
88
                           self:play('climbRight')
 
89
                        elseif self.onWall == 'left' then
 
90
                           self:play('climbLeft')
 
91
                        end
 
92
 
 
93
                        if the.keys:pressed('up') then
 
94
                           self.velocity.y = -200
 
95
                        elseif the.keys:pressed('down') then
 
96
                           self.velocity.y = 200
 
97
                        else
 
98
                           self.velocity.y = 0
 
99
                           self:freeze(self.sequences[self.currentName].frames[1])
 
100
                        end
 
101
                     end
 
102
 
 
103
                     if the.keys:pressed('left') then
 
104
                        self.velocity.x = -200
 
105
                        if self.onGround then self:play('walk') end
 
106
                        if self.onWall == 'right' then
 
107
                           self.onWall = false
 
108
                           self.leftWallAt = love.timer.getTime()
 
109
                        end
 
110
                     elseif the.keys:pressed('right') then
 
111
                        self.velocity.x = 200
 
112
                        if self.onGround then self:play('walk') end
 
113
                        if self.onWall == 'left' then
 
114
                           self.onWall = false
 
115
                           self.leftWallAt = love.timer.getTime()
 
116
                        end
 
117
                     else
 
118
                        if not self.onWall then
 
119
                           if self.onGround then self:play('stand') end
 
120
                           self.velocity.x = 0
 
121
                        end
 
122
                     end
 
123
 
 
124
                     if the.keys:justPressed('up') and
 
125
                      (self.onGround or
 
126
                       (love.timer.getTime() - self.leftWallAt < .1) ) then
 
127
                        self.velocity.y = -400
 
128
                        self.jumping = true
 
129
                     end
 
130
                  end,
 
131
   update = function (self, elapsed)
 
132
               -- NOTE: this is an override, not a callback
 
133
 
 
134
               self:doPhysics('x', elapsed)
 
135
               self:collide(the.view.map)
 
136
 
 
137
               -- handle X collisions
 
138
               self.onWall = false
 
139
               for _, col in ipairs(self.collisions) do
 
140
                  col.other:displaceDir(self, 'x')
 
141
                  if self.velocity.x > 0 then
 
142
                     self.onWall = 'right'
 
143
                  elseif self.velocity.x < 0 then
 
144
                     self.onWall = 'left'
 
145
                  else
 
146
                     print 'x ??'
 
147
                  end
 
148
               end
 
149
 
 
150
               self.onGround = false -- right before Y collision callbacks
 
151
               self:doPhysics('y', elapsed)
 
152
               self:collide(the.view.map)
 
153
 
 
154
               -- handle Y collisions
 
155
               for _, col in ipairs(self.collisions) do
 
156
                  if self.velocity.y > 0 then
 
157
                     self.onGround = true
 
158
                  end
 
159
 
 
160
                  col.other:displaceDir(self, 'y')
 
161
                  self.velocity.y = 0
 
162
                  self.jumping = false
 
163
               end
 
164
 
 
165
               Animation.update(self, elapsed)
 
166
            end,
 
167
   collide = function (self, ...)
 
168
                self.collisions = {}
 
169
                Animation.collide(self, ...)
 
170
                -- I could return a true/false value here if I wanted to...
 
171
             end,
 
172
   onCollide = function (self, other, xOverlap, yOverlap)
 
173
                  if other == the.view.map then return end
 
174
 
 
175
                  table.insert(self.collisions, {other = other,
 
176
                                                 xOverlap = xOverlap,
 
177
                                                 yOverlap = yOverlap })
 
178
               end
 
179
}
 
180
 
 
181
-- displace on a specific axis (monkey patch Sprite)
 
182
function Sprite:displaceDir(other, dir)
 
183
   if not self.solid or self == other or not other.solid then return end
 
184
   if STRICT then assert(other:instanceOf(Sprite), 'asked to displace a non-sprite') end
 
185
 
 
186
   if other.sprites then
 
187
      -- handle groups
 
188
 
 
189
      for _, spr in pairs(other.sprites) do
 
190
         self:displace(spr, dir)
 
191
      end
 
192
   else
 
193
      -- handle sprites
 
194
      local dim
17
195
      if dir == 'x' then
18
 
         return 'width'
 
196
         dim = 'width'
19
197
      elseif dir == 'y' then
20
 
         return 'height'
21
 
      else
22
 
         if STRICT then error('dir '..dir) end
 
198
         dim = 'height'
 
199
      else
 
200
         print 'dir ??'
 
201
      end
 
202
 
 
203
      local negMove = (other[dir] - self[dir]) + other[dim]
 
204
      local posMove = (self[dir] + self[dim]) - other[dir]
 
205
 
 
206
      -- TODO: re-add hinting?
 
207
      if negMove < posMove then
 
208
         chg = - negMove
 
209
      else
 
210
         chg = posMove
23
211
      end
24
212
   end
25
 
}
 
213
 
 
214
   other[dir] = other[dir] + chg
 
215
end
26
216
 
27
217
GameView = View:extend {
28
218
   onNew = function (self)
29
219
              self:loadLayers('data/map.lua')
30
220
              self.focus = the.player
31
221
              self:clampTo(self.map)
32
 
 
33
 
              the.recorder = Recorder:new{mousePosInterval = 9999}
34
 
              the.app.meta:add(the.recorder)
35
 
              if the.app.record then
36
 
                 the.recorder:startRecording()
37
 
              elseif the.app.playback then
38
 
                 local storage = Storage:new{filename = 'record.lua'}
39
 
                 storage:load()
40
 
                 --print(inspect(storage.data))
41
 
                 the.recorder.record = storage.data
42
 
                 the.recorder:startPlaying()
43
 
              end
44
222
           end,
45
223
   onUpdate = function (self)
46
 
                 --print('drawTook: ', the.drawTook)
47
224
                 --print('tick')
48
225
                 --the.player:collide(self.map)
49
226
                 --self.map:collide(the.player)
50
 
              end,
51
 
   -- draw = function (self, x, y)
52
 
   --           View.draw(self, x, y)
53
 
 
54
 
   --           love.graphics.print('FPS:' .. love.timer.getFPS(), 20, 20)
55
 
   --        end
56
 
}
57
 
 
58
 
MenuScreen = View:extend {
59
 
   --title = Text:new{text = "Test Platform Game", font = 48, wordWrap = false},
60
 
   title = Tile:new{image = 'data/title.png', x = 0, y = 0},
61
 
   onNew = function(self)
62
 
              self:add(self.title)
63
 
              --self.title:centerAround(400, 200)
64
 
           end,
65
 
   onUpdate = function(self, elapsed)
66
 
                 if the.keys:allJustPressed() then
67
 
                    the.app.view = GameView:new()
68
 
                 end
69
227
              end
70
228
}
71
229
 
72
230
the.app = App:new {
73
 
   record = true,
74
231
   onRun = function (self)
75
 
              self.view = MenuScreen:new()
76
 
              if DEBUG then
77
 
                 self.console:watch('onGround', 'the.player.onGround')
78
 
                 self.console:watch('onWall', 'the.player.onWall')
79
 
                 self.console:watch('updateTook', 'the.updateTook')
80
 
                 self.console:watch('drawTook', 'the.drawTook')
81
 
                 self.console:watch('recorder state', 'the.recorder.state')
82
 
              end
83
 
 
84
 
              --the.profiler = newProfiler('time', 2000)
85
 
              --the.profiler = newProfiler()
86
 
              --the.profiler:start()
 
232
              self.view = GameView:new()
 
233
              self.console:watch('onGround', 'the.player.onGround')
 
234
              self.console:watch('onWall', 'the.player.onWall')
87
235
           end,
88
236
   onUpdate = function (self, dt)
89
 
                 if the.keys:justPressed('escape') then
90
 
                    if the.profiler then
91
 
                       the.profiler:stop()
92
 
                       local outfile = io.open( "profile.txt", "w+" )
93
 
                       the.profiler:report( outfile )
94
 
                       outfile:close()
95
 
                    end
96
 
 
97
 
                    if self.record and the.recorder then
98
 
                       if not love.filesystem.remove('record.lua') then
99
 
                          print('could not remove record.lua')
100
 
                       end
101
 
                       local storage = Storage:new{
102
 
                          data = the.recorder.record,
103
 
                          filename = 'record.lua'
104
 
                       }
105
 
                       storage:save(false)
106
 
                       --print(inspect(the.recorder.record))
107
 
                    end
108
 
 
 
237
                 if the.keys:justPressed('escape') and 
 
238
                   not self.console.visible then
109
239
                    self.quit()
110
240
                 end
111
 
              end,
112
 
   update = function (self, dt)
113
 
               the.updateStart = love.timer.getMicroTime()
114
 
               App.update(self, dt)
115
 
               if the.updateStart then
116
 
                  the.updateTook = love.timer.getMicroTime() - the.updateStart
117
 
               end
118
 
            end
119
 
}
120
 
 
121
 
function love.load (arg)
122
 
   opts = getopt(arg, '')
123
 
   if opts['p'] then
124
 
      the.app.playback = true
125
 
      the.app.record = false
126
 
   elseif opts['r'] then
127
 
      the.app.record = true
128
 
   end
129
 
 
130
 
   the.app:run()
131
 
end
 
 
b'\\ No newline at end of file'
 
241
              end
 
242
}
 
 
b'\\ No newline at end of file'