{

    "FileVersion": ,

    "Version": ,

    "VersionName": "0.0",

    "EngineVersion": "0.0.0-0",

    "PackageFileUE4Version": ,

    "PackageFileLicenseeUE4Version": ,

    "EngineAssociation": "",

    "FriendlyName": "",

    "Description": "",

    "Category": "",

    "CreatedBy": "",

    "CreatedByURL": "",

    "Modules": [

        {

            "Name": "StrategyGame",

            "Type": "Runtime",

            "LoadingPhase": "Default"

        },

        {

            "Name": "StrategyGameLoadingScreen", //这个是额外增加的module

            "Type": "Runtime",

            "LoadingPhase": "PreLoadingScreen" //从代码中找到解释, 这个module必须设置成这种类型, 否则不会 “hook in time”, 从字面意思来看,是预加载一直存在于内存中的;

        }

    ],

    "EpicSampleNameHash": "",

    "TargetPlatforms": [

        "Android",

        "IOS",

        "MacNoEditor",

        "WindowsNoEditor"

    ]

}

using UnrealBuildTool;

// This module must be loaded "PreLoadingScreen" in the .uproject file, otherwise it will not hook in time!

public class StrategyGameLoadingScreen : ModuleRules

{

    public StrategyGameLoadingScreen(TargetInfo Target)

    {

        PrivateIncludePaths.Add("../../StrategyGame/Source/StrategyGameLoadingScreen/Private");

        PublicDependencyModuleNames.AddRange(

            new string[] {

                "Core",

                "CoreUObject",

                "Engine"

            }

        );

        PrivateDependencyModuleNames.AddRange(

            new string[] {

                "MoviePlayer",

                "Slate",

                "SlateCore",

                "InputCore"

            }

        );

    }

}

        PrivateDependencyModuleNames.AddRange(

            new string[] {

                "StrategyGameLoadingScreen"

            }

        );

void AStrategyMenuHUD::ShowLoadingScreen()

{

    IStrategyGameLoadingScreenModule* LoadingScreenModule = FModuleManager::LoadModulePtr<IStrategyGameLoadingScreenModule>("StrategyGameLoadingScreen");

    if( LoadingScreenModule != nullptr )

    {

        LoadingScreenModule->StartInGameLoadingScreen();

    }

}

    // Load up all modules that need to hook into the loading screen

    if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PreLoadingScreen) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PreLoadingScreen))

    {

        return ;

}

    enum Type

    {

        /** Loaded before the engine is fully initialized, immediately after the config system has been initialized.  Necessary only for very low-level hooks */

        PostConfigInit,

        /** Loaded before the engine is fully initialized for modules that need to hook into the loading screen before it triggers */

        PreLoadingScreen,

        /** Right before the default phase */

        PreDefault,

        /** Loaded at the default loading point during startup (during engine init, after game modules are loaded.) */

        Default,

        /** Right after the default phase */

        PostDefault,

        /** After the engine has been initialized */

        PostEngineInit,

        /** Do not automatically load this module */

        None,

        // NOTE: If you add a new value, make sure to update the ToString() method below!

        Max

};

bool FEngineLoop::LoadStartupModules()

{

    FScopedSlowTask SlowTask();

    SlowTask.EnterProgressFrame();

    // Load any modules that want to be loaded before default modules are loaded up.

    if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PreDefault) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PreDefault))

    {

        return false;

    }

    SlowTask.EnterProgressFrame();

    // Load modules that are configured to load in the default phase

    if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::Default) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::Default))

    {

        return false;

    }

    SlowTask.EnterProgressFrame();

    // Load any modules that want to be loaded after default modules are loaded up.

    if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PostDefault) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PostDefault))

    {

        return false;

    }

    return true;

}

        MiniMapView = NewObject<UTextureRenderTarget2D>();

        MiniMapView->InitAutoFormat(MiniMapWidth,MiniMapHeight);

        GetCaptureComponent2D()->TextureTarget = MiniMapView;

#if WITH_EDITOR

void AStrategyMiniMapCapture::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)

{

    Super::PostEditChangeProperty(PropertyChangedEvent);

    UProperty* PropertyThatChanged = PropertyChangedEvent.Property;

    FName PropertyName = PropertyThatChanged != nullptr ? PropertyThatChanged->GetFName() : NAME_None;

    if (PropertyName==FName(TEXT("RelativeRotation")))

    {

        FRotator ChangedRotation = RootComponent->GetComponentRotation();

        RootComponent->SetWorldRotation(FRotator(-,,ChangedRotation.Roll));

    }

}

