UE4和C++ 开发-新手常用C++API

//C++暴露给蓝图可编辑
UCLASS(Blueprintable)
 
//创建FString
FString::Printf(TEXT("aa bb"));
 
蓝图调用变量
UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
 
限制条件范围
meta = (ClampMin=0.1,ClampMax = 100)
 
蓝图识别组件
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "XXX")
 
返回物理材质
EPhysicalSurface SurfaceType = UPhysicalMaterial::DetermineSurfaceType(Hit.PhysMaterial.Get());
 
开放给编辑器时的类型，而不是某一个引用
TSubClassOf<UObject>
 
软引用
TSoftObjectPtr<UObject>
TSoftClassPtr <UObject>
 
蓝图调用函数
UFUNCTION(BlueprintCallable, Category = "XXX")
 
强制GC
GEngine->ForceGarbageCollection(true);
 
设置子Actor
HandObject->SetChildActorClass(ASlAiHandObject::StaticClass());
 
继承父类
Super::Xxx();  
 
物体投射阴影
void UPrimitiveComponent::SetCastShadow(bool NewCastShadow)
 
获取组件
GetComponentByClass(UXXXComponent::StaticClass());
 
输入参数为UWorld（const UObject* WorldContextObject）时
UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull);
    if (World == nullptr)
        return nullptr;
 
调整Tick间隔为1秒
PrimaryActorTick.TickInterval = 1.0f;
 
循环输出ForEachLoop   FStringaa 
for(FString xx : FStringaa){}
 
设置鼠标点击输入模式（controlelr）
FInputModeGameOnly InputMode;
InputMode.SetConsumeCaptureMouseDown(true);
SetInputMode(InputMode);
 
碰撞体物理旋转锁定
BoxCollision->GetBodyInstance()->bLockZRotation = true;
 
本地化
NSLOCTEXT("namespace", "key", "value")
 
播放音效
UGameplayStatics::SpawnSoundAttached(soundcue,RootComponent);
 
向量长度
Fvector.size();
 
查找子widget
widgettree->FindName
 
Widget的初始化函数
public:
    virtual bool Initialize() override;
protected:
    Widget的tick函数
    virtual void NativeTick(const FGeometry& MyGeometry, float InDeltaTime) override;
    virtual void NativePreConstruct()override;
    virtual void NativeConstruct()override;
UPROPERTY(Meta = (BindWidget)) (绑定UMG中名字叫MyBtn的按钮)
UButton* MyBtn;
 
例：void BeginDestroy() override;
void AmyActor::BeginDestroy()
{
Super::BeginDestroy();
UE_LOG(LogTemp, Warning, TEXT("Game exit!"));
}
 
C++调用蓝图函数
首先创建C++为基类，蓝图继承后创建一个函数Test
#include "OutputDevice.h"
FString cmd = FString::Printf(TEXT("BB CD"));
 
//BB函数名，CD参数
FOutputDeviceDebug device;
CallFunctionByNameWithArguments(*cmd, device, NULL, true);
 
蓝图重载C++函数(可以在C++中其他位置调用一个目前没有任何功能的函数（事件），而该函数的具体实现交给蓝图实现)
UFUNCTION(BlueprintImplementableEvent)       
void OnTest(); 
 
在蓝图中Add Event，找到对应的函数名，创建后即可实现具体逻辑
然后也可以在自己的C++代码中调用该方法
void MyActor::OnPressed()
{
OnTest();
}
 
蓝图添加默认的C++实现（C++在调用了SomeFunction()的地方先调用SomeFunction_Implementation的实现，但如果在蓝图中定义了SomeFunction事件（即使后面不连接任何内容），则会忽略C++中SomeFunction_Implementation中的实现，只采用蓝图中的实现）
UFUNCTION(BlueprintNativeEvent, Category = "SomeCategory")
 void SomeFunction();
void AMyActor::SomeFunction_Implementation() 
{ 
UE_LOG(LogTemp, Warning, TEXT("Implenetaion in C++")); 
}
loadstreamlevel的百分比调用
GetAsyncLoadPercentage(PackageName)
 
获取控制器
UGameplayStatics::GetPlayerController(GWorld, 0)；(->GetWorld())
 
获取默认蓝图类
HUDClass = AXXXHUD::StaticClass();
 
获取项目名字
FApp::GetProjectName();
 
