# 第9章---自定义输入框架搭建以及Ability初识

最新推荐文章于 2024-08-14 14:02:55 发布
最新推荐文章于 2024-08-14 14:02:55 发布
阅读量968 收藏 5
点赞数 16
文章标签： ue5 c++ 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51940803/article/details/136514344
版权

自定义输入框架思路：系统通过Tag判断用户输入，而不是EnhancedInput告诉系统玩家输入，EnhancedInput接受输入，传入Tag告诉系统

文件结构

Source

  • Private

    • AbilitySystem
      • Data
        • AttributeInfo.cpp
      • ModMagCalc
        • MMC_MaxHealth.cpp
        • MMC_MaxMana.cpp
      • RPGAbilitySystemComponent.cpp
      • RPGAbilitySystemLibrary.cpp
      • RPGAttributeSet.cpp
    • Character
      • PGGameCharacterBase.cpp
      • RPGGameEnemy.cpp
      • RPGGamePlayerCharacter.cpp
    • Game
      • RPGGameModeBase.cpp
    • Input
      • RPGInputComponent.cpp
      • RPGInputConfig.cpp
    • Interaction
      • EnemyInterface.cpp
      • CombatInterface.cpp
    • Player
      • RPGPlayerController.cpp
      • RPGPlayerState.cpp
    • Actor
      • RPGEffectActor.cpp
    • UI
      • HUD
        • RPGHUD.cpp
      • WidgetController
        • OverlayWidgetController.cpp
        • AttributeMenuWidgetController.cpp
        • RPGWidgetController.cpp
      • Widgets
        • RPGUserWidget.cpp
    • RPGAssetManager.cpp
    • RPGGameplayTags.cpp

  • Public

    • AbilitySystem

      • Data
        • AttributeInfo.h
      • ModMagCalc
        • MMC_MaxHealth.h
        • MMC_MaxMana.h
      • RPGAbilitySystemComponent.h
      • RPGAbilitySystemLibrary.h
      • RPGAttributeSet.h

    • Character

      • RPGGameCharacterBase.h
      • RPGGameEnemy.h
      • RPGGamePlayerCharacter.h

    • Game

      • RPGGameModeBase.h

    • Input

      • RPGInputComponent.h
      • RPGInputConfig.h

    • Interaction

      • EnemyInterface.h
      • CombatInterface.h

    • Player

      • RPGPlayerController.h
      • RPGPlayerState.h

    • Actor

      • RPGEffectActor.h

    • UI

      • HUD
        • RPGHUD.h
      • WidgetController
        • OverlayWidgetController.h
        • AttributeMenuWidgetController.h
        • RPGWidgetController.h
      • Widgets
        • RPGUserWidget.h

    • RPGAssetManager.h

    • RPGGameplayTags.h

文件概述

RPGAbilitySystemComponent

.h文件
// Copyright KimiLiu

#pragma once

#include "CoreMinimal.h"
#include "AbilitySystemComponent.h"
#include "RPGAbilitySystemComponent.generated.h"

DECLARE_MULTICAST_DELEGATE_OneParam(FEffectAssetTags, const FGameplayTagContainer&/*AssetTags*/);

/**
 * Ability System Component 拥有两个Owner: Owner Actor 以及Avatar Actor，这两个Actor有可能相同，有可能不相同
 *  Owner Actor 指的是实例化组件的Actor
 *  Avatar Actor 指的是ASC实际上服务的Actor，例如
 *     - RPGGameEnemy 内的ASC的 Owner Actor 和 Avatar Actor 都是 RPGGameEnemy 这个 Actor 类自身。因为ASC由 RPGGameEnemy 实例
 *        化，同时服务于 RPGGameEnemy
 *     - RPGGamePlayerCharacter 内的ASC的 Owner Actor 是 RPGPlayerState，而 Avatar Actor 是RPGGamePlayerCharacter。因为
 *        ASC由RPGPlayerState实例化，但是ASC服务于PRGGamePlayerCharacter
 */