void AStrategyMiniMapCapture::EditorApplyRotation(const FRotator& DeltaRotation, bool bAltDown, bool bShiftDown, bool bCtrlDown)

{

    FRotator FiltredRotation(, DeltaRotation.Yaw, );

    Super::EditorApplyRotation(FiltredRotation, bAltDown, bShiftDown, bCtrlDown);

}

#endif

const FPlane GroundPlane = FPlane(FVector(,,GroundLevel), FVector::UpVector);

FViewport* const Viewport = GEngine->GameViewport->ViewportFrame->GetViewport();

FVector2D const ScreenRes = Viewport->GetSizeXY();

FVector RayOrigin, RayDirection;

FVector2D const ScreenCenterPoint = ScreenRes * 0.5f;//获取屏幕中心点

FStrategyHelpers::DeprojectScreenToWorld(ScreenCenterPoint, MyPlayer, RayOrigin, RayDirection);//屏幕中心点坐标转换到世界空间,传出世界空间中的射线始点与方向,其内部:

        FSceneViewProjectionData ProjectionData;

        if (Player->GetProjectionData(Player->ViewportClient->Viewport, eSSP_FULL, /*out*/ ProjectionData))

        {

            const FMatrix ViewMatrix = FTranslationMatrix(-ProjectionData.ViewOrigin) * ProjectionData.ViewRotationMatrix;

            const FMatrix InvViewMatrix = ViewMatrix.InverseFast();

            const FMatrix InvProjectionMatrix = ProjectionData.ProjectionMatrix.InverseFast();

            FSceneView::DeprojectScreenToWorld(ScreenPosition, ProjectionData.GetConstrainedViewRect(), InvViewMatrix, InvProjectionMatrix, /*out*/ RayOrigin, /*out*/ RayDirection);

            return true;

        }

FVector const WorldPoint = FStrategyHelpers::IntersectRayWithPlane(RayOrigin, RayDirection, GroundPlane);//在世界空间进行射线与平面检测

            FCanvasTileItem MapTileItem( FVector2D( 0.0f, 0.0f), FVector2D( 0.0f, 0.0f ), FLinearColor::White );

            MapTileItem.Texture = MiniMapTexture->Resource;

            MapTileItem.Size = FVector2D( MapWidth, MapHeight );

            MapTileItem.BlendMode = SE_BLEND_Opaque;

            Canvas->DrawItem( MapTileItem, FVector2D( MiniMapMargin * UIScale, Canvas->ClipY - MapHeight - MiniMapMargin * UIScale ) )

const FSlateBrush*  SStrategyButtonWidget::GetButtonImage() const

{

    if (ButtonImage.IsValid())

    {

        return ButtonImage.Get();

    }

    else

    {

        return FStrategyStyle::Get().GetBrush("DefaultActionImageBrush");

    }

}

    SLATE_BEGIN_ARGS(SStrategyButtonWidget)

    {}

    /* Owning HUD for getting Game World */

    SLATE_ARGUMENT(TWeakObjectPtr<AStrategyHUD>, OwnerHUD)

    SLATE_DEFAULT_SLOT(FArguments, Content)

    /** called when the button is clicked */

    SLATE_EVENT(FOnClicked, OnClicked)//这个是自定义的新事件并自动被delegate，其实在SWidget里面有OnMouseButtonDown这样的虚函数已经托管好了，重载即可，这里拿来理解怎样新增自己事件以及绑定好回调函数

    /** text on the button */

    SLATE_ATTRIBUTE(FText, ButtonText)

    SLATE_END_ARGS()

        AStrategyPlayerController* const PC = Cast<AStrategyPlayerController>(GEngine->GetFirstLocalPlayerController(OwnerHUD.Get()->GetWorld()));

        AStrategyGameState const* const MyGameState = PC && PC->GetWorld() ? PC->GetWorld()->GetGameState<AStrategyGameState>() : NULL;

        AStrategyHUD* const HUD = PC ? Cast<AStrategyHUD>(PC->MyHUD) : NULL;

SNew(SCanvas)

SNew(SBorder)

SAssignNew(ActionButtonsWidget,SStrategyActionGrid)

SAssignNew(MiniMapWidget,SStrategyMiniMapWidget)