判断Actor是蓝图还是C++
Actor->GetClass.IsNative();
 
按键
GetWorld()->GetFirstPlayerController()->WasInputKeyJustPressed(Key)
GetWorld()->GetFirstPlayerController()->WasInputKeyJustReleased(Key) 
 
确保内容存在，否则中断代码
ensure(XX)
 
鼠标在屏幕中的位置
#include "Engine/GameEngine.h"
#include "Engine/Engine.h"
 
FVector2D MousePosition;
GEngine->GameViewport->GetMousePosition(MousePosition);
MousePosition=MousePosition/DPIScale;
 
判断当前游戏运行模式
GetWorld()->WorldType
 
失焦后声音还能播放
GConfig->GetFloat(TEXT("Audio"), TEXT("UnfocusedVolumeMultiplier"), UnfocusedVolumeMultiplier, GEngineIni);
或者在DefaultEngine.ini中添加
[Audio]
UnfocusedVolumeMultiplier=1.0
 
加载地图
UGameplayStatics::OpenLevel(GetWorld(), *mapName);
 
获取角色位置和方向
GetWorld()->GetFirstPlayerController()->GetPlayerViewPoint(PawnLocation,PawnRotation);//面朝的方向
 
当前帧
#include "Engine/World.h"
 
GetWorld()->DeltaTimeSeconds
 
当前旋转量
this->GetActorForwardVector().Rotation()
 
单位向量
PawnRotation.Vector();
PawnVector.GetSafeNormal();
 
获取速度
auto ForwardSpeed = FVector::DotProduct(MoveVelocityNormal, AIForwardNormal);
 
运行命令行
GetWorld()->GetFirstPlayerController()->ConsoleCommand("quit");
打印
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Yellow, FString::Printf(TEXT("%s"),*FString));
#include "Misc/OutputDevice.h"
GLog->Logf(TEXT("%s"), *Filepath);
FMessageLog("MyLog").Warning(FText::FromString(TEXT("这是一条新的信息")));
 
限制函数
FMath::Clamp<float>(A1 + A2, 0.0, 1.0);
 
设置位置
SetActorLocation(FVector(0.0f, 0.0f, 250.0f));
 
打开EXE
FString pathrul = FPaths::RootDir() + url;
FPlatformProcess::ExecProcess(*QQ, nullptr, nullptr, nullptr, nullptr);
FPlatformProcess::CreateProc(*url, nullptr, true, false, false, nullptr, -1, nullptr, nullptr);
 
添加到控制台函数
#include <windows.h>
#include <iostream>
 
UFUNCTION(Exec, Category = "AActor")
ShellExecute(NULL, NULL, (*pathrul), NULL, NULL, SW_SHOWDEFAULT);
 
覆盖Actor控制台函数
virtual bool ProcessConsoleExec(const TCHAR* Cmd, FOutputDevice& Ar, UObject* Executor) override;
 
bool UMyGameInstance::ProcessConsoleExec(const TCHAR* Cmd, FOutputDevice& Ar, UObject* Executor)
{
    bool Res = Super::ProcessConsoleExec(Cmd, Ar, Executor);
    if (!Res)
    {
        //获取场景对象方法一: 
        for (TActorIterator<AMyCharacter> It(GetWorld()); It; ++It)
        {
            Res = It->ProcessConsoleExec(Cmd, Ar, Executor);
        }
        //获取场景对象方法二:
        /*TArray<AActor*> ActArray;
        UGameplayStatics::GetAllActorsOfClass(GetWorld(), AMyCharacter::StaticClass(), ActArray);
        for(AActor* Act : ActArray) Act->ProcessConsoleExec(Cmd, Ar, Executor);*/
    }
    return Res;
}
 
判断exe是那个端
ENetMode netMode = GetNetMode();
switch(netMode)
{
case NM_Standalone :
 
print 单独端, 单机游戏
NM_DedicatedServer 专用服务器
NM_ListenServer 监听服务器
NM_Client 客户端
NM_MAX
}
 
MD5加密
FMD5::HashAnsiString(TEXT("someStuff"));
 
加载完地图回调
void UMyGameInstance::Init()
{
	Super::Init();
	//FCoreUObjectDelegates::PreLoadMap.AddUObject(this, &UMyGameInstance::BeginLoadingScreen);
	FCoreUObjectDelegates::PostLoadMapWithWorld.AddUObject(this, &UMyGameInstance::EndLoadingScreen);
}
void UMyGameInstance::EndLoadingScreen(UWorld* InLoadedWorld)
{
	UE_LOG(LogTemp, Warning, TEXT("END23131312"));
}
 
