/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:
main.lua
2
2
DEBUG = true
3
3
 
4
4
require 'zoetrope'
 
5
__ = require 'underscore'
5
6
--inspect = require 'inspect'
6
 
--_ = require 'underscore'
7
7
 
8
8
Player = Animation:extend {
9
9
   image = 'data/player.png',
12
12
   sequences = {
13
13
      stand = { frames = { 1 }, fps = 1 },
14
14
      walk = { frames = { 2, 3 }, fps = 5 },
15
 
      jump = { frames = { 4 }, fps = 1 }
 
15
      jump = { frames = { 4 }, fps = 1 },
 
16
      climbLeft = { frames = { 5, 6 }, fps = 5 },
 
17
      climbRight = { frames = { 7, 8 }, fps = 5 }
16
18
   },
 
19
   collisions = {},
 
20
   onWall = false,
 
21
   leftWallAt = 0,
17
22
   onNew = function (self)
18
23
              self.velocity.y = 0
19
24
              self.maxVelocity.y = 400
20
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,
21
69
   onStartFrame = function (self)
22
70
                     -- this is all in startframe so it happens before
23
71
                     -- physics calc at beginning of update
27
75
                     if self.falling then self.jumping = false end
28
76
                     --print(self.jumping, self.falling)
29
77
 
30
 
                     if not self.onGround then
 
78
                     if (not self.onGround) and (not self.onWall) then
31
79
                        self:play('jump')
32
80
                     end
33
81
 
34
 
                     self.velocity.x = 0
35
82
                     self.acceleration.y = 800
36
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
 
37
103
                     if the.keys:pressed('left') then
38
104
                        self.velocity.x = -200
39
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
40
110
                     elseif the.keys:pressed('right') then
41
111
                        self.velocity.x = 200
42
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
43
117
                     else
44
 
                        if self.onGround then self:play('stand') end
 
118
                        if not self.onWall then
 
119
                           if self.onGround then self:play('stand') end
 
120
                           self.velocity.x = 0
 
121
                        end
45
122
                     end
46
123
 
47
 
                     if the.keys:justPressed('up') and self.onGround then
 
124
                     if the.keys:justPressed('up') and
 
125
                      (self.onGround or
 
126
                       (love.timer.getTime() - self.leftWallAt < .1) ) then
48
127
                        self.velocity.y = -400
49
128
                        self.jumping = true
50
129
                     end
51
130
                  end,
52
 
   onUpdate = function (self)
53
 
                 -- needs to happen right before collision
54
 
                 self.onGround = false
55
 
                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,
56
172
   onCollide = function (self, other, xOverlap, yOverlap)
57
 
                  -- seriously, why does this even fire?
58
173
                  if other == the.view.map then return end
59
174
 
60
 
                  --print(string.format('col s{x=%i y=%i w=%i h=%i} %s', self.x, self.y, self.width, self.height, tostring(other)))
61
 
                  --print('vel.x:'..self.velocity.x.." vel.y:"..self.velocity.y)
62
 
 
63
 
                  -- assumption: any other collision is with a solid map tile
64
 
                  if yOverlap > xOverlap then
65
 
                     other:displace(self)
66
 
                  elseif xOverlap > yOverlap then
67
 
                     -- check if we've moved since collisions were generated
68
 
                     local xov, yov = self:overlap(other.x, other.y,
69
 
                                                   other.width, other.height)
70
 
                     if xov ~= 0 and yov ~= 0 then
71
 
                        --print('y collision')
72
 
                        if self.velocity.y > 0 then
73
 
                           self.onGround = true
74
 
                        end
75
 
 
76
 
                        self.velocity.y = 0
77
 
                        other:displace(self)
78
 
                        self.jumping = false
79
 
                     end
80
 
                  else
81
 
                     print('??')
82
 
                  end
83
 
 
84
 
               end,
 
175
                  table.insert(self.collisions, {other = other,
 
176
                                                 xOverlap = xOverlap,
 
177
                                                 yOverlap = yOverlap })
 
178
               end
85
179
}
86
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
 
195
      if dir == 'x' then
 
196
         dim = 'width'
 
197
      elseif dir == 'y' then
 
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
 
211
      end
 
212
   end
 
213
 
 
214
   other[dir] = other[dir] + chg
 
215
end
 
216
 
87
217
GameView = View:extend {
88
218
   onNew = function (self)
89
219
              self:loadLayers('data/map.lua')
92
222
           end,
93
223
   onUpdate = function (self)
94
224
                 --print('tick')
95
 
                 the.player:collide(self.map)
 
225
                 --the.player:collide(self.map)
96
226
                 --self.map:collide(the.player)
97
227
              end
98
228
}
100
230
the.app = App:new {
101
231
   onRun = function (self)
102
232
              self.view = GameView:new()
103
 
              --print(inspect(_(the.app):keys()))
104
233
              self.console:watch('onGround', 'the.player.onGround')
 
234
              self.console:watch('onWall', 'the.player.onWall')
105
235
           end,
106
236
   onUpdate = function (self, dt)
107
237
                 if the.keys:justPressed('escape') and 
108
238
                   not self.console.visible then
109
 
                    love.event.quit()
 
239
                    self.quit()
110
240
                 end
111
241
              end
112
242
}
 
 
b'\\ No newline at end of file'