SNew(SImage)

SAssignNew(PauseMenuButtons[ButtonIndex++], SStrategyButtonWidget)

    UConsole* ViewportConsole = (GEngine !=NULL && GEngine->GameViewport != NULL) ? GEngine->GameViewport->ViewportConsole : NULL;

    if (ViewportConsole != NULL && (ViewportConsole->ConsoleState == "Typing" || ViewportConsole->ConsoleState == "Open"))

    {

        FSlateApplication::Get().SetAllUserFocusToGameViewport();

        FSlateApplication::Get().SetKeyboardFocus(SharedThis(this));

    }

MenuStyle = &FStrategyStyle::Get().GetWidgetStyle<FStrategyMenuStyle>("DefaultStrategyMenuStyle");//注意这里是按照名字查找相关style的，也就是说，所有的widget style都应该放到一个map中，查找代码发现（SlateStyle.h，class SLATECORE_API FSlateStyleSet : public ISlateStyle）：

    FString CoreContentRootDir; /** This dir is Engine/Slate folder to share the items **/

    TMap< FName, TSharedRef< struct FSlateWidgetStyle > > WidgetStyleValues;

会把所有的slate widget style收集起来；

#define IMAGE_BRUSH( RelativePath, ... ) FSlateImageBrush( FPaths::GameContentDir() / "Slate"/ RelativePath + TEXT(".png"), __VA_ARGS__ )

#define BOX_BRUSH( RelativePath, ... ) FSlateBoxBrush( FPaths::GameContentDir() / "Slate"/ RelativePath + TEXT(".png"), __VA_ARGS__ )

#define BORDER_BRUSH( RelativePath, ... ) FSlateBorderBrush( FPaths::GameContentDir() / "Slate"/ RelativePath + TEXT(".png"), __VA_ARGS__ )

#define TTF_FONT( RelativePath, ... ) FSlateFontInfo( FPaths::GameContentDir() / "Slate"/ RelativePath + TEXT(".ttf"), __VA_ARGS__ )

#define OTF_FONT( RelativePath, ... ) FSlateFontInfo( FPaths::GameContentDir() / "Slate"/ RelativePath + TEXT(".otf"), __VA_ARGS__ )

AStrategyMenuGameMode::AStrategyMenuGameMode(const FObjectInitializer& ObjectInitializer)

    : Super(ObjectInitializer)

{

    //setup our custom PC and HUD

    PlayerControllerClass = AStrategyMenuPlayerController::StaticClass();

    HUDClass = AStrategyMenuHUD::StaticClass();

    SpectatorClass = AStrategySpectatorPawn::StaticClass();

}

GameDefaultMap=/Game/Maps/StrategyMenu

ServerDefaultMap=/Game/Maps/StrategyMenu

EditorStartupMap=/Game/Maps/TowerDefenseMap

GlobalDefaultGameMode="/Script/StrategyGame.StrategyGameMode"

WorldContext.World()->SetGameMode(URL);//看来似乎一个地图一个world就有一个game mode设定

bool UWorld::SetGameMode(const FURL& InURL)

{

    if( IsServer() && !AuthorityGameMode )

    {

        AuthorityGameMode = GetGameInstance()->CreateGameModeForURL(InURL);//这个URL里面包含了地图名StrategyMenu，此时正在加载这个地图，按这个函数名来看，似乎会依赖loadmap的地图信息弄出来个game mode

        if( AuthorityGameMode != NULL )

        {

            return true;

        }

        else

        {

            UE_LOG(LogWorld, Error, TEXT("Failed to spawn GameMode actor."));

            return false;

        }

    }

    return false;

}

AStrategyMenuGameMode::AStrategyMenuGameMode(const FObjectInitializer& ObjectInitializer)

    : Super(ObjectInitializer)

{

    //setup our custom PC and HUD

    PlayerControllerClass = AStrategyMenuPlayerController::StaticClass();

    HUDClass = AStrategyMenuHUD::StaticClass();

    SpectatorClass = AStrategySpectatorPawn::StaticClass();

}

void AStrategyMenuHUD::LaunchGame()

{

    FString StartStr = FString::Printf(TEXT("/Game/Maps/TowerDefenseMap?%s=%d"), *AStrategyGameMode::DifficultyOptionName, (uint8) Difficulty);

    GetWorld()->ServerTravel(StartStr);//这里准备加载游戏主地图

    ShowLoadingScreen();//但是主地图不会马上加载并显示进来，所以需要一个loading页面，按照之前的分析，这个loading screen是在另外一个module里面，另外的module也不一定是同一个线程

}