hashi加密
FString HashStringWithSHA1(const FString &InString)
{
FSHAHash StringHash;
FSHA1::HashBuffer(TCHAR_TO_ANSI(*InString), InString.Len(), StringHash.Hash);
return StringHash.ToString();
}
 
传一个Object蓝图
UPROPERTY(BlueprintReadWrite,EditAnywhere,Category = "XX")
TSubclassOf<class SkillHelperObject>SkillBlueprintHelperObject;
 
路径
FString Str2 = FString::Printf(TEXT("Texture2D'/Game/pan/Frame_%05d.Frame_%05d'"),textName)
 
结构体
USTRUCT(Blueprintable)
struct MyStruct
{
GENERATED_USTRUCT_BODY()
//GENERATED_BODY()
public:
UPROPERTY(BlueprintReadWrite,EditAnywhere,Category = "XX")
int intCode;
UPROPERTY(BlueprintReadWrite,EditAnywhere,Category = "XX")
TMap<int, FString> Parameters;
};
 
创建结构体
FMyStruct* MyStruct = new FMyStruct();
查找场景中的Actor
AActor * AMyActor::FindActor(FString Actorname)
{
AActor* mActor = NULL;
if (GetWorld())
{
for (TActorIterator<AActor> It(GetWorld()); It; ++It)
{
AActor* xActor = *It;
if (xActor->GetName() == Actorname)
{
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, TEXT("Get it"));
mActor = xActor;
break;
}
}
if (!mActor)
{
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, TEXT("No Get it"));
}
return  mActor;
}
else
{
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, TEXT("NO getworld"));
return nullptr;
}
}
 
查找场景中的Actor2
#include "Kismet/GameplayStatics.h"
 
TArray<AActor*> PlayerStarts;
UGameplayStatics::GetAllActorsOfClass(GetWorld(), APlayerStart::StaticClass(), PlayerStarts);
if (PlayerStarts.Num() > 0)
    {
        APlayerStart* playerStart= Cast<APlayerStart>(PlayerStarts[0]);
    }
 
设置暂停
SetPause(true);
 
绑定按键（PS：需要在Pawn或Character里）
void AMyActor::SetupPlayerInputComponent(class UInputComponent* InputComponent)
{
InputComponent->BindKey(EKeys::Z, IE_Released, this, &AMyActor::OpenURL);
InputComponent->BindAction("Grow", IE_Released, this, &AMyActor::OpenURL);//.bExecuteWhenPaused = true;在暂停是依旧能运行
InputComponent->BindAxis("back", this, &AMyActor::OpenURL);
}
 
返回多个值，引用
void AMyActor::MoreReturn(FString& A, bool& B)
{
}
 
Udata->AddToRoot();//防止GC回收
Udata->RegisterWithGameInstance((UObject*)WorldContextObject);//防止GC回收
 
蓝图显示中文枚举类（VS文件-高级保存选项UTF-8格式）
UENUM(BlueprintType)
enum class EenumChinese :uint8 
{
E_EN UMETA(DisplayName = "英文"),  
E_CH UMETA(DisplayName = "中文"),  
};
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "enumChinese")
EenumChinese enumChinese;
 
双选项枚举类
UENUM(BlueprintType)
enum class EMyEnum : uint8
{
BranchA,
BranchB,
};
UFUNCTION(BlueprintCallable, Category = "My|MyActor", Meta = (ExpandEnumAsExecs = "Branches"))
void BranchFun(int32 Input, EMyEnum& Branches);
void AMyActor::BranchFun(int32 Input, EMyEnum& Branches)
{
if (Input == 1)
{
Branches = EMyEnum::BranchA;
}
else
{
Branches = EMyEnum::BranchB;
}
}
 
循环迭代
for (TArray<USoundCue*>::TIterator It(MenuAudioResource.Find(FString("Sound"))->CreateIterator()); It; ++It)
        {
            (*It)->VolumeMultiplier = SoundVolume;
        }
 
