path: root/not/Hero.lua

--- `Hero`
-- Hero (naut) entity that exists in a game world.
-- Collision category: [2]
Hero = {
	-- General and physics
	name = "empty",
	angle = 0,
	facing = 1,
	max_velocity = 105,
	world = --[[not.World]]nil,
	group = nil,
	-- Combat
	combo = 0,
	lives = 3,
	spawntimer = 2,
	alive = true,
	punchCooldown = 0.25,
	punchdir = 0, -- a really bad thing
	-- Movement
	inAir = true,
	salto = false,
	isJumping = false,
	jumpTimer = 0.16,
	jumpCounter = 2,
	-- Keys
	controlset = nil,
	-- Statics
	portrait_sprite = nil,
	portrait_frame  = nil,
	portrait_sheet  = require "nautsicons",
	portrait_box    = love.graphics.newQuad( 0, 15, 32,32, 80,130),
	sfx = require "sounds",
}

-- `Hero` is a child of `PhysicalBody`.
require "not.PhysicalBody"
Hero.__index = Hero
setmetatable(Hero, PhysicalBody)

-- Constructor of `Hero`.
function Hero:new (game, world, x, y, name)
	local o = setmetatable({}, self)
	o:init(name, game, x, y)
	-- Load portraits statically.
	if self.portrait_sprite == nil then
		self.portrait_sprite = love.graphics.newImage("assets/portraits.png")
		self.portrait_frame = love.graphics.newImage("assets/menu.png")
	end
	return o
end

-- Initializer of `Hero`.
function Hero:init (name, world, x, y)
	-- Find imagePath based on hero name.
	local fileName = name or Hero.name -- INITIAL from metatable
	local imagePath = string.format("assets/nauts/%s.png", fileName)
	-- `PhysicalBody` initialization.
	PhysicalBody.init(self, world, x, y, imagePath)
	self:setBodyType("dynamic")
	self:setBodyFixedRotation(true)
	self.group = -1-#world.Nauts
	-- Main fixture initialization.
	local fixture = self:addFixture({-5,-8, 5,-8, 5,8, -5,8}, 8)
	fixture:setUserData(self)
	fixture:setCategory(2)
	fixture:setMask(2)
	fixture:setGroupIndex(self.group)
	-- Actual `Hero` initialization.
	self.world = world
	self.punchCooldown = 0
	self.name = name
	self:setAnimationsList(require("animations"))
	self:createEffect("respawn")
end

-- Control set managment
-- TODO: move these two to `not.Player`.
function Hero:assignControlSet (set)
	self.controlset = set
end
function Hero:getControlSet ()
	return self.controlset
end

-- Update callback of `Hero`
-- TODO: Explode this function (method, kek), move controler-related parts to `not.Player`, physics parts to `not.PhysicalBody`.
function Hero:update (dt)
	PhysicalBody.update(self, dt)
	-- locals
	local x, y = self:getLinearVelocity()
	local isDown = Controller.isDown
	local controlset = self:getControlSet()
	
	-- # VERTICAL MOVEMENT
	-- Jumping
	if self.isJumping and self.jumpTimer > 0 then
		self:setLinearVelocity(x,-160)
		self.jumpTimer = self.jumpTimer - dt
	end

	-- Salto
	if self.salto and (self.current == self.animations.walk or self.current == self.animations.default) then
		self.angle = (self.angle + 17 * dt * self.facing) % 360
	elseif self.angle ~= 0 then
		self.angle = 0
	end

	-- # HORIZONTAL MOVEMENT
	-- Walking
	if isDown(controlset, "left") then
		self.facing = -1
		self:applyForce(-250, 0)
		-- Controlled speed limit
		if x < -self.max_velocity then
			self:applyForce(250, 0)
		end
	end
	if isDown(controlset, "right") then
		self.facing = 1
		self:applyForce(250, 0)
		-- Controlled speed limit
		if x > self.max_velocity then
			self:applyForce(-250, 0)
		end
	end

	-- Custom linear damping
	if not isDown(controlset, "left") and
	   not isDown(controlset, "right")
	then
		local face = nil
		if x < -12 then
			face = 1
		elseif x > 12 then
			face = -1
		else
			face = 0
		end
		self:applyForce(40*face,0)
		if not self.inAir then
			self:applyForce(80*face,0)
		end
	end

	-- # DEATH
	-- We all die in the end.
	local m = self.world.map
	if (self.body:getX() < m.center_x - m.width*1.5 or self.body:getX() > m.center_x + m.width*1.5  or
	    self.body:getY() < m.center_y - m.height*1.5 or self.body:getY() > m.center_y + m.height*1.5) and
	    self.alive
	then
		self:die()
	end

	-- respawn
	if self.spawntimer > 0 then
		self.spawntimer = self.spawntimer - dt
	end
	if self.spawntimer <= 0 and not self.alive and self.lives >= 0 then
		self:respawn()
	end

	-- # PUNCH
	-- Cooldown
	self.punchCooldown = self.punchCooldown - dt
	if not self.body:isDestroyed() then -- TODO: This is weird
		for _,fixture in pairs(self.body:getFixtureList()) do -- TODO: getFixtures from `PhysicalBody` or similar.
			if fixture:getUserData() ~= self then
				fixture:setUserData({fixture:getUserData()[1] - dt, fixture:getUserData()[2]})
				if fixture:getUserData()[1] < 0 then
					fixture:destroy()
				end
			end
		end
	end

	-- Stop vertical
	local c,a = self.current, self.animations
	if (c == a.attack_up or c == a.attack_down or c == a.attack) and self.frame < c.frames then
		if self.punchdir == 0 then
			self:setLinearVelocity(0,0)
		else
			self:setLinearVelocity(38*self.facing,0)
		end
	end

	if self.punchCooldown <= 0 and self.punchdir == 1 then
		self.punchdir = 0
	end
