/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-05 22:06:58 UTC
  • Revision ID: josh@9ix.org-20130305220658-92yptjso9z57vzly
use zoetrope 288:a82a08660477 2013-02-23

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
5
 
8
 
Player = Animation:extend {
 
6
Player = Tile:extend {
9
7
   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
8
   onNew = function (self)
23
9
              self.velocity.y = 0
24
10
              self.maxVelocity.y = 400
25
11
           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
12
   onStartFrame = function (self)
70
13
                     -- this is all in startframe so it happens before
71
14
                     -- physics calc at beginning of update
72
15
 
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
 
 
 
16
                     self.velocity.x = 0
82
17
                     self.acceleration.y = 800
83
18
 
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
19
                     if the.keys:pressed('left') then
104
20
                        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
21
                     elseif the.keys:pressed('right') then
111
22
                        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
23
                     end
123
24
 
124
 
                     if the.keys:justPressed('up') and
125
 
                      (self.onGround or
126
 
                       (love.timer.getTime() - self.leftWallAt < .1) ) then
 
25
                     if the.keys:justPressed('up') then
127
26
                        self.velocity.y = -400
128
 
                        self.jumping = true
129
27
                     end
130
28
                  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
 
29
   onUpdate = function (self)
 
30
                 -- this is called after physics, so this makes sense here
 
31
                 the.view.map:subdisplace(self)
 
32
              end
179
33
}
180
34
 
181
 
function Sprite:displaceDir(other, dir)
182
 
   if not self.solid or self == other or not other.solid then return end
183
 
   if STRICT then assert(other:instanceOf(Sprite), 'asked to displace a non-sprite') end
184
 
 
185
 
   if other.sprites then
186
 
      -- handle groups
187
 
 
188
 
      for _, spr in pairs(other.sprites) do
189
 
         self:displace(spr, dir)
190
 
      end
191
 
   else
192
 
      -- handle sprites
193
 
      local dim
194
 
      if dir == 'x' then
195
 
         dim = 'width'
196
 
      elseif dir == 'y' then
197
 
         dim = 'height'
198
 
      else
199
 
         print 'dir ??'
200
 
      end
201
 
 
202
 
      local negMove = (other[dir] - self[dir]) + other[dim]
203
 
      local posMove = (self[dir] + self[dim]) - other[dir]
204
 
 
205
 
      -- TODO: re-add hinting?
206
 
      if negMove < posMove then
207
 
         chg = - negMove
208
 
      else
209
 
         chg = posMove
210
 
      end
211
 
   end
212
 
 
213
 
   other[dir] = other[dir] + chg
214
 
end
215
 
 
216
35
GameView = View:extend {
217
36
   onNew = function (self)
218
37
              self:loadLayers('data/map.lua')
219
38
              self.focus = the.player
220
39
              self:clampTo(self.map)
221
 
           end,
222
 
   onUpdate = function (self)
223
 
                 --print('tick')
224
 
                 --the.player:collide(self.map)
225
 
                 --self.map:collide(the.player)
226
 
              end
 
40
           end
227
41
}
228
42
 
229
43
the.app = App:new {
230
44
   onRun = function (self)
231
45
              self.view = GameView:new()
232
 
              self.console:watch('onGround', 'the.player.onGround')
233
 
              self.console:watch('onWall', 'the.player.onWall')
234
46
           end,
235
47
   onUpdate = function (self, dt)
236
 
                 if the.keys:justPressed('escape') and 
237
 
                   not self.console.visible then
238
 
                    self.quit()
 
48
                 if the.keys:justPressed('escape') then
 
49
                    love.event.quit()
239
50
                 end
240
51
              end
241
52
}
 
 
b'\\ No newline at end of file'