UCLASS()
class AURA_API URPGAbilitySystemComponent : public UAbilitySystemComponent
{
    GENERATED_BODY()

public:
    // ASC初始化完成(设置了实际所有者以及逻辑所有者)
    void AbilityActorInfoSet();

    // 委托，用来处理捡起血瓶或水晶时显示UI用
    FEffectAssetTags EffectAssetTags;

    // 给ASC增加Abilities
    void AddCharacterAbilities(const TArray<TSubclassOf<UGameplayAbility>>& StartupAbilities);

    // 供PlayerController调用， Held时尝试激活拥有的Ability，通过Tag来调用指定的Ability
    void AbilityInputTagHeld(const FGameplayTag& InputTag);
    void AbilityInputTagReleased(const FGameplayTag& InputTag);

protected:
    // 当有任何GE在自身上被应用时会触发委托调用该函数，在客户端也会被调用
    UFUNCTION(Client, Reliable)
    void ClientEffectApplied(UAbilitySystemComponent* AbilitySystemComponent, const FGameplayEffectSpec& GameplayEffectSpec, FActiveGameplayEffectHandle ActiveGameplayEffectHandle);
    
};
.cpp文件
// Copyright KimiLiu


#include "AbilitySytstem/RPGAbilitySystemComponent.h"

#include "RPGGameplayTags.h"
#include "AbilitySytstem/Abilities/RPGGameplayAbility.h"

void URPGAbilitySystemComponent::AbilityActorInfoSet()
{
    // 绑定委托
    OnGameplayEffectAppliedDelegateToSelf.AddUObject(this, &URPGAbilitySystemComponent::ClientEffectApplied);

    const FRPGGameplayTags& GameplayTags = FRPGGameplayTags::Get();
    //GameplayTags.Attributes_Secondary_Armor.ToString()
    GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Orange, FString::Printf(TEXT("Tag: %s"), *GameplayTags.Attributes_Secondary_Armor.ToString()));
}

// 给Character增加Ability
void URPGAbilitySystemComponent::AddCharacterAbilities(const TArray<TSubclassOf<UGameplayAbility>>& StartupAbilities)
{
    for (const TSubclassOf<UGameplayAbility> AbilityClass : StartupAbilities)
    {
       FGameplayAbilitySpec AbilitySpec = FGameplayAbilitySpec(AbilityClass, 1);
       if (const URPGGameplayAbility* RPGAbility = Cast<URPGGameplayAbility>(AbilitySpec.Ability))
       {
          AbilitySpec.DynamicAbilityTags.AddTag(RPGAbility->StartupInputTag);
          GiveAbility(AbilitySpec);
       }
    }
}

void URPGAbilitySystemComponent::AbilityInputTagHeld(const FGameplayTag& InputTag)
{
    if (!InputTag.IsValid()) return;

    // 获取所有能够激活的Abilities,找到符合输入Tag的那个Ability,激活Ability
    for (FGameplayAbilitySpec& AbilitySpec : GetActivatableAbilities())
    {
       if (AbilitySpec.DynamicAbilityTags.HasTagExact(InputTag))
       {
          AbilitySpecInputPressed(AbilitySpec);
          if (!AbilitySpec.IsActive())
          {
             TryActivateAbility(AbilitySpec.Handle);
          }
       }
    }
}

void URPGAbilitySystemComponent::AbilityInputTagReleased(const FGameplayTag& InputTag)
{
    if (!InputTag.IsValid()) return;

    // 获取所有能够激活的Abilities,找到符合输入Tag的那个Ability,调用AbilitySpecInputReleased
    for (FGameplayAbilitySpec& AbilitySpec : GetActivatableAbilities())
    {
       if (AbilitySpec.DynamicAbilityTags.HasTagExact(InputTag))
       {
          AbilitySpecInputReleased(AbilitySpec);
       }
    }
}

