Player Script

-----------------------------------------------------------------------------
-- Services
-----------------------------------------------------------------------------
local RepStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

-----------------------------------------------------------------------------
-- Modules
-----------------------------------------------------------------------------
local Packages = RepStorage.Packages
local Knit = require(Packages.Knit)
local BaseCharacter = require(Knit.Modules.BaseCharacter)
local ControlsClass = require(Knit.Modules.Controls)

-----------------------------------------------------------------------------
-- Constants
-----------------------------------------------------------------------------
local ZERO_VECTOR3 = Vector3.new(0,0,0)

-----------------------------------------------------------------------------
-- Variables
-----------------------------------------------------------------------------
local localPlayer = Players.LocalPlayer

local PlayerClass = setmetatable({},BaseCharacter)
PlayerClass.__index = PlayerClass

function PlayerClass.new()
    print("PlayerClass.new()")
    local self = setmetatable(BaseCharacter.new(),PlayerClass)

    self.controls = ControlsClass.new(self)
    self.moveFunction = localPlayer.Move
    self.moveVectorIsCameraRelative = true

    localPlayer.CharacterAdded:Connect(function(character)
        self:OnCharacterAdded(character)
    end)

    localPlayer.CharacterRemoving:Connect(function(character)
        self:OnCharacterRemoving(character)
    end)

    if localPlayer.Character then
        self:OnCharacterAdded(localPlayer.Character)
    end

    RunService:BindToRenderStep("Update",Enum.RenderPriority.Input.Value, function(dt)
        self:OnRenderStepped(dt)
    end)

    return self
end

function PlayerClass:IsMoveVectorCameraRelative(): boolean
    return self.moveVectorIsCameraRelative
end

function PlayerClass:OnCharacterAdded(character)
    self:SetModel(character)
end

function PlayerClass:OnCharacterRemoving(character)
    self:UnsetModel()
end

function PlayerClass:UpdateMovement(inputState)
    local input = self.controls:GetActiveController()

    if inputState == Enum.UserInputState.Cancel then
        self.moveVector = ZERO_VECTOR3
    else
        self.moveVector = Vector3.new(input.leftValue + input.rightValue, 0, input.forwardValue + input.backwardValue)
    end
end

function PlayerClass:CalculateRawMoveVector(humanoid: Humanoid, cameraRelativeMoveVector: Vector3): Vector3
    local camera = workspace.CurrentCamera
    if not camera then
        return cameraRelativeMoveVector
    end

    if humanoid:GetState() == Enum.HumanoidStateType.Swimming then
        return camera.CFrame:VectorToWorldSpace(cameraRelativeMoveVector)
    end

    local cameraCFrame = camera.CFrame

    local c, s
    local _, _, _, R00, R01, R02, _, _, R12, _, _, R22 = cameraCFrame:GetComponents()
    if R12 < 1 and R12 > -1 then
        -- X and Z components from back vector.
        c = R22
        s = R02
    else
        -- In this case the camera is looking straight up or straight down.
        -- Use X components from right and up vectors.
        c = R00
        s = -R01*math.sign(R12)
    end
    local norm = math.sqrt(c*c + s*s)
    return Vector3.new(
        (c*cameraRelativeMoveVector.X + s*cameraRelativeMoveVector.Z)/norm,
        0,
        (c*cameraRelativeMoveVector.Z - s*cameraRelativeMoveVector.X)/norm
    )
end

function PlayerClass:OnRenderStepped()
    if self.humanoid then
        local moveVector = self:GetMoveVector()
        local cameraRelative = self:IsMoveVectorCameraRelative()

        if cameraRelative then
            moveVector = self:CalculateRawMoveVector(self.humanoid, moveVector)
        end
        self.moveFunction(localPlayer, moveVector, false)
    end
end

return PlayerClass.new()