void AStrategyMenuHUD::ShowLoadingScreen()

{

    IStrategyGameLoadingScreenModule* LoadingScreenModule = FModuleManager::LoadModulePtr<IStrategyGameLoadingScreenModule>("StrategyGameLoadingScreen");//这里就载入了新的module，进入加载游戏的那个页面

    if( LoadingScreenModule != nullptr )

    {

        LoadingScreenModule->StartInGameLoadingScreen();

    }

}

/**

 * SensingComponent encapsulates sensory (ie sight and hearing) settings and functionality for an Actor,

 * allowing the actor to see/hear Pawns in the world. It does *not* enable hearing

 * and sight sensing by default.

 */

UCLASS(config=Game)

class UStrategyAISensingComponent : public UPawnSensingComponent

StrategyAIController.h:

DECLARE_DELEGATE_OneParam(FOnBumpEvent, FHitResult const&);

DECLARE_DELEGATE(FOnMovementEvent);

如此这样声明一个事件,然后比如” FOnMovementEvent”就成为一种类型,可以声明变量;

    FOnMovementEvent MovementDelegate;

    MovementDelegate.BindUObject(this, &UStrategyAIAction_MoveToBrewery::OnMoveCompleted);

    MyAIController->RegisterMovementEventDelegate(MovementDelegate);

[/Script/StrategyGame.StrategyGameMode]

TimeBeforeReturnToMenu=

[/Script/StrategyGame.StrategyGameState]

WarmupTime=

    /** Time before game returns to menu after finish. */

    UPROPERTY(config)

    int32 TimeBeforeReturnToMenu;

    /** Warm up time before game starts */

    UPROPERTY(config)

    int32 WarmupTime;

void AStrategyGameState::StartGameplayStateMachine()

{

    if (WarmupTime > .f)

    {

        SetGameplayState(EGameplayState::Waiting);

        GetWorldTimerManager().SetTimer(TimerHandle_OnGameStart, this, &AStrategyGameState::OnGameStart, WarmupTime, false);

    }

    else

    {

        OnGameStart();

    }

}

void AStrategyMenuHUD::LaunchGame()

{

    FString StartStr = FString::Printf(TEXT("/Game/Maps/TowerDefenseMap?%s=%d"), *AStrategyGameMode::DifficultyOptionName, (uint8) Difficulty);

    GetWorld()->ServerTravel(StartStr);//@Virtuos[wangsongwei]here we begin to load the main game map TowerDefenseMap

    ShowLoadingScreen();//@Virtuos[wangsongwei]since the main game map will not load and appear quickly, we need one loading screen, and this screen is in another module, but this also is same one thread

}

ServerTravel函数加载主游戏地图，初始化state，在初始化state时候有调用：

void AStrategyGameState::StartGameplayStateMachine()

{

    if (WarmupTime > .f)

    {

        SetGameplayState(EGameplayState::Waiting);

        GetWorldTimerManager().SetTimer(TimerHandle_OnGameStart, this, &AStrategyGameState::OnGameStart, WarmupTime, false);//这里设定的不是loading页面的显示时间，只是游戏正式开始的倒计时，其实是一个等待时间，时间到了，就调用这里设定的回调函数开始游戏

    }

    else

    {

        OnGameStart();

    }

}

    virtual void CreateScreen()

    {

        FLoadingScreenAttributes LoadingScreen;

        LoadingScreen.bAutoCompleteWhenLoadingCompletes = true;

        LoadingScreen.MinimumLoadingScreenDisplayTime = .f;//这个值是可以改变等待时间的，单位是秒

        LoadingScreen.WidgetLoadingScreen = SNew(SStrategyLoadingScreen);

        GetMoviePlayer()->SetupLoadingScreen(LoadingScreen);

    }

float const OrigCamFOV = OriginalPC->PlayerCameraManager->GetFOVAngle();

    /** Camera manager associated with this Player Controller. */

    UPROPERTY(BlueprintReadOnly, Category=PlayerController)

    class APlayerCameraManager* PlayerCameraManager;

    /** PlayerCamera class should be set for each game, otherwise Engine.PlayerCameraManager is used */

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=PlayerController)

    TSubclassOf<class APlayerCameraManager> PlayerCameraManagerClass;