void URPGAbilitySystemComponent::ClientEffectApplied_Implementation(UAbilitySystemComponent* AbilitySystemComponent,
                                               const FGameplayEffectSpec& GameplayEffectSpec, FActiveGameplayEffectHandle ActiveGameplayEffectHandle)
{
    //GEngine->AddOnScreenDebugMessage(1, 5.f, FColor::Red, FString("Effect Applied"));
    
    FGameplayTagContainer TagContainer;
    GameplayEffectSpec.GetAllAssetTags(TagContainer);

    // 广播
    EffectAssetTags.Broadcast(TagContainer);
    

    
}

RPGInputComponent

.h文件
// Copyright KimiLiu

#pragma once

#include "CoreMinimal.h"
#include "EnhancedInputComponent.h"
#include "RPGInputConfig.h"
#include "RPGInputComponent.generated.h"

/**
 * 
 */
UCLASS()
class AURA_API URPGInputComponent : public UEnhancedInputComponent
{
    GENERATED_BODY()
public:

    // 模板函数，可以接受函数或函数指针
    // 自定义输入绑定函数， 将输入AS内的所有
    template<class UserClass, typename PressedFuncType, typename ReleasedFuncType, typename HeldFuncType>
    void BindAbilityActions(const URPGInputConfig* InputConfig, UserClass* Object, PressedFuncType PressedFunc, ReleasedFuncType ReleasedFunc, HeldFuncType HeldFunc);
};

// 给一个IA绑定3个函数
template <class UserClass, typename PressedFuncType, typename ReleasedFuncType, typename HeldFuncType>
void URPGInputComponent::BindAbilityActions(const URPGInputConfig* InputConfig, UserClass* Object,
    PressedFuncType PressedFunc, ReleasedFuncType ReleasedFunc, HeldFuncType HeldFunc)
{
    check(InputConfig);

    for (const FRPGInputAction& Action : InputConfig->AbilityInputActions)
    {
       if (Action.InputAction && Action.InputTag.IsValid())
       {
          if (PressedFunc)
          {
             BindAction(Action.InputAction, ETriggerEvent::Started, Object, PressedFunc, Action.InputTag);
          }
          if (ReleasedFunc)
          {
             BindAction(Action.InputAction, ETriggerEvent::Completed, Object, ReleasedFunc, Action.InputTag);
          }
          if (HeldFunc)
          {
             BindAction(Action.InputAction, ETriggerEvent::Triggered, Object, HeldFunc, Action.InputTag);
          }
          
       }
    }
}
.cpp文件

CPP文件为空

RPGInputConfig

.h文件
// Copyright KimiLiu

#pragma once

#include "CoreMinimal.h"
#include "GameplayTagContainer.h"
#include "Engine/DataAsset.h"
#include "RPGInputConfig.generated.h"

class UInputAction;

USTRUCT(BlueprintType)
struct FRPGInputAction
{
    GENERATED_BODY()

    UPROPERTY(EditDefaultsOnly)
    const UInputAction* InputAction = nullptr;

    UPROPERTY(EditDefaultsOnly)
    FGameplayTag InputTag = FGameplayTag();
};

/**
 * 
 */
UCLASS()
class AURA_API URPGInputConfig : public UDataAsset
{
    GENERATED_BODY()

public:

    const UInputAction* FindAbilityInputActionForTag(const FGameplayTag& InputTag, bool bLogNotFound = false) const;
    
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
    TArray<FRPGInputAction> AbilityInputActions;
};
.cpp文件
// Copyright KimiLiu


#include "Input/RPGInputConfig.h"