迭代controller
for (FConstPlayerControllerIterator It = GetWorld()->GetPlayerControllerIterator(); It; It++){AXXPlayerController* PC = Cast<AXXPlayerController>(It->Get());}
LOG
UE_LOG(LogTemp, Warning, TEXT("Info= %s"), *t_str[i]);
DEFINE_LOG_CATEGORY(LogMySlate);
UE_LOG(LogMySlate, Warning, TEXT("Found UObject named"));
 
蓝图打印
#include"MessageLog.h"
 
FMessageLog("DebugLog_FMessageLog").Warning(FText::FromString(MyString));
生成类
TestObjectActor = GWorld->SpawnActor<AActor >(TestBlueprint);
UWorld* const World = GetWorld();
AActor* GridCube = World->SpawnActor<AActor>(GridCubeClass2, FVector(0.0f, 90.0f, 50.0f), FRotator(0.0f, 0.0f, 0.0f));
读取Texture2D
UTexture2D* texture22 = Cast<UTexture2D>(StaticLoadObject(UTexture2D::StaticClass(), NULL, *(Path)));
获得名字
 
Actor->GetName() == TEXT("FloatActor_1")
 
获取相机
 
GetWorld()->GetFirstPlayerController()->PlayerCameraManager
 
强制转换
PTGameInstance = Cast<UPTGameInstance>(World->GetGameInstance());
 
设置碰撞类型
SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
 
设置碰撞属性
 
SetCollisionProfileName(FName("NoCollision"));
 
设置碰撞属性
MeshFirst->SetCollisionObjectType(ECC_Pawn);
MeshFirst->SetCollisionEnabled(ECollisionEnabled::NoCollision);
MeshFirst->SetCollisionResponseToAllChannels(ECR_Ignore);
构造函数添加组件
 
RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Center"));
 
动态创建UObject
UMyObject*NewObj=NewObject<UMyObject>();
 
动态创建Object
 
FMyObject*NewObj= new FMyObject();
 
查找类
 
UClass* ActorRef = FindObject<UClass>(ANY_PACKAGE,*FString("AActor"));
 
找蓝图Actor
 
UClass* aa = LoadClass<UUserWidget>( NULL, TEXT( "Blueprint'/Game/UMG/MainMenu.MainMenu_C'" ) );    (蓝图动态资源加载)  
static ConstructorHelpers::FObjectFinder<UBlueprint> assetObject(TEXT("/Game/Maps/test.test_C")); (蓝图构造函数资源加载)
if (assetObject.Succeeded())
{
TestBlueprint = (UClass*)assetObject.Object->GeneratedClass;
}
找材质(UObject构造函数资源加载)
static ConstructorHelpers::FObjectFinder<UMaterial> MaterialAsset(TEXT("/Game/Maps/MAT.MAT"));
if (MaterialAsset.Succeeded())
{
Material = (UMaterial*)MaterialAsset.Object;
}
 
(UObject动态资源加载)
 
LoadObject<>();
 
创建动态材质
UMaterialInstanceDynamic* MiniMapMatDynamic = UMaterialInstanceDynamic::Create(MiniMapMatInst, nullptr);
 
绑定材质属性
  MiniMapMatDynamic->SetTextureParameterValue(FName("MiniMapTex"), MiniMapRender);
 
组件附加
 
SphereComp->SetupAttachment(MeshComp);
 
等待销毁时从控制器移除角色控制
 
DetachFromControllerPendingDestroy();
 
设置角色生命周期
 
SetLifeSpan(10.0f);
 
获取音乐设备
AudioDevice = GEngine->GetMainAudioDevice();
 
推送混音器到设备
AudioDevice->PushSoundMixModifier(SlAiSoundMix);
 
使用混音器来设置
AudioDevice->SetSoundMixClassOverride(SlAiSoundMix, SlAiMusicClass, MusicVolume, 1.f, 0.2f, false);
 
编辑器改变UPROPERTY参数时调用的函数
 
#if WITH_EDITOR
    virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
 
#if WITH_EDITOR
void AMyCharacter::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent)
{
    Super::PostEditChangeProperty(PropertyChangedEvent);
    if (PropertyChangedEvent.Property && PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(AMyCharacter, Mynum))
    {
        Mynum2+= 10;
    }
}
#endif
 
屏幕大小
 
GetWorld()->GetFirstPlayerController()->GetViewportSize(ViewportSizeX,ViewportSizeY);
重力
SetEnableGravity(false);
 
随机数
 
FRandomStream Stream;
 
