UGCProjects/AthleticMasters/Script/Blueprint/UGCPlayerPawn.lua

---@class UGCPlayerPawn_C:BP_UGCPlayerPawn_C
---@field JumpCamera2 UCameraComponent
---@field JumpArm2 USpringArmComponent
---@field P_PointTo UParticleSystemComponent
---@field JumpCamera UCameraComponent
---@field JumpArm USpringArmComponent
---@field TopCamera UCustomCameraComponent
--Edit Below--
---@type UGCPlayerPawn_C
local UGCPlayerPawn = {
    ---@field ModifyDamageDelegation fun(DamageAmount:float, PlayerPawn:BP_UGCPlayerPawn_C, CauserPC:APlayerController, DamageCauser:AActor, Hit:FHitResult):float
    ModifyDamageDelegation = {};
    -- MechanismEnergy = 0;                         -- 玩家拥有的能量
    CachedSTCharacterMovementGravityScale = 1.0;
    BaseCapsuleHalfHeight = 88.0;
    BaseCapsuleRadius = 40;
    CachedSTCharacterMovementGravityScale = 1.;
    DashDuration = -1;
    VelocityClampBase = 1200;
    VelocityClamp = 1200;
    bCanActiveSkill = false;
    NowCameraType = 1;
    CameraList = {};
    CustomJumpZVelocity = 443;
};

function UGCPlayerPawn:GetReplicatedProperties()
    return
    "DashImpulseEnergy",
    "NowCameraType",
    "CustomJumpZVelocity"
end

-- 关闭盒子掉落
function UGCPlayerPawn:IsSkipSpawnDeadTombBox(EventInstigater)
    return true
end

function UGCPlayerPawn:ReceiveBeginPlay()
    self.SuperClass.ReceiveBeginPlay(self);
    --- 设置翻墙功能
    self.bVaultIsOpen = true
    --- 设置滑铲功能
    self.IsOpenShovelAbility = true

    self.CachedSTCharacterMovementGravityScale = self.STCharacterMovement.GravityScale;

    UGCEventSystem.SendEvent(EventEnum.PlayerBeginPlay, self)

    --- 获取初始胶囊体信息
    self.BaseCapsuleHalfHeight = self.CapsuleComponent.CapsuleHalfHeight
    self.BaseCapsuleRadius = self.CapsuleComponent.CapsuleRadius

    if self:HasAuthority() then
        self:AddEvent()
        self:InitParam()
        --- 循环判断当前武器配置是否正确，多则删、少则补
        if UGCGameSystem.GameState:GetGameStateType() == CustomEnum.EGameState.Playing then
            -- self.LoopCheckGradientWeaponHandle = UGCEventSystem.SetTimerLoop(self, self.CheckGradientWeapon, 1.)
            --- 循环判断是否给予初始近战武器，有则移除Handle，没有则进行循环
            -- self.AddDefaultMeleeWeaponHandle = UGCEventSystem.SetTimerLoop(self, self.AddDefaultMeleeWeapon, 1.)
        end

        if UE.IsValid(self:GetController()) then
            self:ReceivePossessed(self:GetController())
            UGCLogSystem.Log("[UGCPlayerPawn_ReceiveBeginPlay] Controller Is Valid")
        end
        --- 技能的初始化
        self:SkillInit()

    else
        
    end
end

function UGCPlayerPawn:ReceiveEndPlay()
    self:RemoveEvent()
    self:SkillEndPlay()
    self.SuperClass.ReceiveEndPlay(self);
end

function UGCPlayerPawn:CheckGradientWeapon()
    WeaponGradientManager.UpdatePlayerGradientWeaponMatching(
            self.PlayerKey,
            UGCGameSystem.GameState:GetPlayerWeaponGrade(self.PlayerKey),
            UGCGameSystem.GameState:GetPlayerDefaultMeleeWeaponByPlayerKey(self.PlayerKey)
    )
