/zoeplat : revision 7

2

DEBUG = true

3

4

require 'zoetrope'

5

__ = require 'underscore'

6

--inspect = require 'inspect'

7

require 'pepperprof'

8

9

util = {

10

dim = function(dir)

11

if dir == 'x' then

12

return 'width'

13

elseif dir == 'y' then

14

return 'height'

15

else

16

print 'dir ??'

17

end

18

end

19

}

20

21

Player = Animation:extend {

5

6

Player = Tile:extend {

22

7

image = 'data/player.png',

23

height = 32,

24

width = 32,

25

sequences = {

26

stand = { frames = { 1 }, fps = 1 },

27

walk = { frames = { 2, 3 }, fps = 5 },

28

jump = { frames = { 4 }, fps = 1 },

29

climbLeft = { frames = { 5, 6 }, fps = 5 },

30

climbRight = { frames = { 7, 8 }, fps = 5 }

31

},

32

collisions = {},

33

onWall = false,

34

leftWallAt = 0,

35

8

onNew = function (self)

36

9

self.velocity.y = 0

37

10

self.maxVelocity.y = 400

38

11

end,

39

doPhysics = function (self, dir, elapsed)

40

local vel = self.velocity

41

local acc = self.acceleration

42

local drag = self.drag

43

local minVel = self.minVelocity

44

local maxVel = self.maxVelocity

45

46

-- check existence of properties

47

48

if STRICT then

49

assert(vel, 'active sprite has no velocity property')

50

assert(acc, 'active sprite has no acceleration property')

51

assert(drag, 'active sprite has no drag property')

52

assert(minVel, 'active sprite has no minVelocity property')

53

assert(maxVel, 'active sprite has no maxVelocity property')

54

assert(__.include({'x','y','rotation'}, dir), 'direction should be x, y, or rotation')

55

end

56

57

vel.x = vel.x or 0

58

vel.y = vel.y or 0

59

vel.rotation = vel.rotation or 0

60

61

-- physics

62

63

if acc[dir] and acc[dir] ~= 0 then

64

vel[dir] = vel[dir] + acc[dir] * elapsed

65

else

66

if drag[dir] then

67

if vel[dir] > 0 then

68

vel[dir] = vel[dir] - drag[dir] * elapsed

69

if vel[dir] < 0 then vel[dir] = 0 end

70

elseif vel[dir] < 0 then

71

vel[dir] = vel[dir] + drag[dir] * elapsed

72

if vel[dir] > 0 then vel[dir] = 0 end

73

end

74

end

75

end

76

77

if minVel[dir] and vel[dir] < minVel[dir] then vel[dir] = minVel[dir] end

78

if maxVel[dir] and vel[dir] > maxVel[dir] then vel[dir] = maxVel[dir] end

79

80

if vel[dir] ~= 0 then self[dir] = self[dir] + vel[dir] * elapsed end

81

82

if self[dir] < 0 then self[dir] = 0 end

83

local edge = the.view.map[util.dim(dir)] -

84

the.player[util.dim(dir)]

85

-- TODO: take map position into account

86

if self[dir] > edge then self[dir] = edge end

87

end,

88

12

onStartFrame = function (self)

89

13

-- this is all in startframe so it happens before

90

14

-- physics calc at beginning of update

91

15

92

-- jumping/falling updates could go in EndFrame...

93

self.falling = self.velocity.y > 0

94

if self.falling then self.jumping = false end

95

--print(self.jumping, self.falling)

96

97

if (not self.onGround) and (not self.onWall) then

98

self:play('jump')

99

end

100

16

self.velocity.x = 0

101

17

self.acceleration.y = 800

102

18

103

if self.onWall then

104

self.acceleration.y = 0

105

106

if self.onWall == 'right' then

107

self:play('climbRight')

108

elseif self.onWall == 'left' then

109

self:play('climbLeft')

110

end

111

112

if the.keys:pressed('up') then

113

self.velocity.y = -200

114

elseif the.keys:pressed('down') then

115

self.velocity.y = 200

116

else

117

self.velocity.y = 0

118

self:freeze(self.sequences[self.currentName].frames[1])

119

end

120

end

121

122

19

if the.keys:pressed('left') then

123

20

self.velocity.x = -200

124

if self.onGround then self:play('walk') end

125

if self.onWall == 'right' then

126

self.onWall = false

127

self.leftWallAt = love.timer.getTime()

128

end

129

21

elseif the.keys:pressed('right') then

130

22

self.velocity.x = 200

131

if self.onGround then self:play('walk') end

132

if self.onWall == 'left' then

133

self.onWall = false

134

self.leftWallAt = love.timer.getTime()

135

end

136

else

137

if not self.onWall then

138

if self.onGround then self:play('stand') end

139

self.velocity.x = 0

140

end

141

23

end

142

24

143

if the.keys:justPressed('up') and

144

(self.onGround or the.console.visible or

145

(love.timer.getTime() - self.leftWallAt < .1) ) then

25

if the.keys:justPressed('up') then

146

26

self.velocity.y = -400

147

self.jumping = true

148

27

end

149

28

end,

150

update = function (self, elapsed)

151

-- NOTE: this is an override, not a callback

152

153

self:doPhysics('x', elapsed)

154

self:collide(the.view.map)

155

156

-- handle X collisions

157

self.onWall = false

158

for _, col in ipairs(self.collisions) do

159

col.other:displaceDir(self, 'x')

160

if self.velocity.x > 0 then

161

self.onWall = 'right'

162

elseif self.velocity.x < 0 then

163

self.onWall = 'left'

164

else

165

print 'x ??'

166

end

167

end

168

169

self.onGround = false -- right before Y collision callbacks

170

self:doPhysics('y', elapsed)

171

self:collide(the.view.map)

172

173

-- handle Y collisions

174

for _, col in ipairs(self.collisions) do

175

if self.velocity.y > 0 then

176

self.onGround = true

177

end

178

179

col.other:displaceDir(self, 'y')

180

self.velocity.y = 0

181

self.jumping = false

182

end

183

184

Animation.update(self, elapsed)

185

end,

186

collide = function (self, ...)

187

self.collisions = {}

188

Animation.collide(self, ...)

189

-- I could return a true/false value here if I wanted to...

190

end,

191

onCollide = function (self, other, xOverlap, yOverlap)

192

if other == the.view.map then return end

193

194

table.insert(self.collisions, {other = other,

195

xOverlap = xOverlap,

196

yOverlap = yOverlap })

197

end

29

onUpdate = function (self)

30

-- this is called after physics, so this makes sense here

31

the.view.map:subdisplace(self)

32

end

198

33

}

199

34

200

function Sprite:displaceDir(other, dir)

201

if not self.solid or self == other or not other.solid then return end

202

if STRICT then assert(other:instanceOf(Sprite), 'asked to displace a non-sprite') end

203

204

if other.sprites then

205

-- handle groups

206

207

for _, spr in pairs(other.sprites) do

208

self:displace(spr, dir)

209

end

210

else

211

-- handle sprites

212

local dim = util.dim(dir)

213

214

local negMove = (other[dir] - self[dir]) + other[dim]

215

local posMove = (self[dir] + self[dim]) - other[dir]

216

217

-- TODO: re-add hinting?

218

if negMove < posMove then

219

chg = - negMove

220

else

221

chg = posMove

222

end

223

end

224

225

other[dir] = other[dir] + chg

226

end

227

228

35

GameView = View:extend {

229

36

onNew = function (self)

230

37

self:loadLayers('data/map.lua')

231

38

self.focus = the.player

232

39

self:clampTo(self.map)

233

end,

234

onUpdate = function (self)

235

--print('tick')

236

--the.player:collide(self.map)

237

--self.map:collide(the.player)

238

end

40

end

239

41

}

240

42

241

43

the.app = App:new {

242

44

onRun = function (self)

243

45

self.view = GameView:new()

244

self.console:watch('onGround', 'the.player.onGround')

245

self.console:watch('onWall', 'the.player.onWall')

246

self.console:watch('updateTook', 'the.updateTook')

247

self.console:watch('drawTook', 'the.drawTook')

248

249

--the.profiler = newProfiler('time', 2000)

250

--the.profiler = newProfiler()

251

--the.profiler:start()

252

46

end,

253

47

onUpdate = function (self, dt)

254

48

if the.keys:justPressed('escape') then

255

if the.profiler then

256

the.profiler:stop()

257

local outfile = io.open( "profile.txt", "w+" )

258

the.profiler:report( outfile )

259

outfile:close()

260

end

261

262

self.quit()

49

love.event.quit()

263

50

end

264

end,

265

update = function (self, dt)

266

the.updateStart = love.timer.getMicroTime()

267

App.update(self, dt)

268

if the.updateStart then

269

the.updateTook = love.timer.getMicroTime() - the.updateStart

270

end

271

end

272

}

51

end

52

}

b'\\ No newline at end of file'