AStrategyMenuPlayerController::AStrategyMenuPlayerController(const FObjectInitializer& ObjectInitializer)

    : Super(ObjectInitializer)

{

    // just use the normal camera...fine for now

    PlayerCameraManagerClass = APlayerCameraManager::StaticClass();

}

void APlayerController::UpdateCameraManager(float DeltaSeconds)

void APlayerCameraManager::UpdateCamera(float DeltaTime)

void APlayerCameraManager::DoUpdateCamera(float DeltaTime)

void APlayerCameraManager::UpdateViewTarget(FTViewTarget& OutVT, float DeltaTime)

void APlayerCameraManager::UpdateViewTargetInternal(FTViewTarget& OutVT, float DeltaTime)

void AActor::CalcCamera(float DeltaTime, FMinimalViewInfo& OutResult)

void UStrategyCameraComponent::GetCameraView(float DeltaTime, FMinimalViewInfo& OutResult)

{

    APlayerController* Controller = GetPlayerController();

    if( Controller )

    {

        OutResult.FOV = .f;

        const float CurrentOffset = MinCameraOffset + ZoomAlpha * (MaxCameraOffset - MinCameraOffset);//缩放整个场景主要改变ZoomAlpha这个值实现的

        FVector Pos2 = Controller->GetFocalLocation();

        OutResult.Location = Controller->GetFocalLocation() - FixedCameraAngle.Vector() * CurrentOffset;

        OutResult.Rotation = FixedCameraAngle;

    }

}

/** A ViewTarget is the primary actor the camera is associated with. */

USTRUCT()

struct ENGINE_API FTViewTarget

{ class AActor* Target; }

    /** Object that manages player input. */

    UPROPERTY(transient)

    class UPlayerInput* PlayerInput;  

FReply SStrategySlateHUDWidget::OnCheatAddGold() const

{

    FReply Reply = FReply::Unhandled();

    APlayerController* PlayerController = Cast<APlayerController>(OwnerHUD->GetWorld()->GetFirstPlayerController());

    if (PlayerController)

    {

        UStrategyCheatManager* CheatManager = Cast<UStrategyCheatManager>(PlayerController->CheatManager);

        if (CheatManager != nullptr)

        {

            CheatManager->AddGold();

            Reply = FReply::Handled();

        }

    }

    return Reply;

}

    UFUNCTION(exec)// This function is executable from the command line.

    void AddGold(uint32 NewGold);

    /** Object that manages "cheat" commands.  Not instantiated in shipping builds. */

    UPROPERTY(transient, BlueprintReadOnly, Category="Cheat Manager")

    class UCheatManager* CheatManager;

    /**  Enables cheats within the game */

    UFUNCTION(exec)

    virtual void EnableCheats();

类class UStrategyAIDirector : public UActorComponent里面有暴露给blueprint的函数SetDefaultWeapon, 具体是在level blueprint里面进行设定的;

void UStrategyAIDirector::SetDefaultWeapon(UBlueprint* InWeapon)//注意有这种UBlueprint类型

{

    DefaultWeapon = InWeapon ? *InWeapon->GeneratedClass : nullptr;//这种GeneratedClass的属性: /** Pointer to the 'most recent' fully generated class */UPROPERTY(nontransactional)TSubclassOf<class UObject>    GeneratedClass;

}

void UStrategyAIDirector::SetDefaultWeaponClass(TSubclassOf<UStrategyAttachment> InWeapon)

{

    DefaultWeapon = InWeapon;

}

    创建了一个component, class UStrategyAttachment : public USkeletalMeshComponent, 然后创建它相关的blueprint资源, 然后这个资源被SetDefaultWeapon 设定上去; 随后被真正attach到NPC身上:

                if (DefaultWeapon != nullptr)

                {

                    UStrategyGameBlueprintLibrary::GiveWeaponFromClass(MinionChar, DefaultWeapon);

                }

void UStrategyGameBlueprintLibrary::GiveWeaponFromClass(AStrategyChar* InChar, TSubclassOf<UStrategyAttachment> ArmorClass)

{

    if (InChar && *ArmorClass)

    {

        auto MyWeapon = NewObject<UStrategyAttachment>(InChar, *ArmorClass);

        InChar->SetWeaponAttachment(MyWeapon);

    }

}