//产生新的随机种子
Stream.GenerateNewSeed();
 
int RandIndex = Stream.RandRange(0, ResourcePath.Num() - 1);
 
删除AIController
 
DetachFromControllerPendingDestroy();
 
进入观察者模式
 
StartSpectatingOnly();
 
复制资源
 
UBehaviorTree* myBehaviorTree = DuplicateObject<UObject>(object,NULL)
 
退出游戏
 
UKismetSystemLibrary::QuitGame(this, nullptr, EQuitPreference::Quit);
 
GEngine->Exec(GWorld, *FString("Exit"));
 
获取游戏时间
 
double MyTime = FPlatformTime::Seconds;
 
获取时间
 
FDateTime::Now().ToString();
链接URL
FString TheURL = "xxxxxxxx";
FPlatformProcess::LaunchURL(*TheURL, nullptr, nullptr);
 
创建UI   "Media", "MediaAssets"
 if (nullptr == MainMenuWidget)    
{        
UClass* aa = LoadClass<UUserWidget>( NULL, TEXT( "Blueprint'/Game/UMG/MainMenu.MainMenu_C'" ) );        
MainMenuWidget = CreateWidget<UUserWidget>( GetWorld()->GetFirstPlayerController(), aa );    
}    
MainMenuWidget->AddToViewport(); 
//http://blog.csdn.net/zilisen/article/details/77645500
 
OR：
 
UPROPERTY(EditAnywhere, Category = "AA")
        TSubclassOf<class UMyHUDWidget> HUDWidgetClass;
 
UMyHUDWidget* HUDWidget = CreateWidget<UMyHUDWidget>(GetWorld(), HUDWidgetClass);
 
子弹函数
 
#include "Kismet/GameplayStatics.h"
 
UGameplayStatics::SuggestProjectileVelocity(
this,
FireVector,
StartLocation,
EndLocation,
Speed,
false,
0,
0,
ESuggestProjVelocityTraceOption::DoNotTrace
 
);
 
绘制射线
 
#include "DrawDebugHelpers.h"
 
DrawDebugLine(
GetWorld(),
StartLocation1,
EndLocation1,
FColor(255, 0, 0),
false,
0.0f,
0.0f,
10.0f
 
);
 
FCollisionQueryParams QueryParameter = FCollisionQueryParams("", false, GetOwner());
FHitResult HitResult;
GetWorld()->LineTraceSingleByChannel(
HitResult,
StartLocation2,
EndLocation2,
FCollisionObjectQueryParams(ECollisionChannel::ECC_PhysicsBody),
QueryParameter
)
 
游戏运行中开启作弊等命令
 
static int32 DebugWeaponDrawing = 0;
FAutoConsoleVariableRef CVARDebugWeaponDrawing(
    TEXT("COOP.DebugWeapons"), 
    DebugWeaponDrawing, 
    TEXT("Draw Debug Lines for Weapons"), 
    ECVF_Cheat);
 
if(DebugWeaponDrawing >0){...}
 
计时器
 
#include "TimerManager.h"
 
FTimerHandle CountdownTimerHandle;
GetWorldTimerManager().SetTimer(CountdownTimerHandle, this, &AMytestActor::AdvanceTimer, 1.0f, true);
 
FTimerDelegate timeDele ;//  定义调用的委托
 
timeDele.BindRaw(this,&xxx:ffff); //绑定函数到委托
GWorld->GetTimerManager().UnPauseTimer(mTimer); //唤醒   GetWorld()
float elapsed = GWorld->GetTimerManager().GetTimerElapsed(mTimer); //已逝时间
float elapsed = GWorld->GetTimerManager().GetTimerRemaining(mTimer); //剩余时间
bool isActive = GWorld->GetTimerManager().IsTimerActive(mTimer); //激活
bool isPaused = GWorld->GetTimerManager().IsTimerPaused(mTimer); //暂停
bool isExist = GWorld->GetTimerManager().TimerExists(mTimer); //存在
 
GetWorldTimerManager().ClearTimer(CountdownTimerHandle);//停止计时器
 
伤害
 
#include<Engine/World.h>
 
UGameplayStatics::ApplyRadialDamage(
this,
ActorDamage,
GetActorLocation(),
Radius,
UDamageType::StaticClass(),
TArray<AActor*>()//友军
)
 
