/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:11:55 UTC
  • Revision ID: josh@9ix.org-20130305221155-hva5q53evnqqfn58
build script to build .love file

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
29
   onCollide = function (self, other, xOverlap, yOverlap)
 
30
                  -- seriously, why does this even fire?
173
31
                  if other == the.view.map then return end
174
32
 
175
 
                  table.insert(self.collisions, {other = other,
176
 
                                                 xOverlap = xOverlap,
177
 
                                                 yOverlap = yOverlap })
 
33
                  --print(string.format('col s{x=%i y=%i w=%i h=%i} %s', self.x, self.y, self.width, self.height, tostring(other)))
 
34
                  --print('vel.x:'..self.velocity.x.." vel.y:"..self.velocity.y)
 
35
 
 
36
                  -- assumption: any other collision is with a solid map tile
 
37
                  if yOverlap > xOverlap then
 
38
                     other:displace(self)
 
39
                  elseif xOverlap > yOverlap then
 
40
                     -- check if we've moved since collisions were generated
 
41
                     local xov, yov = self:overlap(other.x, other.y,
 
42
                                                   other.width, other.height)
 
43
                     if xov ~= 0 and yov ~= 0 then
 
44
                        self.velocity.y = 0
 
45
                        other:displace(self)
 
46
                     end
 
47
                  else
 
48
                     print('??')
 
49
                  end
 
50
 
178
51
               end
179
52
}
180
53
 
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
54
GameView = View:extend {
217
55
   onNew = function (self)
218
56
              self:loadLayers('data/map.lua')
222
59
           end,
223
60
   onUpdate = function (self)
224
61
                 --print('tick')
225
 
                 --the.player:collide(self.map)
 
62
                 the.player:collide(self.map)
226
63
                 --self.map:collide(the.player)
227
64
              end
228
65
}
230
67
the.app = App:new {
231
68
   onRun = function (self)
232
69
              self.view = GameView:new()
233
 
              self.console:watch('onGround', 'the.player.onGround')
234
 
              self.console:watch('onWall', 'the.player.onWall')
235
70
           end,
236
71
   onUpdate = function (self, dt)
237
 
                 if the.keys:justPressed('escape') and 
238
 
                   not self.console.visible then
239
 
                    self.quit()
240
 
                 end
 
72
                 -- apparently I can do this w/ C-A-q if DEBUG is on
 
73
                 -- if the.keys:justPressed('escape') then
 
74
                 --    love.event.quit()
 
75
                 -- end
241
76
              end
242
77
}
 
 
b'\\ No newline at end of file'