const UInputAction* URPGInputConfig::FindAbilityInputActionForTag(const FGameplayTag& InputTag, bool bLogNotFound) const
{
    for (const FRPGInputAction& InputAction : AbilityInputActions)
    {
       if (InputAction.InputAction && InputAction.InputTag.MatchesTag(InputTag))
       {
          return InputAction.InputAction;
       }
    }
    if (bLogNotFound)
    {
       UE_LOG(LogTemp, Error,
          TEXT("Can't find Info for InputAction [%s] on InputConfig [%s]."),*InputTag.ToString(), *GetNameSafe(this) );
    }
    return nullptr;
}

RPGPlayerController

.h文件
// Copyright KimiLiu

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/PlayerController.h"
#include "GameplayTagContainer.h"
#include "RPGPlayerController.generated.h"

class URPGInputConfig;
class UInputMappingContext;
class UInputAction;
class IEnemyInterface;
class URPGAbilitySystemComponent;
class USplineComponent;
struct FInputActionValue;

/**
 * 
 */
UCLASS()
class AURA_API ARPGPlayerController : public APlayerController
{
    GENERATED_BODY()

public:
    ARPGPlayerController();

    virtual void PlayerTick(float DeltaTime) override;
    
protected:
    virtual void BeginPlay() override;

    virtual void SetupInputComponent() override;

private:
    /**
     * ---Property---------------------------------------------------------------------
     */
    UPROPERTY(EditAnywhere, Category="Input")
    TObjectPtr<UInputMappingContext> PlayerContext;

    UPROPERTY(EditAnywhere, Category="Input")
    TObjectPtr<UInputAction> MoveAction;

    //鼠标指针追踪处理参数，表示上一帧鼠标指针悬停的对象以及当前帧鼠标指针悬停的对象
    //鼠标指针追踪
    void CursorTrace();
    IEnemyInterface* LastActor;
    IEnemyInterface* ThisActor;
    FHitResult CursorHit;
    
    //移动函数
    void Move(const FInputActionValue& InputActionValue);

    

    void AbilityInputTagPressed(FGameplayTag InputTag);
    void AbilityInputTagReleased(FGameplayTag InputTag);
    void AbilityInputHeld(FGameplayTag InputTag);
    
    UPROPERTY(EditDefaultsOnly,Category="Input")
    TObjectPtr<URPGInputConfig> InputConfig;

    UPROPERTY()
    TObjectPtr<URPGAbilitySystemComponent> RPGAbilitySystemComponent;

    URPGAbilitySystemComponent* GetASC();

    // 鼠标点击移动功能
    FVector CachedDestination = FVector::ZeroVector;
    float FollowTime = 0.f;
    float ShortPressThreshold = 0.5f;
    bool bAutoRunning = false;
    bool bTargeting = false;
    
    UPROPERTY(EditDefaultsOnly)
    float AutoRunAcceptanceRadius = 50.f;

    UPROPERTY(VisibleAnywhere)
    TObjectPtr<USplineComponent> Spline;

    void AutoRun();
};
.cpp文件
// Copyright KimiLiu


#include "Player/RPGPlayerController.h"

#include "AbilitySystemBlueprintLibrary.h"
#include "EnhancedInputSubsystems.h"
#include "NavigationPath.h"
#include "NavigationSystem.h"
#include "RPGGameplayTags.h"
#include "AbilitySytstem/RPGAbilitySystemComponent.h"
#include "Components/SplineComponent.h"
#include "Input/RPGInputComponent.h"
#include "Interaction/EnemyInterface.h"

ARPGPlayerController::ARPGPlayerController()
{
    bReplicates = true;

    Spline = CreateDefaultSubobject<USplineComponent>("Spline");
}

void ARPGPlayerController::PlayerTick(float DeltaTime)
{
    Super::PlayerTick(DeltaTime);

    // 每帧追踪鼠标，高亮选择的对象，取消高亮不选择的对象
    CursorTrace();

    // 当bAutoRun为真时，鼠标左键单点前往可以去的地方，每帧都调用运动输入
    AutoRun();
}

