/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-04-11 02:07:08 UTC
  • Revision ID: josh@9ix.org-20130411020708-psrxtdnm8xe4pz7d
text balloon system

Show diffs side-by-side

added added

removed removed

Lines of Context:
7
7
require 'pepperprof'
8
8
require 'getopt_alt'
9
9
 
 
10
require 'sprite'
 
11
require 'animation'
 
12
require 'player'
 
13
require 'balloon'
 
14
 
10
15
util = {
11
16
   dim = function(dir)
12
17
      if dir == 'x' then
19
24
   end
20
25
}
21
26
 
22
 
Player = Animation:extend {
23
 
   image = 'data/player.png',
24
 
   height = 32,
25
 
   width = 32,
26
 
   sequences = {
27
 
      stand = { frames = { 1 }, fps = 1 },
28
 
      walk = { frames = { 2, 3 }, fps = 5 },
29
 
      jump = { frames = { 4 }, fps = 1 },
30
 
      climbLeft = { frames = { 5, 6 }, fps = 5 },
31
 
      climbRight = { frames = { 7, 8 }, fps = 5 }
32
 
   },
33
 
   collisions = {},
34
 
   onWall = false,
35
 
   leftWallAt = 0,
36
 
   onNew = function (self)
37
 
              self.velocity.y = 0
38
 
              self.maxVelocity.y = 400
39
 
           end,
40
 
   doPhysics = function (self, dir, elapsed)
41
 
                  local vel = self.velocity
42
 
                  local acc = self.acceleration
43
 
                  local drag = self.drag
44
 
                  local minVel = self.minVelocity
45
 
                  local maxVel = self.maxVelocity
46
 
 
47
 
                  -- check existence of properties
48
 
 
49
 
                  if STRICT then
50
 
                     assert(vel, 'active sprite has no velocity property')
51
 
                     assert(acc, 'active sprite has no acceleration property')
52
 
                     assert(drag, 'active sprite has no drag property')
53
 
                     assert(minVel, 'active sprite has no minVelocity property')
54
 
                     assert(maxVel, 'active sprite has no maxVelocity property')
55
 
                     assert(__.include({'x','y','rotation'}, dir), 'direction should be x, y, or rotation')
56
 
                  end
57
 
 
58
 
                  vel.x = vel.x or 0
59
 
                  vel.y = vel.y or 0
60
 
                  vel.rotation = vel.rotation or 0
61
 
 
62
 
                  -- physics
63
 
 
64
 
                  if acc[dir] and acc[dir] ~= 0 then
65
 
                     vel[dir] = vel[dir] + acc[dir] * elapsed
66
 
                  else
67
 
                     if drag[dir] then
68
 
                        if vel[dir] > 0 then
69
 
                           vel[dir] = vel[dir] - drag[dir] * elapsed
70
 
                           if vel[dir] < 0 then vel[dir] = 0 end
71
 
                        elseif vel[dir] < 0 then
72
 
                           vel[dir] = vel[dir] + drag[dir] * elapsed
73
 
                           if vel[dir] > 0 then vel[dir] = 0 end
74
 
                        end
75
 
                     end
76
 
                  end
77
 
 
78
 
                  if minVel[dir] and vel[dir] < minVel[dir] then vel[dir] = minVel[dir] end
79
 
                  if maxVel[dir] and vel[dir] > maxVel[dir] then vel[dir] = maxVel[dir] end
80
 
 
81
 
                  -- ugly hack for falling through floor on really slow frames
82
 
                  if math.abs(vel[dir] * elapsed) > 32 then
83
 
                     print('skip')
84
 
                     return
85
 
                  end
86
 
 
87
 
                  if vel[dir] ~= 0 then self[dir] = self[dir] + vel[dir] * elapsed end
88
 
 
89
 
                  if self[dir] < 0 then self[dir] = 0 end
90
 
                  local edge = the.view.map[util.dim(dir)] -
91
 
                               the.player[util.dim(dir)]
92
 
                  -- TODO: take map position into account
93
 
                  if self[dir] > edge then self[dir] = edge end
94
 
               end,
95
 
   onStartFrame = function (self)
96
 
                     -- this is all in startframe so it happens before
97
 
                     -- physics calc at beginning of update
98
 
 
99
 
                     -- jumping/falling updates could go in EndFrame...
100
 
                     self.falling = self.velocity.y > 0
101
 
                     if self.falling then self.jumping = false end
102
 
                     --print(self.jumping, self.falling)
103
 
 
104
 
                     if (not self.onGround) and (not self.onWall) then
105
 
                        self:play('jump')
106
 
                     end
107
 
 
108
 
                     self.acceleration.y = 800
109
 
 
110
 
                     if self.onWall then
111
 
                        self.acceleration.y = 0
112
 
 
113
 
                        if self.onWall == 'right' then
114
 
                           self:play('climbRight')
115
 
                        elseif self.onWall == 'left' then
116
 
                           self:play('climbLeft')
117
 
                        end
118
 
 
119
 
                        if the.keys:pressed('up') then
120
 
                           self.velocity.y = -200
121
 
                        elseif the.keys:pressed('down') then
122
 
                           self.velocity.y = 200
123
 
                        else
124
 
                           self.velocity.y = 0
125
 
                           self:freeze(self.sequences[self.currentName].frames[1])
126
 
                        end
127
 
                     end
128
 
 
129
 
                     if the.keys:pressed('left') then
130
 
                        self.velocity.x = -200
131
 
                        if self.onGround then self:play('walk') end
132
 
                        if self.onWall == 'right' then
133
 
                           self.onWall = false
134
 
                           self.leftWallAt = love.timer.getTime()
135
 
                        end
136
 
                     elseif the.keys:pressed('right') then
137
 
                        self.velocity.x = 200
138
 
                        if self.onGround then self:play('walk') end
139
 
                        if self.onWall == 'left' then
140
 
                           self.onWall = false
141
 
                           self.leftWallAt = love.timer.getTime()
142
 
                        end
143
 
                     else
144
 
                        if not self.onWall then
145
 
                           if self.onGround then self:play('stand') end
146
 
                           self.velocity.x = 0
147
 
                        end
148
 
                     end
149
 
 
150
 
                     if the.keys:justPressed('up') and
151
 
                      (self.onGround or the.console.visible or
152
 
                       (love.timer.getTime() - self.leftWallAt < .1) ) then
153
 
                        self.velocity.y = -400
154
 
                        self.jumping = true
155
 
                     end
156
 
                  end,
157
 
   update = function (self, elapsed)
158
 
               -- NOTE: this is an override, not a callback
159
 
 
160
 
               self:doPhysics('x', elapsed)
161
 
               self:collide(the.view.map)
162
 
 
163
 
               -- handle X collisions
164
 
               self.onWall = false
165
 
               for _, col in ipairs(self.collisions) do
166
 
                  col.other:displaceDir(self, 'x')
167
 
                  if self.velocity.x > 0 then
168
 
                     self.onWall = 'right'
169
 
                  elseif self.velocity.x < 0 then
170
 
                     self.onWall = 'left'
171
 
                  else
172
 
                     print 'x ??'
173
 
                  end
174
 
               end
175
 
 
176
 
               self.onGround = false -- right before Y collision callbacks
177
 
               self:doPhysics('y', elapsed)
178
 
               self:collide(the.view.map)
179
 
 
180
 
               -- handle Y collisions
181
 
               for _, col in ipairs(self.collisions) do
182
 
                  if self.velocity.y > 0 then
183
 
                     self.onGround = true
184
 
                  end
185
 
 
186
 
                  col.other:displaceDir(self, 'y')
187
 
                  self.velocity.y = 0
188
 
                  self.jumping = false
189
 
               end
190
 
 
191
 
               -- text blob
192
 
               if not self.text then
193
 
                  self.text = Text:new{wordWrap = true, width = 50, tint = {0,0,0}}
194
 
                  self.textfill = Fill:new{width = 54, border = {0,0,255}}
195
 
                  --the.view:add(self.textfill)
196
 
                  --the.view:add(self.text)
197
 
               end
198
 
               self.text.text = "Blah blah big text etc etc wrapping"
199
 
               self.text:centerAround(self.x+16, self.y+16, 'horizontal')
200
 
               _, texth = self.text:getSize()
201
 
               self.text.y = self.y - texth - 4
202
 
               self.textfill.x = self.text.x - 2
203
 
               self.textfill.y = self.text.y - 2
204
 
               self.textfill.height = texth + 4
205
 
 
206
 
               Animation.update(self, elapsed)
207
 
            end,
208
 
   collide = function (self, ...)
209
 
                self.collisions = {}
210
 
                Animation.collide(self, ...)
211
 
                -- I could return a true/false value here if I wanted to...
212
 
             end,
213
 
   onCollide = function (self, other, xOverlap, yOverlap)
214
 
                  if other == the.view.map then return end
215
 
 
216
 
                  table.insert(self.collisions, {other = other,
217
 
                                                 xOverlap = xOverlap,
218
 
                                                 yOverlap = yOverlap })
219
 
               end
220
 
}
221
 
 
222
 