获取IP地址
需要在build.cs添加Sockets模块
#include "SocketSubsystem.h"
#include "IPAddress.h"
FString IpAddr("NONE");
  bool canBind = false;
  TSharedRef<FInternetAddr> LocalIp = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetLocalHostAddr(*GLog, canBind);
  if (LocalIp->IsValid())
  {
IpAddr = LocalIp->ToString(false); //（如果想附加端口就写 ture）
}
return IpAddr;
添加标签
MyActor.Tags.AddUnique(TEXT("MyTag"));  
销毁物体
MyActor->Destroy();
MyActor->SetLifeSpan(1);//延迟1S
截图
FString UMyBlueprintFunctionLibrary::TakeScreenShoot(FString picName, bool bUnique /*= true*/)
{
FString inStr;
FString Filename;
FScreenshotRequest::RequestScreenshot(picName + ".png", false, bUnique);
FString ResultStr = FScreenshotRequest::GetFilename();
ResultStr = FPaths::GetBaseFilename(ResultStr, true);
return ResultStr + ".png";
 
}
 
void UMyBlueprintFunctionLibrary::Screenshot(const FString InFilename, bool bInShowUI)
{
FScreenshotRequest SR = FScreenshotRequest();
FString savelocation = FPaths::ConvertRelativePathToFull(FPaths::GameDir());
FString filename = savelocation + FString(TEXT("/Saved/Screenshotss/")) + InFilename + FString(TEXT(".png"));
SR.RequestScreenshot(filename, bInShowUI, false);
}
 
写入配置文件，有GEditorIni,GEditorProjectIni,GCompatIni,GlightmassIni,GScalabilityIni,GHardwareIni,GInputIni,GGameIni,GGameUserSettingsIni等(查找CoreGlobals.h)
写的数据会写到 YourGame\Saved\Config\Windows\Game.ini 中
    const FString WriteSection = "MyCustomSection";
    //String
    GConfig->SetString(
        *WriteSection,
        TEXT("key1"),
        TEXT("Hello world"),
        GGameIni
    );
    GConfig->Flush(false, GGameIni);
读取配置
if (!GConfig) return 0;
float ValueReceived ;
GConfig->GetFloat(
TEXT("MyCustomSection"),
TEXT("key1"),
ValueReceived,
GGameIni
);
return ValueReceived;
 
服务器：
 
判断是否在服务端运行
 
GetWorld()->IsServer()
 
网络更新频率
 
NetUpdateFrequency = 66.0f;
 
MinNetUpdateFrequency = 33.0f;
 
枚举字节化
 
TEnumAsByte<Eenum> AA;
 
让矢量服务器传输不用那么精确
 
FVector_NetQuantize   vectorr；
 
复制变量到服务器
 
UPROPERTY(Replicated)
 
在服务器上运行函数
 
UFUNCTION(Server, Reliable, WithValidation)//NetMulticast
 
void Server();
 
void XXX::ServerFire_Implementation(){}
 
bool XXX::ServerFire_Validate(){return true;}//完整性检查才用到
 
判断是否在服务器上运行（Actor是否主机）
 
Role == ROLE_Authority
 
判断是否在客户端上运行
 
Role < ROLE_Authority
 
服务器变量改了通知客户端调用函数
 
UPROPERTY(ReplicatedUsing=OnRep_GuardState)
 
UFUNCTION()
    void OnRep_GuardState();
 
             规则：所有的客户端  #include "Net/UnrealNetwork.h"
void XXX::GetLifetimeReplicatedProps(TArray< FLifetimeProperty > & OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(XXX（AActor）, 变量);
 
//DOREPLIFETIME_CONDITION(XXX（AActor）, 变量,COND_SkipOwner);
}
 
Slate：
 
创建slate
 
TSharedPtr<class SSlAiMenuHUDWidget> MenuHUDWidget;
 
ASlAiMenuHUD::ASlAiMenuHUD()
{
    if (GEngine && GEngine->GameViewport) {
        SAssignNew(MenuHUDWidget, SSlAiMenuHUDWidget);
 
        GEngine->GameViewport->AddViewportWidgetContent(SNew(SWeakWidget).PossiblyNullContent(MenuHUDWidget.ToSharedRef()));
 
    }
}
 
播放动画
 
MenuAnimation = FCurveSequence();
MenuCurve = MenuAnimation.AddCurve(StartDelay, AnimDuration, ECurveEaseFunction::QuadInOut);
 