void ARPGPlayerController::BeginPlay()
{
    Super::BeginPlay();

    //检查上下文是否为空，为空则直接中断系统，免得运行崩溃
    check(PlayerContext);
    UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(GetLocalPlayer());
    //只有本地玩家才会有一个Subsystem，其它玩家并不会被分配Subsystem
    if (Subsystem)
    {
       Subsystem->AddMappingContext(PlayerContext, 0);
    }

    //显示鼠标指针，设置光标样式
    bShowMouseCursor = true;
    DefaultMouseCursor = EMouseCursor::Default;

    //设置交互方式，不将鼠标锁在游戏内，同时在鼠标不被ui捕捉时照样显示ui
    FInputModeGameAndUI InputModeData;
    InputModeData.SetLockMouseToViewportBehavior(EMouseLockMode::DoNotLock);
    InputModeData.SetHideCursorDuringCapture(false);
    SetInputMode(InputModeData);
}

void ARPGPlayerController::SetupInputComponent()
{
    Super::SetupInputComponent();

    //检查是否为空以及是否为增强输入系统
    URPGInputComponent* RPGInputComponent = CastChecked<URPGInputComponent>(InputComponent);
    //绑定输入
    RPGInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &ARPGPlayerController::Move);
    RPGInputComponent->BindAbilityActions(InputConfig, this, &ThisClass::AbilityInputTagPressed, &ThisClass::AbilityInputTagReleased, &ThisClass::AbilityInputHeld);
}

void ARPGPlayerController::Move(const FInputActionValue& InputActionValue)
{
    //将输入的数据结构转变为FVector2D，我们只需要向量
    const FVector2d InputAxisVector = InputActionValue.Get<FVector2d>();

    //获得控制器的转向信息，转向信息是基于世界坐标系的
    //创建水平转向的Rotator
    const FRotator Rotation = GetControlRotation();
    const FRotator YawRotation(0.f, Rotation.Yaw, 0.f);

    //获取当前角色在世界坐标系下的前向方向(XY平面)以及右向方向(XY平面)的向量
    //FrotationMatrix是一个结构体，表示旋转矩阵
    //GetUnitAxis函数返回矩阵的第x行参数，x取决于入参
    const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
    const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

    //Move函数会在游戏的每一帧被调用，因此有可能控制器还没有控制人物，这个函数就被调用了，那么系统会崩溃，我们不用Check来中断，只需要无视就好
    //等到控制器被分配到了人物之后再进入if函数内执行逻辑
    if (APawn* ControlledPawn = GetPawn<APawn>())
    {
       ControlledPawn->AddMovementInput(ForwardDirection, InputAxisVector.Y);
       ControlledPawn->AddMovementInput(RightDirection, InputAxisVector.X);
    }
    
}

void ARPGPlayerController::CursorTrace()
{
    
    GetHitResultUnderCursor(ECC_Visibility, false, CursorHit);
    
    if (!CursorHit.bBlockingHit)return;

    //刷新指针悬浮的Actor
    LastActor = ThisActor;
    //获取点击对象的IEnemyInterface接口，查看对象是否实现了该接口，如未实现则返回nullptr
    ThisActor = Cast<IEnemyInterface>(CursorHit.GetActor());

    /**
     *鼠标指针追踪会有多种结果：
     * A. LastActor is null && ThisActor is null 
     *    - 不做任何处理
     * B. LastActor is null && ThisActor is valid
     *    - 高亮ThisActor
     * C. LastActor is valid && ThisActor is null
     *    - 取消高亮LastActor
     * D. LastActor is valid && ThisActor is valid , but LastActor != ThisActor
     *    - 取消高亮LastActor并高亮ThisActor
     * E. LastActor is valid && ThisActor is valid , but LastActor == ThisActor
     *    - 不做任何处理
     */

    if (LastActor == nullptr)
    {
       if (ThisActor != nullptr)
       {
          // case B
          ThisActor->HighlightActor();
       }
       else
       {
          // case A
       }
       
    }
    else
    {
       if (ThisActor == nullptr)
       {
          // case C
          LastActor->UnHighlightActor();
       }
       else
       {
          if (LastActor != ThisActor)
          {
             // case D
             LastActor->UnHighlightActor();
             ThisActor->HighlightActor();
          }
          else
          {
             // case E
          }
       }
    }
    
}