end

-- Controller callbacks
function Hero:controlpressed (set, action, key)
	if set ~= self:getControlSet() then return end
	local isDown = Controller.isDown
	local controlset = self:getControlSet()
	-- Jumping
	if action == "jump" then
		if self.jumpCounter > 0 then
			-- General jump logics
			self.isJumping = true
			--self:playSound(6)
			-- Spawn proper effect
			if not self.inAir then
				self:createEffect("jump")
			else
				self:createEffect("doublejump")
			end
			-- Start salto if last jump
			if self.jumpCounter == 1 then
				self.salto = true
			end
			-- Animation clear
			if (self.current == self.animations.attack) or
			   (self.current == self.animations.attack_up) or
			   (self.current == self.animations.attack_down) then
				self:setAnimation("default")
			end
			-- Remove jump
			self.jumpCounter = self.jumpCounter - 1
		end
	end

	-- Walking
	if (action == "left" or action == "right") and 
	   (self.current ~= self.animations.attack) and
	   (self.current ~= self.animations.attack_up) and
	   (self.current ~= self.animations.attack_down) then
		self:setAnimation("walk")
	end

	-- Punching
	if action == "attack" and self.punchCooldown <= 0 then
		local f = self.facing
		self.salto = false
		if isDown(controlset, "up") then
			-- Punch up
			if self.current ~= self.animations.damage then
				self:setAnimation("attack_up")
			end
			self:punch("up")
		elseif isDown(controlset, "down") then
			-- Punch down
			if self.current ~= self.animations.damage then
				self:setAnimation("attack_down")
			end
			self:punch("down")
		else
			-- Punch horizontal
			if self.current ~= self.animations.damage then
				self:setAnimation("attack")
			end
			if f == 1 then
				self:punch("right")
			else
				self:punch("left")
			end
			self.punchdir = 1
		end
	end
end
function Hero:controlreleased (set, action, key)
	if set ~= self:getControlSet() then return end
	local isDown = Controller.isDown
	local controlset = self:getControlSet()
	-- Jumping
	if action == "jump" then
		self.isJumping = false
		self.jumpTimer = Hero.jumpTimer -- take initial from metatable
	end
	-- Walking
	if (action == "left" or action == "right") and not
	   (isDown(controlset, "left") or isDown(controlset, "right")) and
	   self.current == self.animations.walk
	then
		self:setAnimation("default")
	end
end

-- TODO: comment them and place them somewhere properly
function Hero:getAngle ()
	return self.angle
end
function Hero:getHorizontalMirror ()
	return self.facing
end
function Hero:getOffset ()
	return 12,15 -- TODO: WHY? How about creating body as polygon and using 0,0 instead. LIKE EVERYWHERE ELSE? Make it obsolete both in here and in `not.Sprite`.
end

-- Draw of `Hero`
function Hero:draw (offset_x, offset_y, scale, debug)
	if not self.alive then return end
	PhysicalBody.draw(self, offset_x, offset_y, scale, debug)
end