end

function UGCPlayerPawn:AddDefaultMeleeWeapon()
    local MeleeWeaponID = UGCGameSystem.GameState:GetPlayerDefaultMeleeWeaponByPlayerKey(self.PlayerKey)
    if UGCBackPackSystem.GetItemCount(self, MeleeWeaponID) > 0 then
        UGCEventSystem.StopTimer(self.AddDefaultMeleeWeaponHandle)
        self.AddDefaultMeleeWeaponHandle = nil
    else
        UGCBackPackSystem.AddItem(self, MeleeWeaponID, 1)
    end
end

function UGCPlayerPawn:InitParam()
    -- self:SetMechanismEnergy(GlobalConfigs.GameSetting.InitEnergy)
end

function UGCPlayerPawn:ReceiveTick(DeltaTime)
    self.SuperClass.ReceiveTick(self, DeltaTime);
    -- UGCLogSystem.Log("[UGCPlayerPawn_ReceiveTick] bUseControllerRotationYaw:%s", tostring(self.bUseControllerRotationYaw))
    self:TickSkill(DeltaTime)
    if not UGCGameSystem.IsServer() then
        self:ClientMustBeExeBeginPlay()
    end

    self.CharacterMovement.Velocity = KismetMathLibrary.ClampVectorSize(self.CharacterMovement.Velocity, 0, self:GetVelocityClamp())
end

function UGCPlayerPawn:GetVelocityClamp()
    return self.VelocityClamp
end

function UGCPlayerPawn:SetVelocityClamp(NewVelocityClamp)
    self.VelocityClamp = NewVelocityClamp
end



--- 客户端必定执行的BeginPlay
function UGCPlayerPawn:ClientMustBeExeBeginPlay()
    if self.DoOnceMustBeExeBeginPlay then return end
    self.DoOnceMustBeExeBeginPlay = true
    --- 技能的初始化
    self:SkillInit()
    self:AddEvent()
    UGCPawnAttrSystem.SetCanSwitchFPP(self, true)

    self:InitCamera()

    self.P_PointTo:SetHiddenInGame(true)
end


function UGCPlayerPawn:AddEvent()
    UGCEventSystem.AddListener(EventEnum.SetSceneCameraControl, self.SetSceneCameraControl, self)
    if self:HasAuthority() then
        self.DeadNotifyDelegate:Add(self.PlayerDeadCallBack, self)
        self.DamageNotifyDelegate:Add(self.PlayerInjury, self)
    else
    end
end

function UGCPlayerPawn:RemoveEvent()
    UGCEventSystem.RemoveListener(EventEnum.SetSceneCameraControl, self.SetSceneCameraControl, self)
    if self:HasAuthority() then
        self.DeadNotifyDelegate:Remove(self.PlayerDeadCallBack, self)
        self.DamageNotifyDelegate:Remove(self.PlayerInjury, self)

        if self.LoopCheckGradientWeaponHandle then
            UGCEventSystem.StopTimer(self.LoopCheckGradientWeaponHandle)
            self.LoopCheckGradientWeaponHandle = nil
        end
        if self.AddDefaultMeleeWeaponHandle then
            UGCEventSystem.StopTimer(self.AddDefaultMeleeWeaponHandle)
            self.AddDefaultMeleeWeaponHandle = nil
        end
    else
    end
end


function UGCPlayerPawn:ReceivePossessed(NewController)
    self.SuperClass.ReceivePossessed(self, NewController);
    UGCLogSystem.Log("[UGCPlayerPawn_ReceivePossessed] PlayerKey:%s", tostring(NewController.PlayerKey))
    UGCEventSystem.SendEvent(EventEnum.PlayerPossessed, NewController.PlayerKey)
    --UGCSendRPCSystem.RPCEvent(NewController.PlayerKey, EventEnum.PlayerPossessed, NewController.PlayerKey)
    if GlobalConfigs.GameSetting.ReadyCanNotMove and UGCGameSystem.GameState:GetIsReadyState() then
        self:SetCanActionable(false)
    else
        self:SetCanActionable(true)
    end