// 集中处理所有按键事件
void ARPGPlayerController::AbilityInputTagPressed(FGameplayTag InputTag)
{
    GEngine->AddOnScreenDebugMessage(1, 3.f, FColor::Red, *InputTag.ToString());

    if(InputTag.MatchesTagExact(FRPGGameplayTags::Get().InputTag_LMB))
    {
       bTargeting = ThisActor ? true : false ;
       bAutoRunning = false;
    }
    
}

void ARPGPlayerController::AbilityInputTagReleased(FGameplayTag InputTag)
{
    if(!InputTag.MatchesTagExact(FRPGGameplayTags::Get().InputTag_LMB))
    {
       if (GetASC())
       {
          GetASC()->AbilityInputTagReleased(InputTag);
       }
       return;
    }
    if (bTargeting)
    {
       if (GetASC())
       {
          GetASC()->AbilityInputTagReleased(InputTag);
       }
    }
    else
    {
       APawn* ControlledPawn = GetPawn();
       if (FollowTime <= ShortPressThreshold && ControlledPawn)
       {
          if(UNavigationPath* NavPath = UNavigationSystemV1::FindPathToLocationSynchronously(this, ControlledPawn->GetActorLocation(), CachedDestination))
          {
             Spline->ClearSplinePoints();
             for (const FVector& PointLoc : NavPath->PathPoints)
             {
                Spline->AddSplinePoint(PointLoc, ESplineCoordinateSpace::World);
                DrawDebugSphere(GetWorld(), PointLoc, 8.f, 8, FColor::Green, false, 5.f);
             }
             CachedDestination = NavPath->PathPoints[NavPath->PathPoints.Num()-1];
             bAutoRunning = true;
          }
       }
       FollowTime = 0.f;
       bTargeting = false;
    }
    
}

void ARPGPlayerController::AbilityInputHeld(FGameplayTag InputTag)
{

    if(!InputTag.MatchesTagExact(FRPGGameplayTags::Get().InputTag_LMB))
    {
       if (GetASC())
       {
          GetASC()->AbilityInputTagHeld(InputTag);
       }
       return;
    }

    if (bTargeting)
    {
       if (GetASC())
       {
          GetASC()->AbilityInputTagHeld(InputTag);
       }
    }
    else
    {
       FollowTime += GetWorld()->GetDeltaSeconds();

       
       if (CursorHit.bBlockingHit)
       {
          CachedDestination = CursorHit.ImpactPoint;
       }

       if (APawn* ControlledPawn = GetPawn())
       {
          const FVector WorldDirection = (CachedDestination - ControlledPawn->GetActorLocation()).GetSafeNormal();
          ControlledPawn->AddMovementInput(WorldDirection);
       }
    }
}

URPGAbilitySystemComponent* ARPGPlayerController::GetASC()
{
    if (RPGAbilitySystemComponent == nullptr)
    {
       RPGAbilitySystemComponent = Cast<URPGAbilitySystemComponent>(UAbilitySystemBlueprintLibrary::GetAbilitySystemComponent(GetPawn<APawn>()));
    }
    return RPGAbilitySystemComponent;
}

