383 lines
9.2 KiB
Lua
383 lines
9.2 KiB
Lua
Player = class(Entity, {
|
|
type = "Player",
|
|
display = Animation:new(animation.nancy.idle),
|
|
})
|
|
|
|
function Player:new(x,y)
|
|
local o = Entity:new(x,y)
|
|
|
|
-- physics
|
|
o.zero_speed = 0.01 -- gameworld pixels
|
|
|
|
o.move_x = 0 -- gameworld pixels
|
|
o.move_speed = 1.3 -- gameworld pixels
|
|
|
|
o.nodrift_frames = 0 -- frames
|
|
|
|
o.air_friction = 0.01 -- gameworld pixels
|
|
o.ground_friction = 0.3 -- gameworld pixels
|
|
o.wall_friction = 0.3 -- gameworld pixels
|
|
|
|
o.jump_impulse = 3.5 -- gameworld pixels
|
|
|
|
o.coyote_value = 5 -- frames
|
|
o.coyote_amount = 5 -- int
|
|
|
|
|
|
-- dash values
|
|
o.dash_timer = 0 -- seconds
|
|
o.dash_time = 0.15 -- seconds
|
|
o.dash_distance = 40 -- gameworld pixels
|
|
o.dash_speed = o.dash_distance / (o.dash_time*60) -- pixels
|
|
o.dash_count = 1 -- int
|
|
o.dash_amount = 10 -- int
|
|
o.dash_cooldown_time = 0.1 -- seconds
|
|
o.dash_cooldown_timer = 0 -- seconds
|
|
|
|
-- hook values
|
|
o.hook_swing_speed = math.rad(0.05)
|
|
o.hook_anchor = nil
|
|
|
|
-- walljump values
|
|
o.walljump_nodrift_amount = 12
|
|
o.walljump_impulse = { x = 2.5, y = 3.5 }
|
|
|
|
-- status
|
|
o.can_jump = true
|
|
o.can_fall = true
|
|
o.can_friction = true
|
|
o.can_hook = true
|
|
o.can_walljump = true
|
|
|
|
o.is_dashing = false
|
|
o.is_hooked = false
|
|
o.is_sliding = false
|
|
o.is_jumping = false
|
|
o.is_on_ground = false
|
|
o.is_on_ladder = false
|
|
|
|
o.mask_type = animation.moth_mask
|
|
o.wall_hit = 0
|
|
|
|
o.respawn_anchor = {
|
|
x = o.pos.x,
|
|
y = o.pos.y
|
|
}
|
|
|
|
-- sprite
|
|
o.target_offset = {x = 0, y = 0}
|
|
o.body = Animation:new(animation.nancy.idle)
|
|
o.mask = Animation:new(animation.moth_mask.idle)
|
|
|
|
o:centerOffset(o.body)
|
|
o:createBox(o.body,0,4,-1,-5)
|
|
|
|
-- lights
|
|
local light_data = {}
|
|
light_data.radius = 40
|
|
light_data.shine_radius = 20
|
|
light_data.flicker = nil
|
|
light_data.color = nil
|
|
o.light = Light:new(o.pos.x,o.pos.y,light_data)
|
|
|
|
o:id()
|
|
|
|
setmetatable(o, self)
|
|
self.__index = self
|
|
return o
|
|
end
|
|
|
|
function Player:doLogic()
|
|
|
|
-- reset coyote_value
|
|
if self.is_on_ground then
|
|
self.coyote_value = self.coyote_amount
|
|
elseif self.coyote_value > 0 then
|
|
self.coyote_value = self.coyote_value - 1
|
|
end
|
|
|
|
-- not dashing, normal movment
|
|
if self.dash_timer <= 0 then
|
|
-- horizontal movement
|
|
if not self.is_hooked then
|
|
if self.nodrift_frames > 0 then
|
|
self.move_x = 0
|
|
elseif Keybind:checkDown(Keybind.move.left) then
|
|
self.move_x = -1
|
|
self.vel.x = math.min(self.vel.x, -self.move_speed)
|
|
elseif Keybind:checkDown(Keybind.move.right) then
|
|
self.move_x = 1
|
|
self.vel.x = math.max(self.vel.x, self.move_speed)
|
|
end
|
|
end
|
|
|
|
-- jump if on ground (coyotevalue) or if 0
|
|
if self.can_jump and Keybind:checkPressed(Keybind.move.jump) then
|
|
if self.can_walljump and self.wall_hit ~= 0 then
|
|
self.is_sliding = false
|
|
self.vel.y = -self.walljump_impulse.y
|
|
self.vel.x = -self.walljump_impulse.x * self.wall_hit
|
|
self.move_x = 0
|
|
self.sprite_flip.x = -self.sprite_flip.x
|
|
self.nodrift_frames = self.walljump_nodrift_amount
|
|
elseif self.coyote_value > 0 then
|
|
self.vel.y = -self.jump_impulse
|
|
self.coyote_value = 0
|
|
end
|
|
end
|
|
end
|
|
|
|
-- dash timer
|
|
self.dash_cooldown_timer = math.max(0,self.dash_cooldown_timer - current_dt)
|
|
|
|
-- try to dash
|
|
if Keybind:checkDown(Keybind.move.dash) then
|
|
if self.dash_cooldown_timer == 0
|
|
and not self.is_dashing
|
|
and self.dash_count > 0 then
|
|
|
|
self:unhook()
|
|
self.nodrift_frames = 0
|
|
|
|
-- state player
|
|
self.is_dashing = true
|
|
self.is_sliding = false
|
|
self.dash_count = self.dash_count - 1
|
|
|
|
-- get dash direction
|
|
local vertical = 0
|
|
if Keybind:checkDown(Keybind.move.down) then vertical = vertical + 1 end
|
|
if Keybind:checkDown(Keybind.move.up) then vertical = vertical - 1 end
|
|
local horizontal = 0
|
|
if Keybind:checkDown(Keybind.move.right) then horizontal = horizontal + 1 end
|
|
if Keybind:checkDown(Keybind.move.left) then horizontal = horizontal - 1 end
|
|
|
|
-- if no direction, then dash forward
|
|
if horizontal == 0 and vertical == 0 then
|
|
horizontal = self.sprite_flip.x
|
|
end
|
|
|
|
-- set dash values
|
|
self.dashDirection = getAngleFromVector(vector(horizontal, vertical))
|
|
self.dash_timer = math.floor(self.dash_time * game.framerate)
|
|
end
|
|
else
|
|
-- not dashing!
|
|
self.is_dashing = false
|
|
end
|
|
|
|
if self.can_hook and Keybind:checkPressed(Keybind.move.hook) then
|
|
if self.is_hooked then
|
|
self:unhook()
|
|
else
|
|
local anchor = self:checkNearest("HookAnchor","hook_specific")
|
|
if anchor then
|
|
self.is_hooked = true
|
|
self.hook_distance = anchor.hook_distance
|
|
self.hook_anchor = {
|
|
x = anchor.pos.x,
|
|
y = anchor.pos.y
|
|
}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function Player:doPhysics()
|
|
if self.dash_timer <= 0 then
|
|
if self.is_on_ground then
|
|
self.vel.x = self.vel.x * (1-self.ground_friction)
|
|
else
|
|
self.vel.x = self.vel.x * (1-self.air_friction)
|
|
end
|
|
|
|
self.is_sliding = false
|
|
if self.wall_hit == 0 then
|
|
self.vel.y = self.vel.y * (1-self.air_friction)
|
|
elseif self.nodrift_frames ~= self.walljump_nodrift_amount then
|
|
self.is_sliding = true
|
|
self.vel.y = self.vel.y * (1-self.wall_friction)
|
|
end
|
|
|
|
if math.abs(self.vel.x) < self.zero_speed then self.vel.x = 0 end
|
|
end
|
|
|
|
-- reset state
|
|
self.can_fall = true
|
|
self.is_on_ground = false
|
|
|
|
-- adjust timers
|
|
self.dash_timer = self.dash_timer - 1
|
|
self.nodrift_frames = self.nodrift_frames - 1
|
|
|
|
-- DASH STATE
|
|
if self.dash_timer > 0 then
|
|
self.can_fall = false
|
|
-- dash particle
|
|
local particle_data = {
|
|
animation = self.body,
|
|
animation_speed = 0,
|
|
sprite_tint = hex2rgb("#fed100"),
|
|
sprite_alpha = 0.5,
|
|
time = 0.2,
|
|
sprite_flip = {
|
|
x = self.sprite_flip.x,
|
|
y = self.sprite_flip.y
|
|
}
|
|
}
|
|
Particle:new(self.pos.x,self.pos.y,particle_data)
|
|
self.dash_cooldown_timer = self.dash_cooldown_time
|
|
-- dash movement
|
|
self.vel.x = self.dash_speed * math.cos(self.dashDirection)
|
|
self.vel.y = self.dash_speed * math.sin(self.dashDirection)
|
|
end
|
|
|
|
-- hook state
|
|
if self.is_hooked then
|
|
self.move_x = 0
|
|
local hook = vector(self.hook_anchor.x - self.pos.x, self.hook_anchor.y - self.pos.y)
|
|
local dist = math.min(getVectorValue(hook), self.hook_distance)
|
|
|
|
local hook_angle = getAngleFromVector(hook)-math.rad(180)
|
|
|
|
if Keybind:checkDown(Keybind.move.right) then
|
|
hook_angle = hook_angle - self.hook_swing_speed
|
|
end
|
|
|
|
if Keybind:checkDown(Keybind.move.left) then
|
|
hook_angle = hook_angle + self.hook_swing_speed
|
|
|
|
end
|
|
|
|
local particle_data = {
|
|
animation = self.body,
|
|
animation_speed = 0,
|
|
sprite_tint = hex2rgb("#fed100"),
|
|
sprite_alpha = 0.5,
|
|
time = 4,
|
|
time_unit = "frames",
|
|
sprite_flip = {
|
|
x = self.sprite_flip.x,
|
|
y = self.sprite_flip.y
|
|
}
|
|
}
|
|
Particle:new(self.pos.x,self.pos.y,particle_data)
|
|
|
|
local pos_x = self.hook_anchor.x + dist * math.cos(hook_angle)
|
|
local pos_y = self.hook_anchor.y + dist * math.sin(hook_angle)
|
|
self.vel.x = self.vel.x + pos_x - self.pos.x
|
|
self.vel.y = self.vel.y + pos_y - self.pos.y
|
|
|
|
self:moveX(
|
|
pos_x - self.pos.x
|
|
)
|
|
self:moveY(
|
|
pos_y - self.pos.y
|
|
)
|
|
end
|
|
|
|
|
|
if self.can_fall then
|
|
-- not in dash
|
|
self.dash_timer = 0
|
|
self.vel.y = self.vel.y + gravity
|
|
end
|
|
|
|
-- horizontal collision
|
|
self.wall_hit = 0
|
|
self:moveX(
|
|
self.vel.x,
|
|
function()
|
|
self.wall_hit = math.sign(self.vel.x)
|
|
self.vel.x = 0
|
|
end
|
|
)
|
|
|
|
-- vertical collision
|
|
self:moveY(
|
|
self.vel.y,
|
|
function()
|
|
if self.vel.y > 0 then
|
|
self.is_on_ground = true
|
|
self.dash_count = self.dash_amount
|
|
end
|
|
self.vel.y = 0
|
|
end
|
|
)
|
|
|
|
-- if u collision w hazard, respawn
|
|
if self:isCollidingAt(self.pos.x, self.pos.y, LoadedObjects.Hazards) then
|
|
self:respawn()
|
|
end
|
|
|
|
self:adjustLight(self.target_offset.x,self.target_offset.y)
|
|
end
|
|
|
|
function Player:respawn()
|
|
self.pos.x = self.respawn_anchor.x
|
|
self.pos.y = self.respawn_anchor.y
|
|
end
|
|
|
|
function Player:handleAnimation()
|
|
-- flip sprite to look in the direction is moving
|
|
if self.is_hooked then
|
|
if self.vel.x ~= 0 then
|
|
self.sprite_flip.x = math.sign(self.vel.x)
|
|
end
|
|
elseif self.move_x ~= 0 then
|
|
self.sprite_flip.x = math.sign(self.move_x)
|
|
end
|
|
-- animation priority
|
|
if self.is_sliding then
|
|
self.body = self.body:change(animation.nancy.slide)
|
|
self.mask = self.mask:change(self.mask_type.slide)
|
|
elseif self.vel.y > 1.25 then
|
|
self.body = self.body:change(animation.nancy.fall)
|
|
self.mask = self.mask:change(self.mask_type.fall)
|
|
elseif self.vel.y < 0 then
|
|
self.body = self.body:change(animation.nancy.jump)
|
|
self.mask = self.mask:change(self.mask_type.jump)
|
|
elseif self.vel.x + self.move_x ~= 0 and not self.is_hooked then
|
|
self.body = self.body:change(animation.nancy.run)
|
|
self.mask = self.mask:change(self.mask_type.run)
|
|
elseif not self.is_hooked then
|
|
self.body = self.body:change(animation.nancy.idle)
|
|
self.mask = self.mask:change(self.mask_type.idle)
|
|
end
|
|
|
|
-- special case: idle animation gets slower by time
|
|
if self.body.anim_path == animation.nancy.idle.path then
|
|
if self.body.anim_speed < 0.5 then
|
|
self.body.anim_speed = self.body.anim_speed + 0.001
|
|
end
|
|
end
|
|
|
|
if self.is_hooked then
|
|
love.graphics.line(
|
|
-Camera.pos.x + self.pos.x,
|
|
-Camera.pos.y + self.pos.y,
|
|
-Camera.pos.x + self.hook_anchor.x,
|
|
-Camera.pos.y + self.hook_anchor.y
|
|
)
|
|
end
|
|
|
|
self.body:animate()
|
|
self:draw(self.body)
|
|
|
|
if self.dash_count > 0 then
|
|
self:draw(self.mask)
|
|
end
|
|
self.move_x = 0
|
|
end
|
|
|
|
function Player:unhook()
|
|
self.is_hooked = false
|
|
self.hook_anchor = nil
|
|
self.hook_distance = nil
|
|
end
|
|
|
|
function Player:debug()
|
|
Entity.debug(self)
|
|
love.graphics.print("wall_hit: "..self.wall_hit)
|
|
end
|