end

function UGCPlayerPawn:SetCanActionable(IsActionable)
    UGCSystemLibrary.SetPlayerPawnMovable(self, IsActionable)
end



function UGCPlayerPawn:SetCanActiveSkill(IsActive)
    self.bCanActiveSkill = IsActive
end

-------------------------------------------------- Delegate --------------------------------------------------

---@param DamageInfo FDamageInfoCollection
---@return VictimKey, CauserKey, WeaponID, DamageType, IsHeadShotDamage, Distance, DamageValue uint, uint, int, EDamageType, bool, float, float
function UGCPlayerPawn:GetDamageInfoCollectionInfo(DamageInfo)
    local CauserController = DamageInfo.Instigator
    local WeaponID = -1
	local CauserKey = CauserController and CauserController.PlayerKey or -1
	local VictimKey = self.PlayerKey
    local CauserItemID = DamageInfo.CauserItemID
    --- 近战投掷、投掷手雷
    if CauserItemID then
        WeaponID = CauserItemID
    end
    UGCLogSystem.Log("[UGCPlayerPawn_GetDamageInfoCollectionInfo] WeaponID:%d", WeaponID)
	local Distance = 0.
	if CauserController and CauserController.Pawn then
		Distance = VectorHelper.GetDistance(self:K2_GetActorLocation(), CauserController.Pawn:K2_GetActorLocation())
	end

    local IsHeadShotDamage = (DamageInfo.Hit.BoneName == "head")
    return VictimKey, CauserKey, WeaponID, DamageInfo.DamageType, IsHeadShotDamage, Distance, DamageInfo.Damage
end

---@param DamageInfo FDamageInfoCollection
function UGCPlayerPawn:PlayerDeadCallBack(DamageInfo)
    UGCLogSystem.Log("[UGCPlayerPawn_PlayerDeadCallBack] PlayerKey:%s", tostring(self.PlayerKey))
    local VictimKey, CauserKey, WeaponID, DamageType, IsHeadShotDamage, Distance, DamageValue = self:GetDamageInfoCollectionInfo(DamageInfo)
    UGCLogSystem.LogTree("[UGCPlayerPawn_PlayerDeadCallBack] DeadInfo", {VictimKey, CauserKey, WeaponID, DamageType, IsHeadShotDamage, Distance, DamageValue})
    local DeadPS = UGCGameSystem.GetPlayerStateByPlayerKey(VictimKey)
    local Assister = -1
    if DeadPS then
        Assister = DeadPS:GetAssister(CauserKey, GlobalConfigs.GameSetting.AssistDamage)
    end
    UGCSendRPCSystem.RPCEvent(nil, EventEnum.PlayerDeathInfo, VictimKey, CauserKey, WeaponID, DamageType, IsHeadShotDamage, Distance, DamageValue, Assister)
    UGCEventSystem.SendEvent(EventEnum.PlayerDeathInfo, VictimKey, CauserKey, WeaponID, DamageType, IsHeadShotDamage, Distance, DamageValue, Assister)
    UGCLogSystem.Log("[UGCPlayerPawn_PlayerDeadCallBack] Succeed")
end

---@param DamageInfo FDamageInfoCollection
---@param ReturnValue float
function UGCPlayerPawn:PlayerInjury(DamageInfo)
    local VictimKey, CauserKey, WeaponID, DamageType, IsHeadShotDamage, Distance, DamageValue = self:GetDamageInfoCollectionInfo(DamageInfo)
    self.PlayerState:UpdatePlayerInjuryInfo(VictimKey, CauserKey, WeaponID, DamageType, IsHeadShotDamage, Distance, DamageValue)
    UGCEventSystem.SendEvent(EventEnum.PlayerInjuryInfo, VictimKey, CauserKey, WeaponID, DamageType, IsHeadShotDamage, Distance, DamageValue)
    UGCSendRPCSystem.RPCEvent(CauserKey, EventEnum.PlayerInjuryInfo, VictimKey, CauserKey, WeaponID, DamageType, IsHeadShotDamage, Distance, DamageValue)