void ARPGPlayerController::AutoRun()
{
    if (!bAutoRunning)return;
    if(APawn* ControlledPawn = GetPawn())
    {
       const FVector LocationOnSpline = Spline->FindLocationClosestToWorldLocation(ControlledPawn->GetActorLocation(), ESplineCoordinateSpace::World);
       const FVector Direction = Spline->FindDirectionClosestToWorldLocation(LocationOnSpline, ESplineCoordinateSpace::World);
       ControlledPawn->AddMovementInput(Direction);

       const float DistanceToDestination = (LocationOnSpline - CachedDestination).Length();
       if (DistanceToDestination <= AutoRunAcceptanceRadius)
       {
          bAutoRunning = false;
          
       }
    }
}
楚江_wog1st
关注
  • 16
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
[网络安全自学篇] 六十六.Vulnhub靶机渗透之DC-1提权和Drupal漏洞利用（二）
杨秀璋的专栏
04-11 1万+
这是作者的网络安全自学教程系列，主要是关于安全工具和实践操作的在线笔记，特分享出来与博友们学习，希望您们喜欢，一起进步。前文分享了Vulnhub靶机渗透的环境搭建和JIS-CTF题目，采用Nmap、Dirb、中国蚁剑、敏感文件分析、SSH远程连接、Shell提权等获取5个flag。本文将讲解DC-1提权和Drupal漏洞利用，通过信息收集、CMS漏洞搜索、Metasploit反弹shell、提权及数据库爆破获取flag。本文是一篇Web渗透的基础性文章，希望对您有所帮助。
JavaEE知识体系
yuh2012的博客
07-11 2万+
1 1.文件上传下载 1.1 文件上传 1.1.1 文件上传的作用 例如网络硬盘！就是用来上传下载文件的。 在智联招聘上填写一个完整的简历还需要上传照片呢。 1.1.2 文件上传对页面的要求 1.必须使用表单，而不能是超链接； 2.表单的method必须是POST，而不能是GET； 3.表单的enctype必须是multipart/form-data； 4.在表单中添加file表
HarmonyOS应用开发者基础认证考试(90分过)
热门推荐
不愧是暮言的博客
05-15 5万+
此博文为HarmonyOS应用开发者基础认证考试的最后的大考，要求100分取得90分方可获取证书、现将考试的题库进行分享，希望能帮到大家。真心希望这篇博文能帮助到大家！！！
鸿蒙操作系统-初识
qq_47840823的博客
03-26 1628
在应用上架到应用市场时，需要把Bundle打包为一个.app后缀的文件用于上架，这个.app文件称为App Pack（Application Package），其中同时包含了描述App Pack属性的pack.info文件。等该App包上架到应用市场云端，应用市场会对上架的App包校验签名，校验签名通过后会将App包中的HAP拆分出来，同时对拆分出的HAP重新添加签名，然后对HAP进行分发，以达到统一OS，弹性部署。在右边的侧边工具栏，点击Previewer，预览一下。最终达到诊断页面全是。
140.【鸿蒙OS开发-01】
qq_69683957的博客
11-20 863
鸿蒙开发(一)、初识鸿蒙1.初识鸿蒙(1).移动通讯技术的发展(2).完整的鸿蒙开发(二)、鸿蒙系统介绍1.鸿蒙系统的官方定义(1).鸿蒙操作系统概述(2).鸿蒙的生态2.鸿蒙系统的特点3.鸿蒙和安卓的对比4.鸿蒙开发的发展前景(三)、鸿蒙开发准备工作1.鸿蒙OS的完整开发流程2.注册并实名认证华为开发者账号3.下载并安装开发工具4.开发工具的常见设置5.开发工具项目结构介绍(四)、鸿蒙入门应用1.第一个应用: HelloWorld(1).如何运行项目(2).页面中的包含关系(3).为什么存在子页面呢?(4
HarmonyOS实战开发：LocalStorage-页面级UI状态存储
2401_84194030的博客
04-22 830
LocalStorage支持UIAbility实例内多个页面间状态共享。
StarlingX 前世今生 -- （汇总了网上的一些资料）
straka的博客
04-28 3879
背景 要说StarlingX，首先要弄清楚其发展的背景，作为致力于边缘云的基础设施，可以从两个角度，一个是云计算的发展，另一个是边缘计算的发展 云计算的发展经历了虚拟化→基础云-->云原生的发展，虚拟化时代的vmware领航着当时的云发展，通过VMware完成虚拟机资源的统一管理，显然这种方式有一定局限，必须采购VMware的商业产品，只能使用VMware虚拟机，性能也比较受...
第二章 OpenHarmony工程介绍
开源大使
10-26 1230
Ability译为能力，一个OpenHarmony应用包含N个能力（Ability），它们是系统调用应用的最小单元。应用程序开发其实本质上就是开发Ability。自己试试对应用进行拆分，你会发现它们具备很多小能力。把这些小能力组合起来就变成了一个应用。方舟开发框架（简称：ArkUI），是一套UI开发框架，提供开发者进行应用UI开发时所必需的能力。
鸿蒙应用开发学习-初识ArkTS
初一十五的博客
03-15 1362
ArkTS是HarmonyOS优选的主力应用开发语言
Telegrams-AbilityBot入门：这是我入门的代码
02-04
Telegrams-AbilityBot入门：这是我入门的代码
unity-gameplay-ability-system:在Unity中实施能力系统的统一框架
04-19
Unity游戏能力系统Unity的游戏能力系统（简称GAS）是一个Unity框架，用于创建包含任何能力（例如DotA，Skyrim）的游戏。 该框架有助于以统一的方式简化组件之间的交互。 该项目的灵感主要来自虚幻游戏能力系统，并...
ability-ability-runtime元能力子系统
07-16
元能力子系统实现对Ability的运行及生命周期进行统一的调度和管理，应用进程能够支撑多个Ability，Ability具有跨应用进程间和同一进程内调用的能力。Ability管理服务统一调度和管理应用中各Ability，并对Ability的...
HealthRegen-Ability-UI-Asset.zip
06-14
这包括触发能力的事件、更新UI状态的事件，以及处理输入和反馈的逻辑。 总结起来，HealthRegen-Ability-UI-Asset.zip这个资源包提供了一次实践机会，让你在UE4中掌握制作和整合游戏UI资产的技能，特别是与角色能力...
UE5学习笔记12-为角色添加蹲下的动作
m0_53219246的博客
08-12 485
角色的蹲伏，代码中设置角色是否蹲伏
UE5 隐藏模型关节，实现半身模型的驱动
独孤光的博客
08-08 623
运行动捕软件，加载一段半身带手指数据运行UE，通过LiveLink插件与动捕系统建立连接。
虚幻5|入门AI行为树，建立敌人
djh7758258520184的博客
08-09 722
先自定义事件，再事件开始运行ai巡逻，ai能一次性移动1000的半径，每次移动等待1~2秒再次移动，每移动完一次打印到达。用于添加敌人的UI于蓝图视口，可在运行的时候，看到血条UI，如果你还没做这个，可以暂时不加这个组件，后面我会开基础UI编写文章。4.回到行为树，在moveto之前执行一个task，我的任务命名是ue5_task，你的可能跟我不一样。运行，就可以发现跟我们第一点讲的建立简单ai敌人的行为一致了，虽然麻烦但这种方法可以创建很多个ai敌人。导航网格体边界体积，这绿色的范围就是敌人可巡逻范围。
虚幻5|AI行为树，进阶篇
最新发布
djh7758258520184的博客
08-14 632
2.打开后，创建一个变量，注意该变量的引用类型设置一下，我们还要选中该变量，在右侧细节栏，处把默认改为键或者输入英文keys，并勾选可编辑实例。2.打开主界面，创建一个导航网格体积，上一章都有讲，在添加体积这里面，找到导航网格体积，点击创建，自己弄范围，可以看到，我图下是绿色的就行了。我们就需要加一个selector判断条件，无论是否为真假，后面的都执行，而唯有自己为真执行自己，为假，自己单独不执行。为了更好的设置敌人的转向，如果你的敌人是复制的其他角色的蓝图，那么你需要更改一下它的控制器。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

楚江_wog1st

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值