/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:
2
2
DEBUG = true
3
3
 
4
4
require 'zoetrope'
5
 
 
6
 
TERM_VEL = 400
7
 
 
8
 
Player = Tile:extend {
 
5
__ = require 'underscore'
 
6
--inspect = require 'inspect'
 
7
 
 
8
Player = Animation:extend {
9
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,
10
22
   onNew = function (self)
11
23
              self.velocity.y = 0
 
24
              self.maxVelocity.y = 400
12
25
           end,
13
 
   onUpdate = function (self)
14
 
 
15
 
                 self.velocity.x = 0
16
 
                 if self.velocity.y >= TERM_VEL then
17
 
                    self.velocity.y = TERM_VEL
18
 
                    self.acceleration.y = 0
19
 
                 else
20
 
                    self.acceleration.y = 800
21
 
                 end
22
 
 
23
 
                 if the.keys:pressed('left') then
24
 
                    self.velocity.x = -200
25
 
                 elseif the.keys:pressed('right') then
26
 
                    self.velocity.x = 200
27
 
                 end
28
 
 
29
 
                 if the.keys:justPressed('up') then
30
 
                    self.velocity.y = -400
31
 
                 end
32
 
 
33
 
              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
34
179
}
35
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
 
36
217
GameView = View:extend {
37
218
   onNew = function (self)
38
219
              self:loadLayers('data/map.lua')
39
220
              self.focus = the.player
40
221
              self:clampTo(self.map)
41
222
           end,
42
 
 
43
 
   onEndFrame = function (self, dt)
44
 
                   self.map:subdisplace(the.player)
45
 
                end
 
223
   onUpdate = function (self)
 
224
                 --print('tick')
 
225
                 --the.player:collide(self.map)
 
226
                 --self.map:collide(the.player)
 
227
              end
46
228
}
47
229
 
48
230
the.app = App:new {
49
231
   onRun = function (self)
50
232
              self.view = GameView:new()
 
233
              self.console:watch('onGround', 'the.player.onGround')
 
234
              self.console:watch('onWall', 'the.player.onWall')
51
235
           end,
52
236
   onUpdate = function (self, dt)
53
 
                 if the.keys:justPressed('escape') then
54
 
                    love.event.quit()
 
237
                 if the.keys:justPressed('escape') and 
 
238
                   not self.console.visible then
 
239
                    self.quit()
55
240
                 end
56
241
              end
57
242
}
 
 
b'\\ No newline at end of file'