/zoeplat : revision 34

19

end

20

}

21

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

22

GameView = View:extend {

255

23

onNew = function (self)

256

24

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