end

------------------------------------------------ Delegate End ------------------------------------------------


function UGCPlayerPawn:AddMechanismEnergy(InEnergy)
    self:SetMechanismEnergy(self:GetMechanismEnergy() + InEnergy)
end

function UGCPlayerPawn:GetMechanismEnergy()
    return self.MechanismEnergy
end

function UGCPlayerPawn:SetMechanismEnergy(NewEnergy)
    self.MechanismEnergy = (NewEnergy > 0 and NewEnergy or 0)
end

------------------------------------------------ ModifyDamage ------------------------------------------------

function UGCPlayerPawn:UGC_TakeDamageOverrideEvent(Damage, DamageType, EventInstigator, DamageCauser, Hit)
    local DamageAmount = Damage
    UGCLogSystem.Log("[UGCPlayerPawn_UGC_TakeDamageOverrideEvent] InDamageAmount:%s", tostring(DamageAmount))
    for i, v in pairs(self.ModifyDamageDelegation) do
        if v.Obj then
            DamageAmount = v.DelegationFun(v.Obj, Damage, self, EventInstigator, DamageCauser, Hit)
        else
            DamageAmount = v.DelegationFun(Damage, self, EventInstigator, DamageCauser, Hit)
        end
    end
    UGCLogSystem.Log("[UGCPlayerPawn_UGC_TakeDamageOverrideEvent] ModifyDamageAmount:%s", tostring(DamageAmount))
    return DamageAmount
end

function UGCPlayerPawn:RemoveModifyDamageDelegation(InDelegationFun, InObj)
    for i = #self.ModifyDamageDelegation, 1, -1 do
        if self.ModifyDamageDelegate[i].DelegationFun == InDelegationFun and self.ModifyDamageDelegate[i].Obj == InObj then
            self.ModifyDamageDelegate[i] = nil
        end
    end
end