-- Draw HUD of `Hero`
-- elevation: 1 bottom, 0 top
function Hero:drawHUD (x,y,scale,elevation)
	-- hud displays only if player is alive
	if self.alive then
		love.graphics.setColor(255,255,255,255)
		love.graphics.draw(self.portrait_frame, self.portrait_box, (x)*scale, (y)*scale, 0, scale, scale)
		love.graphics.draw(self.portrait_sprite, self.portrait_sheet[self.name], (x+2)*scale, (y+3)*scale, 0, scale, scale)
		local dy = 30 * elevation
		love.graphics.setFont(Font)
		love.graphics.print((self.combo*10).."%",(x+2)*scale,(y-3+dy)*scale,0,scale,scale)
		love.graphics.print(math.max(0, self.lives),(x+24)*scale,(y-3+dy)*scale,0,scale,scale)
	end
end

-- Change animation of `Hero`
-- default, walk, attack, attack_up, attack_down, damage
function Hero:goToNextFrame ()
	local isDown = Controller.isDown
	local controlset = self:getControlSet()
	if self.current.repeated or not (self.frame == self.current.frames) then
		self.frame = (self.frame % self.current.frames) + 1
	elseif isDown(controlset, "right") or isDown(controlset, "left") then
		-- If nonrepeatable animation is finished and player is walking
		self:setAnimation("walk")
	elseif self.current == self.animations.damage then
		self:setAnimation("default")
	end
end

-- Spawn `Effect` relative to `Hero`
function Hero:createEffect (name)
	if name == "trail" or name == "hit" then
		-- 16px effect: -7 -7
		self.world:createEffect(name, self.body:getX()-8, self.body:getY()-8)
	elseif name ~= nil then
		-- 24px effect: -12 -15
		self.world:createEffect(name, self.body:getX()-12, self.body:getY()-15)
	end
end

-- Creates temporary fixture for hero's body that acts as sensor.
-- direction:  ("left", "right", "up", "down")
-- Sensor fixture is deleted after time set in UserData[1]; deleted by `not.Hero.update`.
-- TODO: Magic numbers present in `not.Hero.punch`.
function Hero:punch (direction)
	self.punchCooldown = Hero.punchCooldown -- INITIAL from metatable
	-- Choose shape based on punch direction.
	local shape
	if direction == "left" then shape = {-2,-6, -20,-6, -20,6, -2,6} end
	if direction == "right" then shape = {2,-6, 20,-6, 20,6, 2,6} end
	if direction == "up" then shape = {-8,-4, -8,-20, 8,-20, 8,-4} end
	if direction == "down" then shape = {-8,4, -8,20, 8,20, 8,4} end
	-- Create and set sensor fixture.
	local fixture = self:addFixture(shape, 0)
	fixture:setSensor(true)
	fixture:setCategory(3)
	fixture:setMask(1,3)
	fixture:setGroupIndex(self.group)
	fixture:setUserData({0.08, direction})
	self:playSound(4)
end

-- Taking damage of `Hero` by successful hit test
-- currently called from World's startContact
-- TODO: attack functions needs to be renamed, because even I have problems understanding them.
function Hero:damage (direction)
	local horizontal, vertical = 0, 0
	if direction == "left" then
		horizontal = -1
	end
	if direction == "right" then
		horizontal = 1
	end
	if direction == "up" then
		vertical = -1
	end
	if direction == "down" then
		vertical = 1
	end
	self:createEffect("hit")
	local x,y = self:getLinearVelocity()
	self:setLinearVelocity(x,0)
	self:applyLinearImpulse((42+10*self.combo)*horizontal, (68+10*self.combo)*vertical + 15)
	self:setAnimation("damage")
	self.combo = math.min(99, self.combo + 1)
	self.punchCooldown = 0.08 + self.combo*0.006
	self:playSound(2)
end

-- DIE
function Hero:die ()
	self:playSound(1)
	self.combo = Hero.combo -- INITIAL from metatable
	self.lives = self.lives - 1
	self.alive = false
	self.spawntimer = Hero.spawntimer -- INITIAL from metatable
	self:setBodyActive(false)
	self.world:onNautKilled(self)
end

-- And then respawn. Like Jon Snow.
function Hero:respawn ()
	self.alive = true
	self:setLinearVelocity(0,0)
	self:setPosition(self.world:getSpawnPosition()) -- TODO: I'm not convinced about getting new position like this.
	self:setBodyActive(true)
	self:createEffect("respawn")
	self:playSound(7)
end

-- Sounds
-- TODO: Possibly export to nonexistent SoundEmitter class. Can be used by World (Stage), too.
function Hero:playSound (sfx, force)
	if self.alive or force then
		local source = love.audio.newSource(self.sfx[sfx])
		source:play()
	end
end