MenuAnimation.Play(this->AsShared());
 
把图片导入ImageSlot
 
SOverlay::FOverlaySlot* ImageSlot;
 
.Expose(ImageSlot)
 
点击事件
 
.OnClicked(this, &XXX::OnClick)
 
添加嵌套UMG控件到Slate控件里
 
ChildSlot[umgWidget->TakeWidget()];
 
添加slate到游戏窗口
 
GEngine->GetWorldFromContextObject(this, EGetWorldErrorMode::LogAndReturnNull)->GetGameViewport()->AddViewportWidgetContent(slateWidget);
 
内嵌到Slate控件内
 
slateWidget->AddWidget(umgWidget);
 
设置锚点
 
.Anchors(FAnchors(0.f))
 
创建按钮
 
+ SOverlay::Slot()
 
[
 
SNew(SButton)
 
]
 
布局
 
.HAlign(HAlign_Left)
.VAlign(VAlign_Top)
 
创建外部调用Slate
 
TSharedPtr<SCheckBox> ZhCheckBox;//.h
 
SAssignNew(ZhCheckBox,SCheckBox)
 
获取TWeakPtr实例
 
TWeakPtr< Sxxx>  xxx;
 
xxx.pin();
 
转换为共享指针
 
TShareRef<Faa> aaRef = MakeShareable(new Faa);
 
TSharePtr<Faa> aaPtr = aaRef ;
 
转换为共享引用
 
TSharePtr<Faa> aaPtr= MakeShareable(new Faa);
 
TShareRef<Faa> aaRef = aaPtr.ToSharedRef();
 
获取声音资源文件
 
FSlateSound.GetResourceObject()
 
FGeometry里面保存了Widget位置大小等属性
 
在鼠标事件中获取鼠标相对widget的位置
 
MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition());
 
获取DPI
 
UWidgetLayoutLibrary::GetViewportScale(GEngine->GameViewport);
 
获取Widget之间的相对位置
 
FVector2D StartPos = WidgetA.AbsoluteToLocal(WidgetB->GetCachedGeometry().AbsolutePosition);
 
获取资源
 
FSlateApplication::Get().
 
AI行为树：
 
黑板:
 
#include "BehaviorTree/Blackboard/BlackboardKeyType_Enum.h"
#include "BehaviorTree/Blackboard/BlackboardKeyType_Vector.h"
#include "BehaviorTree/Blackboard/BlackboardKeyType_Float.h"
#include "BehaviorTree/Blackboard/BlackboardKeyType_Object.h"
#include "BehaviorTree/Blackboard/BlackboardKeyType_Bool.h"
 
void UEnemyBlackboard::PostLoad()
{
    Super::PostLoad();
 
    //目的地
    FBlackboardEntry Destination;
    Destination.EntryName = FName("Destination");
    UBlackboardKeyType_Vector* DestinationKeyType = NewObject<UBlackboardKeyType_Vector>();
    Destination.KeyType = DestinationKeyType;
 
    //敌人状态
    FBlackboardEntry EnemyState;
    EnemyState.EntryName = FName("EnemyState");
    UBlackboardKeyType_Enum* EnemyStateKeyType = NewObject<UBlackboardKeyType_Enum>();
    EnemyStateKeyType->EnumType = FindObject<UEnum>(ANY_PACKAGE, *FString("EEnemyAIState"), true);
    EnemyStateKeyType->EnumName = FString("EEnemyAIState");
    EnemyState.KeyType = EnemyStateKeyType;
 
}
 
UBTDecorator:
 
//对应的就是蓝图节点的PerformConditionCheck
        virtual bool CalculateRawConditionValue(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const override;
 
使用导航系统获取随机点
    UNavigationSystem::K2_GetRandomReachablePointInRadius(SEController, ChaseOrigin, DesLoc, ChaseRadius);
 
重写task执行函数
 
virtual EBTNodeResult::Type ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) override;
 
 
 
保存文件4.24（编辑器）
 
UDataTable* saveTble;
        TArray<UPackage*> PackagesToSave;
        PackagesToSave.Add(saveTble->GetOutermost());
        UEditorLoadingAndSavingUtils::SavePackages(PackagesToSave, false);
        UE_LOG(LogTemp, Warning, TEXT("Save %s SUCCESS!"), *saveTble->GetName());