function UGCPlayerPawn:AddModifyDamageDelegationFun(InDelegationFun, InObj)
    self.ModifyDamageDelegation[#self.ModifyDamageDelegation + 1] = {DelegationFun = InDelegationFun, Obj = InObj}
end

---------------------------------------------- ModifyDamage End ----------------------------------------------





function UGCPlayerPawn:ScalePlayer(NewScale)
    if UGCGameSystem.IsServer() then
        self:SetPlayerScale_N(NewScale)
        UGCLogSystem.Log("[UGCPlayerPawn_ScalePlayer]")
        UGCSendRPCSystem.ActorRPCNotify(nil, self, "SetPlayerScale_N", NewScale)
        UGCLogSystem.Log("[UGCPlayerPawn_ScalePlayer] Finish")
    end
end

function UGCPlayerPawn:SetPlayerScale_N(NewScale)
    UGCLogSystem.Log("[UGCPlayerPawn_SetPlayerScale_N]")
    local HalfHeight = self.BaseCapsuleHalfHeight * NewScale
    self.Mesh:SetWorldScale3D({X = NewScale, Y = NewScale, Z = NewScale})
    self.CapsuleComponent:SetCapsuleHalfHeight(HalfHeight, true)
    self.CapsuleComponent:SetCapsuleRadius(self.BaseCapsuleRadius * NewScale, true)
    self.Mesh:K2_SetRelativeLocation({X = 0, Y = 0, Z = HalfHeight})
    UGCLogSystem.Log("[UGCPlayerPawn_SetPlayerScale_N] Finish")
end




function UGCPlayerPawn:SetPlayerState(PawnState)
    UGCPawnSystem.EnterPawnState(self, PawnState)
end

function UGCPlayerPawn:SetPawnTF(Pos, Rot)
    self:K2_SetActorLocation(Pos)
    self:K2_SetActorRotation(Rot)
    self.CharacterMovement.Velocity = VectorHelper.VectorZero()
    if UGCGameSystem.IsServer() then
        self.bShouldDumpCallstackWhenMovingfast = false
        self:SetClientLocationOrRotation(Pos, Rot, true, false)
        self.bShouldDumpCallstackWhenMovingfast = true
        UGCSendRPCSystem.ActorRPCNotify(nil, self, "SetPawnTF", VectorHelper.ToLuaTable(Pos), VectorHelper.RotToLuaTable(Rot))
        UGCLogSystem.Log("[UGCPlayerPawn_SetPawnTF] Succeed")
    end
end

------------------------------------- ChangeCamera -------------------------------------




function UGCPlayerPawn:InitCamera()
    self.CameraList = {
        [CustomEnum.EPlayerPawnCameraType.Default] = {}, -- 默认摄像机
        [CustomEnum.EPlayerPawnCameraType.TopCamera] = {Camera = self.TopCamera, Arm = nil, CameraRot = {Pitch=-30,Yaw=0.000000,Roll=0.000000}},
        [CustomEnum.EPlayerPawnCameraType.JumpCamera] = {Camera = self.JumpCamera, Arm = self.JumpArm},
        [CustomEnum.EPlayerPawnCameraType.JumpCamera2] = {Camera = self.JumpCamera2, Arm = self.JumpArm2}
    }
    if self.NowCameraType ~= 1 then
        self:OnRep_NowCameraType()
    end
    UGCLogSystem.Log("[UGCPlayerPawn_InitCamera] Finish")
end

function UGCPlayerPawn:SetNowCameraType(NewCameraType)
    self.NowCameraType = NewCameraType
    --if UGCGameSystem.IsServer() then
    --    UGCSendRPCSystem.ActorRPCNotify(self.PlayerKey, self, "SetNowCameraType", NewCameraType)
    --else
    --    self:OnRep_NowCameraType()
    --end
end

function UGCPlayerPawn:OnRep_NowCameraType()
    if self.CameraList[self.NowCameraType] == nil then return end

    local TargetCamera = self.CameraList[self.NowCameraType].Camera
    local TargetArm = self.CameraList[self.NowCameraType].Arm
    local CameraRot = self.CameraList[self.NowCameraType].CameraRot

    if TargetCamera then
        UGCSystemLibrary.ActivePlayerCameraByName(self, TargetCamera, TargetArm)
        if CameraRot then
            TargetCamera:K2_SetRelativeRotation(CameraRot)
        end
    else
        UGCSystemLibrary.ActivePlayerDefaultCamera(self)
    end
    UGCLogSystem.Log("[UGCPlayerPawn_OnRep_NowCameraType] Succeed")
end

function UGCPlayerPawn:SetSceneCameraControl(bIsSet)
    UGCLogSystem.Log("[UGCPlayerPawn_SetSceneCameraControl] bIsSet:%s", tostring(bIsSet))
    if bIsSet then
        self:SceneCameraControlPlayer()
    else
        self:ResetControlSetting()
    end
end

--- 场景摄像机控制玩家时的设置
function UGCPlayerPawn:SceneCameraControlPlayer()
    self.bUseControllerRotationYaw = false
    self.CharacterMovement.bOrientRotationToMovement = true
    self.CharacterMovement.bUseControllerDesiredRotation = false;
    self.CharacterMovement.RotationRate = {Pitch=0.000000,Yaw=-1.000000,Roll=0.000000}
    UGCLogSystem.Log("[UGCPlayerPawn_SceneCameraControlPlayer] bUseControllerRotationYaw：%s", tostring(self.bUseControllerRotationYaw))
end

--- 默认控制玩家时的设置
function UGCPlayerPawn:ResetControlSetting()
    self.bUseControllerRotationYaw = true
    self.CharacterMovement.bOrientRotationToMovement = false
    self.CharacterMovement.bUseControllerDesiredRotation = true;
    self.CharacterMovement.RotationRate = {Pitch=0.000000,Yaw=360.000000,Roll=0.000000}
    UGCLogSystem.Log("[UGCPlayerPawn_ResetControlSetting]")
end

function UGCPlayerPawn:SetTopCamera(On)
    if On then
        UGCSystemLibrary.ActivePlayerCameraByName(self, self.TopCamera, nil)
        self.TopCamera:K2_SetRelativeRotation({Pitch=-30,Yaw=0.000000,Roll=0.000000})
    else
        UGCSystemLibrary.ActivePlayerDefaultCamera(self)
    end
end


function UGCPlayerPawn:SetJumpCamera(On)
    if On then
        UGCSystemLibrary.ActivePlayerCameraByName(self, self.JumpCamera, self.JumpArm)
        -- self.JumpCamera:K2_SetRelativeRotation({Pitch=-10,Yaw=0.000000,Roll=0.000000})
    else
        UGCSystemLibrary.ActivePlayerDefaultCamera(self)
    end
end

----------------------------------- ChangeCamera End -----------------------------------

------------------------------------- ShowPointToSelf -------------------------------------

function UGCPlayerPawn:ShowPointToSelf(IsShow)
    if self.PlayerKey == UGCSystemLibrary.GetLocalPlayerKey() then
        self.P_PointTo:SetHiddenInGame(not IsShow)
    end
end

----------------------------------- ShowPointToSelf End -----------------------------------



---------------------------------------------------------- TurnOffGravityScale ----------------------------------------------------------

--- 关闭重力影响
---@param On bool
function UGCPlayerPawn:TurnOffGravityScale(On)
    if On then
        self.STCharacterMovement.GravityScale = 0;
    else
        self.STCharacterMovement.GravityScale = self.CachedSTCharacterMovementGravityScale;
    end
end

-------------------------------------------------------- TurnOffGravityScale End --------------------------------------------------------

function UGCPlayerPawn:SetCustomJumpZVelocity(InJumpZVelocity)
    --UGCPawnAttrSystem.SetJumpZVelocity(self, InJumpZVelocity)
    if self then
        self.CustomJumpZVelocity = InJumpZVelocity
        self.CharacterMovement.JumpZVelocity = self.CustomJumpZVelocity
        if UGCGameSystem.IsServer() then
            UGCSendRPCSystem.ActorRPCNotify(nil, self, "SetCustomJumpZVelocity", InJumpZVelocity)
        end
    end
end
function UGCPlayerPawn:OnRep_CustomJumpZVelocity()
    self:SetCustomJumpZVelocity(self.CustomJumpZVelocity)
end

------------------------------------------------------- DashImpulseSkill -------------------------------------------------------

UGCPlayerPawn.MinDashVelocity = 2400
UGCPlayerPawn.MaxDashVelocity = 3600
--- 冲量强度 /s
UGCPlayerPawn.ImpulseStrength = 10000
--- 移动范围（帧计算会有一点偏差）超过范围自动停止
UGCPlayerPawn.TargetDashLength = 1500
--- 最大冲刺时长
UGCPlayerPawn.DashMaxTime = 0.5
--- Dash的消耗限制
UGCPlayerPawn.DashImpulseEnergy = 0.
UGCPlayerPawn.DashImpulseEnergyCost = 100.
UGCPlayerPawn.EnergyRecoverySpeed = 20.
UGCPlayerPawn.DashImpulseMaxEnergy = 200

function UGCPlayerPawn:InitDashImpulse()
    if (self.bInitedDashImpulse == nil or (not self:GetDashImpulseOverlapComponent():IsActive()) ) and  UGCGameSystem.IsServer() then
        self.bInitedDashImpulse = true
        self.BP_PawnAuxiliaryOverlapCap:SetActive(true)
        self:GetDashImpulseOverlapComponent():SetActive(true)
        -- Pawn增加的碰撞盒都没效果
        self:GetDashImpulseOverlapComponent().OnComponentBeginOverlap:Add(self.DashCollisionCapsuleBeginOverlap, self)
        UGCLogSystem.Log("[UGCPlayerPawn_InitDashImpulse] Finish DashCollisionCapsuleIsActive:%s", tostring(self:GetDashImpulseOverlapComponent():IsActive()))
    end
end

function UGCPlayerPawn:GetDashImpulseOverlapComponent()
    return self.BP_PawnAuxiliaryOverlapCap.ChildActor.Capsule
end

function UGCPlayerPawn:DashCollisionCapsuleBeginOverlap(OverlappedComponent, OtherActor, OtherComp, OtherBodyIndex, bFromSweep, SweepResult)
    UGCLogSystem.Log("[UGCPlayerPawn_DashCollisionCapsuleBeginOverlap] OtherActor:%s", KismetSystemLibrary.GetObjectName(OtherActor))
    self:StopDashImpulse()
end


--- 冲量冲刺
---@param ForwardDir FVector 为nil则使用玩家向前向量作为方向
---@param InStartDashPos FVector 调用时无需传入
function UGCPlayerPawn:DashImpulse(ForwardDir, InStartDashPos)
    --local CameraForward = self:GetController().PlayerCameraManager:GetActorForwardVector()
    if self.ImpulseDashing then
        return
    end
    if UGCGameSystem.IsServer() then
        if not self.bCanActiveSkill then
            return
        end
    end

    if self:CheckDashImpulse() then
        self.DashImpulseEnergy = self.DashImpulseEnergy - self.DashImpulseEnergyCost
    else
        return
    end
    -- self:InitDashImpulse()

    self:SetCanActiveSkill(false)
    self.ImpulseDashing = true
    self:TurnOffGravityScale(true)
    self:SetVelocityClamp(self.MaxDashVelocity)

    if ForwardDir == nil then
        self.ImpulseDir = VectorHelper.ToLuaTable(self:GetActorForwardVector())
    else
        self.ImpulseDir = ForwardDir
    end

    -- 给予一个初始冲量
    UGCLogSystem.Log("[UGCPlayerPawn_DashImpulse] ImpulseDir:%s", VectorHelper.ToString(self.ImpulseDir))
    self.CharacterMovement.Velocity = VectorHelper.MulNumber(self.ImpulseDir, VectorHelper.Length(self.CharacterMovement.Velocity))
    self.CharacterMovement:AddImpulse(VectorHelper.MulNumber(self.ImpulseDir, self.ImpulseStrength * 0.4), true)
    -- 给予一个初始速度
    -- self.CharacterMovement.Velocity = VectorHelper.MulNumber(self.ImpulseDir, 1200)

    if UGCGameSystem.IsServer() then
        self.StartDashPos = VectorHelper.ToLuaTable(self:K2_GetActorLocation())
    else
        -- self.StartDashPos = InStartDashPos
        self:DashEffect()
    end

    --self.StopImpulseDashHandle = UGCEventSystem.SetTimer(self, self.StopDashImpulse, self.DashMaxTime)
    if UGCGameSystem.IsServer() then
        UGCSendRPCSystem.ActorRPCNotify(nil, self, "DashImpulse", self.ImpulseDir)
        self.StopImpulseDashHandle = UGCEventSystem.SetTimer(self, function()
            self.StopImpulseDashHandle = nil
            self:StopDashImpulse()
        end, self.DashMaxTime)
    end
end



function UGCPlayerPawn:DashEffect()
    if self.PlayerKey == UGCSystemLibrary.GetLocalPlayerKey() then
        SoundSystem.PlaySound(SoundSystem.ESound.Impulse)
    end
end

function UGCPlayerPawn:StopDashImpulse()
    if not self.ImpulseDashing then
        return
    end
    self:TurnOffGravityScale(false)
    self.CharacterMovement.Velocity = VectorHelper.VectorZero()
    self:SetVelocityClamp(self.VelocityClampBase)
    if UGCGameSystem.IsServer() then
        if self.StopImpulseDashHandle then
            UGCEventSystem.StopTimer(self.StopImpulseDashHandle)
            self.StopImpulseDashHandle = nil
        end
        UGCSendRPCSystem.ActorRPCNotify(nil, self, "StopDashImpulse")
    end
    self.ImpulseDashing = false
    self:SetCanActiveSkill(true)
end

function UGCPlayerPawn:AddDashImpulseEnergy(DeltaTime)
    self.DashImpulseEnergy = math.clamp(self.DashImpulseEnergy + DeltaTime * self.EnergyRecoverySpeed, 0, self.DashImpulseMaxEnergy)
end

function UGCPlayerPawn:CheckDashImpulse()
    return self.DashImpulseEnergy >= self.DashImpulseEnergyCost
end

function UGCPlayerPawn:DashImpulseTick(DeltaTime)
    self:AddDashImpulseEnergy(DeltaTime)
    if self.ImpulseDashing then
        self.CharacterMovement:AddImpulse(VectorHelper.MulNumber(self.ImpulseDir, self.ImpulseStrength * DeltaTime), true)

        if self.CharacterMovement.MovementMode ~= EMovementMode.MOVE_Falling then
            self.CharacterMovement:SetMovementMode(EMovementMode.MOVE_Falling);
        end
        -- self.CharacterMovement.Velocity = KismetMathLibrary.ClampVectorSize(self.CharacterMovement.Velocity, self.MinDashVelocity, self.MaxDashVelocity)
        self.CharacterMovement.Velocity = VectorHelper.MulNumber(self.ImpulseDir, math.clamp(VectorHelper.Length(self.CharacterMovement.Velocity), self.MinDashVelocity, self.MaxDashVelocity))
        if UGCGameSystem.IsServer() then
            if VectorHelper.Length(VectorHelper.Sub(self:K2_GetActorLocation(), self.StartDashPos)) > self.TargetDashLength then
                self:StopDashImpulse()
            end
        end

    end
end

----------------------------------------------------- DashImpulseSkill End -----------------------------------------------------

--- 测试按键按下在服务器触发的函数
function UGCPlayerPawn:TestButtonFun(CameraForwardVector)
    -- self:PlayerDashSkill(self:GetActorForwardVector(), 1, 5000)
    -- self:PlayerDashSkill(CameraForwardVector, 1, 5000)
    -- self:DashImpulse(CameraForwardVector, 8000, 1500, 0.8)
    -- self:TestMoveComponentTo(CameraForwardVector)
end

function UGCPlayerPawn:TestButtonPressed(CameraForwardVector)
end

function UGCPlayerPawn:TestButtonReleased()
end

--- Server的BeginPlay触发及Client的ClientMustBeExeBeginPlay触发
function UGCPlayerPawn:SkillInit()
    if UGCGameSystem.IsServer() then
        -- self:InitDashImpulse()
    else
    end
end

function UGCPlayerPawn:SkillEndPlay()
    if UGCGameSystem.IsServer() then
    else
    end
end

function UGCPlayerPawn:TickSkill(DeltaTime)
    --self:DashImpulseTick(DeltaTime)
    ---- self:TickDash(DeltaTime)
    --if UGCGameSystem.IsServer() then
    --else
    --    if UGCSystemLibrary.GetLocalPlayerPawn() == self then
    --    end
    --
    --end
end



function UGCPlayerPawn:GetAvailableServerRPCs()
    return
end


return UGCPlayerPawn;