function Sprite:displaceDir(other, dir)
223
 
   if not self.solid or self == other or not other.solid then return end
224
 
   if STRICT then assert(other:instanceOf(Sprite), 'asked to displace a non-sprite') end
225
 
 
226
 
   if other.sprites then
227
 
      -- handle groups
228
 
 
229
 
      for _, spr in pairs(other.sprites) do
230
 
         self:displace(spr, dir)
231
 
      end
232
 
   else
233
 
      -- handle sprites
234
 
      local dim = util.dim(dir)
235
 
 
236
 
      local negMove = (other[dir] - self[dir]) + other[dim]
237
 
      local posMove = (self[dir] + self[dim]) - other[dir]
238
 
 
239
 
      -- TODO: re-add hinting?
240
 
      if negMove < posMove then
241
 
         chg = - negMove
242
 
      else
243
 
         chg = posMove
244
 
      end
245
 
   end
246
 
 
247
 
   other[dir] = other[dir] + chg
248
 
end
249
 
 
250
 
function Sprite:update (elapsed)
251
 
   if self.onUpdate then self:onUpdate(elapsed) end
252
 
end
253
 
 
254
27
GameView = View:extend {
255
28
   onNew = function (self)
256
29
              self:loadLayers('data/map.lua')
288
59
   record = true,
289
60
   onRun = function (self)
290
61
              self.view = GameView:new()
291
 
              self.console:watch('onGround', 'the.player.onGround')
292
 
              self.console:watch('onWall', 'the.player.onWall')
293
 
              self.console:watch('updateTook', 'the.updateTook')
294
 
              self.console:watch('drawTook', 'the.drawTook')
295
 
              self.console:watch('recorder state', 'the.recorder.state')
 
62
              if DEBUG then
 
63
                 self.console:watch('onGround', 'the.player.onGround')
 
64
                 self.console:watch('onWall', 'the.player.onWall')
 
65
                 self.console:watch('updateTook', 'the.updateTook')
 
66
                 self.console:watch('drawTook', 'the.drawTook')
 
67
                 self.console:watch('recorder state', 'the.recorder.state')
 
68
              end
296
69
 
297
70
              --the.profiler = newProfiler('time', 2000)
298
71
              --the.profiler = newProfiler()