public HarfBuzz(TargetInfo Target)
{
Type = ModuleType.External;
// Can't be used without our dependencies
if (!UEBuildConfiguration.bCompileFreeType || !UEBuildConfiguration.bCompileICU)
{
Definitions.Add("WITH_HARFBUZZ=0");
return;
}
string HarfBuzzVersion = "harfbuzz-1.2.4";
string HarfBuzzRootPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "HarfBuzz/" + HarfBuzzVersion + "/";
// Includes
PublicSystemIncludePaths.Add(HarfBuzzRootPath + "src" + "/");
string PlatformFolderName = Target.Platform.ToString();
string HarfBuzzLibPath = HarfBuzzRootPath + PlatformFolderName + "/";
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
HarfBuzzLibPath = HarfBuzzRootPath + "Win32/";
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32"))
{
Definitions.Add("WITH_HARFBUZZ=1");
string VSVersionFolderName = "VS" + WindowsPlatform.GetVisualStudioCompilerVersionName();
HarfBuzzLibPath += VSVersionFolderName + "/";
string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
? "Debug"
: "RelWithDebInfo";
HarfBuzzLibPath += BuildTypeFolderName + "/";
PublicLibraryPaths.Add(HarfBuzzLibPath);
PublicAdditionalLibraries.Add("harfbuzz.lib");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
string OpimizationSuffix = "_Oz"; // i.e. bCompileForSize
if (!UEBuildConfiguration.bCompileForSize)
{
switch (Target.Configuration)
{
case UnrealTargetConfiguration.Development:
OpimizationSuffix = "_O2";
break;
case UnrealTargetConfiguration.Shipping:
OpimizationSuffix = "_O3";
break;
default:
OpimizationSuffix = "";
break;
}
}
PublicAdditionalLibraries.Add(HarfBuzzRootPath + "HTML5/libharfbuzz" + OpimizationSuffix + ".bc");
// PublicAdditionalLibraries.Add(HarfBuzzRootPath + "HTML5/libharfbuzz" + OpimizationSuffix + ".a");
}
else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS)
{
Definitions.Add("WITH_HARFBUZZ=1");
PublicAdditionalLibraries.Add(HarfBuzzLibPath + "libharfbuzz.a");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
Definitions.Add("WITH_HARFBUZZ=1");
string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
? "Debug"
: "Release";
HarfBuzzLibPath += BuildTypeFolderName + "/";
PublicLibraryPaths.Add(HarfBuzzLibPath);
PublicAdditionalLibraries.Add("harfbuzz"); // Automatically transforms to libharfbuzz.a
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
Definitions.Add("WITH_HARFBUZZ=1");
string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
? "Debug"
: "Release";
HarfBuzzLibPath += "VS2015/" + BuildTypeFolderName + "/";
PublicLibraryPaths.Add(HarfBuzzLibPath);
PublicAdditionalLibraries.Add("harfbuzz.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
Definitions.Add("WITH_HARFBUZZ=1");
string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
? "Debug/"
: "Release/";
PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/ARMv7/" + BuildTypeFolderName);
PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/ARM64/" + BuildTypeFolderName);
PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/x86/" + BuildTypeFolderName);
PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/x64/" + BuildTypeFolderName);
PublicAdditionalLibraries.Add("harfbuzz");
}
else
{
Definitions.Add("WITH_HARFBUZZ=0");
}
}
public SubstanceEngine(TargetInfo Target)
{
//Marked as an external module as we are not building any source code with this module
Type = ModuleType.External;
string BuildConfig = GetBuildConfig(Target);
string PlatformConfig = GetPlatformConfig(Target);
string SubstanceLibPath = ModuleDirectory + "/../../Libs/" + BuildConfig + "/" + PlatformConfig + "/";
Dictionary <SubstanceEngineType, string> EngineLibs = new Dictionary <SubstanceEngineType, string>();
List <string> StaticLibs = new List <string>();
//add linker libraries
StaticLibs.Add("pfxlinkercommon");
StaticLibs.Add("algcompression");
StaticLibs.Add("tinyxml");
string LibExtension = "";
string LibPrefix = "";
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
LibExtension = ".lib";
StaticLibs.Add("substance_linker_static");
EngineLibs.Add(SubstanceEngineType.CPU, "substance_sse2_blend_static");
EngineLibs.Add(SubstanceEngineType.GPU, "substance_d3d11pc_blend_static");
}
else if (Target.Platform == UnrealTargetPlatform.Mac ||
Target.Platform == UnrealTargetPlatform.Linux)
{
LibExtension = ".a";
LibPrefix = "lib";
StaticLibs.Add("substance_linker");
EngineLibs.Add(SubstanceEngineType.CPU, "substance_sse2_blend");
EngineLibs.Add(SubstanceEngineType.GPU, "substance_ogl3_blend");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
LibExtension = ".a";
LibPrefix = "lib";
StaticLibs.Add("substance_linker");
EngineLibs.Add(SubstanceEngineType.CPU, "substance_avx_blend");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
LibExtension = ".lib";
StaticLibs.Add("substance_linker");
EngineLibs.Add(SubstanceEngineType.CPU, "substance_avx_blend");
}
else
{
throw new BuildException("Substance Plugin does not support platform " + Target.Platform.ToString());
}
if (Target.Type == TargetRules.TargetType.Editor)
{
Definitions.Add("AIR_NO_DEFAULT_ENGINE");
Definitions.Add("SUBSTANCE_ENGINE_DYNAMIC");
StaticLibs.Add("substance_framework_editor");
if (BuildConfig == "Debug")
{
Definitions.Add("SUBSTANCE_ENGINE_DEBUG");
}
}
else
{
Definitions.Add("AIR_NO_DYNLOAD");
SubstanceEngineType type = GetEngineSuffix();
if (EngineLibs.ContainsKey(type))
{
StaticLibs.Add(EngineLibs[type]);
}
else
{
StaticLibs.Add(EngineLibs[SubstanceEngineType.CPU]);
}
StaticLibs.Add("substance_framework");
//Linux GPU requires certain libraries added
if (Target.Platform == UnrealTargetPlatform.Linux && type == SubstanceEngineType.GPU)
{
PublicAdditionalLibraries.AddRange(new string[] { "X11", "glut", "GLU", "GL" });
}
}
//add our static libs
foreach (string staticlib in StaticLibs)
{
string libname = LibPrefix + staticlib + LibExtension;
PublicAdditionalLibraries.Add(SubstanceLibPath + libname);
}
}
public SlateCore(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"InputCore",
"Json",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/SlateCore/Private",
"Runtime/SlateCore/Private/Animation",
"Runtime/SlateCore/Private/Application",
"Runtime/SlateCore/Private/Brushes",
"Runtime/SlateCore/Private/Commands",
"Runtime/SlateCore/Private/Fonts",
"Runtime/SlateCore/Private/Input",
"Runtime/SlateCore/Private/Layout",
"Runtime/SlateCore/Private/Logging",
"Runtime/SlateCore/Private/Rendering",
"Runtime/SlateCore/Private/Sound",
"Runtime/SlateCore/Private/Styling",
"Runtime/SlateCore/Private/Textures",
"Runtime/SlateCore/Private/Types",
"Runtime/SlateCore/Private/Widgets",
}
);
if (Target.Type.Value != TargetRules.TargetType.Server)
{
if (UEBuildConfiguration.bCompileFreeType)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "FreeType2");
Definitions.Add("WITH_FREETYPE=1");
}
else
{
Definitions.Add("WITH_FREETYPE=0");
}
if (UEBuildConfiguration.bCompileICU)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "HarfBuzz");
}
else
{
Definitions.Add("WITH_FREETYPE=0");
Definitions.Add("WITH_HARFBUZZ=0");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "XInput");
}
}
private FireRockMining()
{
HarvestResource[] res;
HarvestVein[] veins;
#region Mining for FireRock
HarvestDefinition FireRock = m_FireRock = new HarvestDefinition();
// Resource banks are every 8x8 tiles
FireRock.BankWidth = 8;
FireRock.BankHeight = 8;
// Every bank holds from 6 to 12 FireRock
FireRock.MinTotal = 5;
FireRock.MaxTotal = 8;
// A resource bank will respawn its content every 10 to 20 minutes
FireRock.MinRespawn = TimeSpan.FromMinutes(10.0);
FireRock.MaxRespawn = TimeSpan.FromMinutes(20.0);
// Skill checking is done on the Mining skill
FireRock.Skill = SkillName.Mining;
// Set the list of harvestable tiles
FireRock.Tiles = m_LavaTiles;
// Players must be within 2 tiles to harvest
FireRock.MaxRange = 2;
// One FireRock per harvest action
FireRock.ConsumedPerHarvest = 1;
FireRock.ConsumedPerFeluccaHarvest = 1;
// The digging effect
FireRock.EffectActions = new int[] { 11 };
FireRock.EffectSounds = new int[] { 0x125, 0x126 };
FireRock.EffectCounts = new int[] { 1 };
FireRock.EffectDelay = TimeSpan.FromSeconds(1.6);
FireRock.EffectSoundDelay = TimeSpan.FromSeconds(0.9);
FireRock.NoResourcesMessage = "There is no FireRock here to mine."; // There is no FireRock here to mine.
FireRock.DoubleHarvestMessage = "There is no FireRock here to mine."; // There is no FireRock here to mine.
FireRock.TimedOutOfRangeMessage = "You have moved too far away to continue mining."; // You have moved too far away to continue mining.
FireRock.OutOfRangeMessage = "That is too far away."; // That is too far away.
FireRock.FailMessage = "You dig for a while but fail to find any FireRock."; // You dig for a while but fail to find any FireRock.
FireRock.PackFullMessage = "Your backpack can't hold the FireRock, and it is lost!"; // Your backpack can't hold the FireRock, and it is lost!
FireRock.ToolBrokeMessage = 1044038; // You have worn out your tool!
res = new HarvestResource[]
{
new HarvestResource(79.0, 59.0, 100.0, "You dig a SmallFireRock and put it in your backpack", typeof(SmallFireRock)),
new HarvestResource(99.0, 79.0, 120.0, "You dig some CrystalineFire and put it in your backpack", typeof(CrystalineFire), typeof(FireRockElemental)),
};
veins = new HarvestVein[]
{
new HarvestVein(80.7, 0.0, res[0], null), // SmallFireRock
new HarvestVein(19.3, 0.5, res[1], res[0]), // CrystalineFire
};
FireRock.Resources = res;
FireRock.Veins = veins;
Definitions.Add(FireRock);
#endregion
}
private Fishing()
{
HarvestResource[] res;
HarvestVein[] veins;
#region Fishing
HarvestDefinition fish = new HarvestDefinition
{
// Resource banks are every 8x8 tiles
BankWidth = 8,
BankHeight = 8,
// Every bank holds from 5 to 15 fish
MinTotal = 5,
MaxTotal = 15,
// A resource bank will respawn its content every 10 to 20 minutes
MinRespawn = TimeSpan.FromMinutes(10.0),
MaxRespawn = TimeSpan.FromMinutes(20.0),
// Skill checking is done on the Fishing skill
Skill = SkillName.Fishing,
// Set the list of harvestable tiles
Tiles = m_WaterTiles,
SpecialTiles = m_LavaTiles,
RangedTiles = true,
// Players must be within 4 tiles to harvest
MaxRange = 4,
// One fish per harvest action
ConsumedPerHarvest = 1,
ConsumedPerFeluccaHarvest = 1,
// The fishing
EffectActions = new int[] { 6 },
EffectSounds = new int[0],
EffectCounts = new int[] { 1 },
EffectDelay = TimeSpan.Zero,
EffectSoundDelay = TimeSpan.FromSeconds(8.0),
NoResourcesMessage = 503172, // The fish don't seem to be biting here.
FailMessage = 503171, // You fish a while, but fail to catch anything.
TimedOutOfRangeMessage = 500976, // You need to be closer to the water to fish!
OutOfRangeMessage = 500976, // You need to be closer to the water to fish!
PackFullMessage = 503176, // You do not have room in your backpack for a fish.
ToolBrokeMessage = 503174 // You broke your fishing pole.
};
res = new HarvestResource[]
{
new HarvestResource(00.0, 00.0, 120.0, 1043297, typeof(Fish))
};
veins = new HarvestVein[]
{
new HarvestVein(100.0, 0.0, res[0], null)
};
fish.Resources = res;
fish.Veins = veins;
fish.BonusResources = new BonusHarvestResource[]
{
new BonusHarvestResource(0, 97.0, null, null), //set to same chance as mining ml gems
new BonusHarvestResource(80.0, 2.0, 1113764, typeof(DelicateScales)),
new BonusHarvestResource(80.0, 1.0, 1072597, typeof(WhitePearl))
};
m_Definition = fish;
Definitions.Add(fish);
#endregion
}
public D3D12RHI(TargetInfo Target)
{
PrivateIncludePaths.Add("Runtime/D3D12RHI/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Engine",
"RHI",
"RenderCore",
"ShaderCore",
"UtilityShaders",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
///////////////////////////////////////////////////////////////
// Platform agnostic defines
///////////////////////////////////////////////////////////////
Definitions.Add("SUB_ALLOCATED_DEFAULT_ALLOCATIONS=1");
Definitions.Add("DEBUG_RESOURCE_STATES=0");
// DX12 doesn't support higher MSAA count
Definitions.Add("DX_MAX_MSAA_COUNT=8");
// This is a value that should be tweaked to fit the app, lower numbers will have better performance
Definitions.Add("MAX_SRVS=32");
Definitions.Add("MAX_CBS=8");
// This value controls how many root constant buffers can be used per shader stage in a root signature.
// Note: Using root descriptors significantly increases the size of root signatures (each root descriptor is 2 DWORDs).
Definitions.Add("MAX_ROOT_CBVS=MAX_CBS");
// PC uses a multiple root signatures that are optimized for a particular draw/dispatch.
Definitions.Add("USE_STATIC_ROOT_SIGNATURE=0");
// How many residency packets can be in flight before the rendering thread
// blocks for them to drain. Should be ~ NumBufferedFrames * AvgNumSubmissionsPerFrame i.e.
// enough to ensure that the GPU is rarely blocked by residency work
Definitions.Add("RESIDENCY_PIPELINE_DEPTH=6");
///////////////////////////////////////////////////////////////
// Platform specific defines
///////////////////////////////////////////////////////////////
if (Target.Platform != UnrealTargetPlatform.Win64 && Target.Platform != UnrealTargetPlatform.XboxOne)
{
PrecompileForTargets = PrecompileTargetsType.None;
}
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAPI");
Definitions.Add("ENABLE_RESIDENCY_MANAGEMENT=1");
Definitions.Add("ASYNC_DEFERRED_DELETION=1");
Definitions.Add("PLATFORM_SUPPORTS_MGPU=1");
Definitions.Add("PIPELINE_STATE_FILE_LOCATION=FPaths::GameSavedDir()");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
Definitions.Add("ENABLE_RESIDENCY_MANAGEMENT=0");
Definitions.Add("ASYNC_DEFERRED_DELETION=0");
Definitions.Add("PLATFORM_SUPPORTS_MGPU=0");
Definitions.Add("ASYNC_DEFERRED_DELETION=0");
// The number of sampler descriptors with the maximum value of 2048
// If the heap type is unbounded the number could be increased to avoid rollovers.
Definitions.Add("ENABLE_UNBOUNDED_SAMPLER_DESCRIPTORS=0");
Definitions.Add("NUM_SAMPLER_DESCRIPTORS=D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE");
// Xbox doesn't have DXGI but common code needs this defined for headers
Definitions.Add("DXGI_QUERY_VIDEO_MEMORY_INFO=int");
Definitions.Add("PIPELINE_STATE_FILE_LOCATION=FPaths::GameContentDir()");
}
}
public IntelTBB(TargetInfo Target)
{
Type = ModuleType.External;
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
string IntelTBBPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelTBB/";
switch (WindowsPlatform.Compiler)
{
case WindowsCompiler.VisualStudio2017:
case WindowsCompiler.VisualStudio2015: IntelTBBPath += "IntelTBB-4.4u3/"; break;
case WindowsCompiler.VisualStudio2013: IntelTBBPath += "IntelTBB-4.0/"; break;
}
PublicSystemIncludePaths.Add(IntelTBBPath + "Include");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
if (WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015 || WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2017)
{
PublicLibraryPaths.Add(IntelTBBPath + "lib/Win64/vc14");
}
else if (WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2013)
{
PublicLibraryPaths.Add(IntelTBBPath + "lib/Win64/vc12");
}
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
if (WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015 || WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2017)
{
PublicLibraryPaths.Add(IntelTBBPath + "lib/Win32/vc14");
}
else if (WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2013)
{
PublicLibraryPaths.Add(IntelTBBPath + "lib/Win32/vc12");
}
}
// Disable the #pragma comment(lib, ...) used by default in MallocTBB...
// We want to explicitly include the library.
Definitions.Add("__TBBMALLOC_BUILD=1");
string LibName = "tbbmalloc";
if (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
{
LibName += "_debug";
}
LibName += ".lib";
PublicAdditionalLibraries.Add(LibName);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicSystemIncludePaths.AddRange(
new string[] {
UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelTBB/IntelTBB-4.0/include",
}
);
PublicAdditionalLibraries.AddRange(
new string[] {
UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelTBB/IntelTBB-4.0/lib/Mac/libtbb.a",
UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelTBB/IntelTBB-4.0/lib/Mac/libtbbmalloc.a",
}
);
}
}
public UnrealEd(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/UnrealEdPrivatePCH.h";
SharedPCHHeaderFile = "Public/UnrealEdSharedPCH.h";
PrivateIncludePaths.AddRange(
new string[]
{
"Editor/UnrealEd/Private",
"Editor/UnrealEd/Private/Settings",
"Editor/PackagesDialog/Public",
"Developer/DerivedDataCache/Public",
"Developer/TargetPlatform/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"AssetRegistry",
"AssetTools",
"BehaviorTreeEditor",
"ClassViewer",
"ContentBrowser",
"CrashTracker",
"DerivedDataCache",
"DesktopPlatform",
"EnvironmentQueryEditor",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"ImageWrapper",
"MainFrame",
"MaterialEditor",
"MergeActors",
"MeshUtilities",
"Messaging",
"MovieSceneCapture",
"NiagaraEditor",
"PlacementMode",
"Settings",
"SettingsEditor",
"SuperSearch",
"AudioEditor",
"ViewportSnapping",
"SourceCodeAccess",
"ReferenceViewer",
"IntroTutorials",
"OutputLog",
"Landscape",
"Niagara",
"SizeMap",
"LocalizationService",
"HierarchicalLODUtilities",
"MessagingRpc",
"PortalRpc",
"PortalServices",
"BlueprintNativeCodeGen",
"ViewportInteraction",
"VREditor",
"Persona",
"ClothingSystemEditorInterface",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"BspMode",
"Core",
"CoreUObject",
"DirectoryWatcher",
"Documentation",
"Engine",
"Json",
"Projects",
"SandboxFile",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"UnrealEdMessages",
"AIModule",
"GameplayDebugger",
"BlueprintGraph",
"Http",
"UnrealAudio",
"FunctionalTesting",
"AutomationController",
"Localization",
"AudioEditor",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"LevelSequence",
"AnimGraph",
"AppFramework",
"BlueprintGraph",
"CinematicCamera",
"DesktopPlatform",
"EditorStyle",
"EngineSettings",
"InputCore",
"InputBindingEditor",
"LauncherServices",
"MaterialEditor",
"MessageLog",
"NetworkFileSystem",
"PakFile",
"PropertyEditor",
"Projects",
"RawMesh",
"RenderCore",
"RHI",
"ShaderCore",
"Sockets",
"SourceControlWindows",
"StatsViewer",
"SwarmInterface",
"TargetPlatform",
"TargetDeviceServices",
"EditorWidgets",
"GraphEditor",
"Kismet",
"InternationalizationSettings",
"JsonUtilities",
"Landscape",
"HeadMountedDisplay",
"MeshPaint",
"MeshPaintMode",
"Foliage",
"VectorVM",
"TreeMap",
"MaterialUtilities",
"Localization",
"LocalizationService",
"AddContentDialog",
"GameProjectGeneration",
"HierarchicalLODUtilities",
"Analytics",
"AnalyticsET",
"PluginWarden",
"PixelInspectorModule",
"MovieScene",
"MovieSceneTracks",
"ViewportInteraction",
"VREditor",
"ClothingSystemEditor",
"ClothingSystemRuntime",
"ClothingSystemRuntimeInterface",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"CrashTracker",
"FontEditor",
"StaticMeshEditor",
"TextureEditor",
"Cascade",
"UMGEditor",
"Matinee",
"AssetRegistry",
"AssetTools",
"ClassViewer",
"CollectionManager",
"ContentBrowser",
"CurveTableEditor",
"DataTableEditor",
"DestructibleMeshEditor",
"EditorSettingsViewer",
"LandscapeEditor",
"KismetCompiler",
"DetailCustomizations",
"ComponentVisualizers",
"MainFrame",
"LevelEditor",
"PackagesDialog",
"Persona",
"PhAT",
"ProjectLauncher",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"Sequencer",
"StringTableEditor",
"SuperSearch",
"GeometryMode",
"TextureAlignMode",
"FoliageEdit",
"PackageDependencyInfo",
"ImageWrapper",
"Blutility",
"IntroTutorials",
"WorkspaceMenuStructure",
"PlacementMode",
"NiagaraEditor",
"MeshUtilities",
"MergeActors",
"ProjectSettingsViewer",
"ProjectTargetPlatformEditor",
"PListEditor",
"BehaviorTreeEditor",
"EnvironmentQueryEditor",
"ViewportSnapping",
"UserFeedback",
"GameplayTasksEditor",
"UndoHistory",
"SourceCodeAccess",
"ReferenceViewer",
"EditorLiveStreaming",
"HotReload",
"IOSPlatformEditor",
"HTML5PlatformEditor",
"SizeMap",
"PortalProxies",
"PortalServices",
"GeometryCacheEd",
"BlueprintNativeCodeGen",
"AnimationModifiers",
"ClothPainter",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.Add("AndroidPlatformEditor");
}
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"GraphEditor",
"Kismet",
"AudioEditor",
"ViewportInteraction",
"VREditor"
}
);
// Add include directory for Lightmass
PublicIncludePaths.Add("Programs/UnrealLightmass/Public");
PublicIncludePathModuleNames.AddRange(
new string[] {
"UserFeedback",
"CollectionManager",
"BlueprintGraph",
"AddContentDialog",
"MeshUtilities"
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("XAudio2");
PublicDependencyModuleNames.Add("AudioMixerXAudio2");
PublicDependencyModuleNames.Add("UnrealAudioXAudio2");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"DX11Audio"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PublicDependencyModuleNames.Add("ALAudio");
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"HACD",
"VHACD",
"FBX",
"FreeType2"
);
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
Definitions.Add("WITH_RECAST=0");
}
}
public UnrealEnginePython(TargetInfo Target)
{
System.Console.WriteLine("Using Python at: " + PythonHome);
PublicIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"MovieScene",
"LevelSequence",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (UEBuildConfiguration.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd"
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
PublicIncludePaths.Add(PythonHome);
PublicAdditionalLibraries.Add(Path.Combine(PythonHome, "libs", "python35.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string mac_python = "/Library/Frameworks/Python.framework/Versions/3.5/";
PublicIncludePaths.Add(Path.Combine(mac_python, "include"));
PublicAdditionalLibraries.Add(Path.Combine(mac_python, "lib", "libpython3.5m.dylib"));
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_MAC=1"));
}
}
public Facebook(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
Definitions.Add("WITH_FACEBOOK=1");
// Additional Frameworks and Libraries for Android found in OnlineSubsystemFacebook_UPL.xml
if (Target.Platform == UnrealTargetPlatform.IOS)
{
Definitions.Add("UE4_FACEBOOK_VER=4.18");
// These are iOS system libraries that Facebook depends on (FBAudienceNetwork, FBNotifications)
PublicFrameworks.AddRange(
new string[] {
"ImageIO"
});
// More dependencies for Facebook (FBAudienceNetwork, FBNotifications)
PublicAdditionalLibraries.AddRange(
new string[] {
"xml2"
});
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"AccountKit",
"IOS/FacebookSDK/AccountKit.embeddedframework.zip",
"AccountKit.framework/AccountKitAdditionalStrings.bundle"
)
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"AccountKit",
"IOS/FacebookSDK/AccountKit.embeddedframework.zip",
"AccountKit.framework/AccountKitStrings.bundle"
)
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"Bolts",
"IOS/FacebookSDK/Bolts.embeddedframework.zip"
)
);
// Add the FBAudienceNetwork framework
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"FBAudienceNetwork",
"IOS/FacebookSDK/FBAudienceNetwork.embeddedframework.zip"
)
);
// Access to Facebook notifications
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"FBNotifications",
"IOS/FacebookSDK/FBNotifications.embeddedframework.zip"
)
);
// Access to Facebook core
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"FBSDKCoreKit",
"IOS/FacebookSDK/FBSDKCoreKit.embeddedframework.zip",
"FBSDKCoreKit.framework/Resources/FacebookSDKStrings.bundle"
)
);
// Access to Facebook login
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"FBSDKLoginKit",
"IOS/FacebookSDK/FBSDKLoginKit.embeddedframework.zip"
)
);
// Access to Facebook messenger sharing
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"FBSDKMessengerShareKit",
"IOS/FacebookSDK/FBSDKMessengerShareKit.embeddedframework.zip"
)
);
// Access to Facebook sharing
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"FBSDKShareKit",
"IOS/FacebookSDK/FBSDKShareKit.embeddedframework.zip"
)
);
}
}
private bool LoadV8(ReadOnlyTargetRules Target)
{
int[] v8_version = GetV8Version();
bool ShouldLink_libsampler = !(v8_version[0] == 5 && v8_version[1] < 3);
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibrariesPath = Path.Combine(LibrariesPath, "Win64");
}
else
{
LibrariesPath = Path.Combine(LibrariesPath, "Win32");
}
if (Target.Configuration == UnrealTargetConfiguration.Debug)
{
LibrariesPath = Path.Combine(LibrariesPath, "Debug");
}
else
{
LibrariesPath = Path.Combine(LibrariesPath, "Release");
}
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_0.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_1.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_2.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_3.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libbase.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libplatform.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_nosnapshot.lib"));
if (ShouldLink_libsampler)
{
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libsampler.lib"));
}
Definitions.Add(string.Format("WITH_V8=1"));
return(true);
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib", "Android");
PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "ARMv7"));
PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "ARM64"));
PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "x86"));
PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "x64"));
PublicAdditionalLibraries.Add("v8_base");
PublicAdditionalLibraries.Add("v8_libbase");
PublicAdditionalLibraries.Add("v8_libplatform");
PublicAdditionalLibraries.Add("v8_nosnapshot");
if (ShouldLink_libsampler)
{
PublicAdditionalLibraries.Add("v8_libsampler");
}
Definitions.Add(string.Format("WITH_V8=1"));
return(true);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib", "Linux");
PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "x64"));
PublicAdditionalLibraries.Add("v8_base");
PublicAdditionalLibraries.Add("v8_libbase");
PublicAdditionalLibraries.Add("v8_libplatform");
PublicAdditionalLibraries.Add("v8_nosnapshot");
if (ShouldLink_libsampler)
{
PublicAdditionalLibraries.Add("v8_libsampler");
}
Definitions.Add(string.Format("WITH_V8=1"));
return(true);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib", "Mac", "x64");
PublicLibraryPaths.Add(LibrariesPath);
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_base.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_libbase.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_libplatform.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_nosnapshot.a"));
if (ShouldLink_libsampler)
{
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_libsampler.a"));
}
Definitions.Add(string.Format("WITH_V8=1"));
return(true);
}
Definitions.Add(string.Format("WITH_V8=0"));
return(false);
}
public libcurl(TargetInfo Target)
{
Type = ModuleType.External;
Definitions.Add("WITH_LIBCURL=1");
string NewLibCurlPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libcurl/7_48_0/";
string LibCurlPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libcurl/curl-7.47.1/";
// TODO: latest recompile for consoles and mobile platforms
string OldLibCurlPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libcurl/";
if (Target.Platform == UnrealTargetPlatform.Linux)
{
string platform = "/Linux/" + Target.Architecture;
string IncludePath = NewLibCurlPath + "include" + platform;
string LibraryPath = NewLibCurlPath + "lib" + platform;
PublicIncludePaths.Add(IncludePath);
PublicLibraryPaths.Add(LibraryPath);
PublicAdditionalLibraries.Add(LibraryPath + "/libcurl.a");
PrivateDependencyModuleNames.Add("SSL");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// toolchain will filter properly
PublicIncludePaths.Add(OldLibCurlPath + "include/Android/ARMv7");
PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/ARMv7");
PublicIncludePaths.Add(OldLibCurlPath + "include/Android/ARM64");
PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/ARM64");
PublicIncludePaths.Add(OldLibCurlPath + "include/Android/x86");
PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/x86");
PublicIncludePaths.Add(OldLibCurlPath + "include/Android/x64");
PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/x64");
PublicAdditionalLibraries.Add("curl");
// PublicAdditionalLibraries.Add("crypto");
// PublicAdditionalLibraries.Add("ssl");
// PublicAdditionalLibraries.Add("dl");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string PlatformSubdir = "/Mac/";
PublicIncludePaths.Add(LibCurlPath + "include" + PlatformSubdir);
// OSX needs full path
PublicAdditionalLibraries.Add(LibCurlPath + "lib" + PlatformSubdir + "libcurl.a");
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 ||
(Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32"))
{
string PlatformSubdir = (Target.Platform == UnrealTargetPlatform.HTML5) ? "Win32" : Target.Platform.ToString();
PublicIncludePaths.Add(LibCurlPath + "/include/" + PlatformSubdir + "/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicLibraryPaths.Add(LibCurlPath + "/lib/" + PlatformSubdir + "/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicAdditionalLibraries.Add("libcurl_a.lib");
Definitions.Add("CURL_STATICLIB=1");
}
}
public GoogleTest(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string RootPath = Target.UEThirdPartySourceDirectory + "GoogleTest/";
string DefaultConfiguration = "MinSizeRel";
// Includes
PublicSystemIncludePaths.Add(RootPath + "include/");
// Libraries
string PartialLibraryPath = "lib/" + Target.Platform.ToString() + "/";
string LibraryPath = RootPath;
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
PartialLibraryPath += "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
if (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT)
{
PartialLibraryPath += "/Debug";
}
else
{
PartialLibraryPath += "/" + DefaultConfiguration;
}
//if (!Target.IsMonolithic)
//{
// PartialLibraryPath += "_Shared";
//}
PartialLibraryPath += "/";
LibraryPath += PartialLibraryPath;
//i.e. Engine\Source\ThirdParty\GoogleTest\lib\Win64\VS2013\MinSizeRel_Shared\
// I was unable to get non-monolithic windows builds working without crashing within the
// time box I was given for the integration. The workaround is to ensure that all tests
// are included in the same dll when building monolithic, otherwise error messages
// will not be routed properly.
// We should re-investigate this integration problem in the future, as more teams want to
// adopt usage of the library
//if (!Target.IsMonolithic)
//{
// PublicAdditionalLibraries.Add("gmock_main.lib");
// RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/ThirdParty/GoogleTest/" + PartialLibraryPath + "gmock_main.dll"));
//}
//else
//{
PublicAdditionalLibraries.Add("gtest.lib");
PublicAdditionalLibraries.Add("gmock.lib");
PublicAdditionalLibraries.Add("gmock_main.lib");
//}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (Target.LinkType == TargetLinkType.Monolithic)
{
PartialLibraryPath += DefaultConfiguration + "/";
LibraryPath += PartialLibraryPath;
PublicAdditionalLibraries.Add(LibraryPath + "libgtest.a");
PublicAdditionalLibraries.Add(LibraryPath + "libgmock.a");
PublicAdditionalLibraries.Add(LibraryPath + "libgmock_main.a");
}
else
{
PartialLibraryPath += DefaultConfiguration + "_Shared/";
LibraryPath += PartialLibraryPath;
PublicAdditionalLibraries.Add(LibraryPath + "libgmock_main.dylib");
}
}
PublicLibraryPaths.Add(LibraryPath);
// The including module will also need these enabled
Definitions.Add("WITH_GOOGLE_MOCK=1");
Definitions.Add("WITH_GOOGLE_TEST=1");
Definitions.Add("GTEST_HAS_POSIX_RE=0");
if (Target.LinkType != TargetLinkType.Monolithic)
{
//Definitions.Add("GTEST_LINKED_AS_SHARED_LIBRARY=1");
}
}
private Lumberjacking()
{
HarvestResource[] res;
HarvestVein[] veins;
#region Lumberjacking
HarvestDefinition lumber = new HarvestDefinition();
// Resource banks are every 4x3 tiles
lumber.BankWidth = 4;
lumber.BankHeight = 3;
// Every bank holds from 20 to 45 logs
lumber.MinTotal = 20;
lumber.MaxTotal = 45;
// A resource bank will respawn its content every 20 to 30 minutes
lumber.MinRespawn = TimeSpan.FromMinutes(20.0);
lumber.MaxRespawn = TimeSpan.FromMinutes(30.0);
// Skill checking is done on the Lumberjacking skill
lumber.Skill = SkillName.Lumberjacking;
// Set the list of harvestable tiles
lumber.Tiles = m_TreeTiles;
// Players must be within 2 tiles to harvest
lumber.MaxRange = 2;
// Ten logs per harvest action
lumber.ConsumedPerHarvest = 10;
lumber.ConsumedPerFeluccaHarvest = 20;
// The chopping effect
lumber.EffectActions = new int[] { 13 };
lumber.EffectSounds = new int[] { 0x13E };
lumber.EffectCounts = (Core.AOS ? new int[] { 1 } : new int[] { 1, 2, 2, 2, 3 });
lumber.EffectDelay = TimeSpan.FromSeconds(1.6);
lumber.EffectSoundDelay = TimeSpan.FromSeconds(0.9);
lumber.AFKChance = ((1.6 * 2 + 0.9) / 60) / 30; //Approx once every 30 minutes.
lumber.NoResourcesMessage = 500493; // There's not enough wood here to harvest.
lumber.FailMessage = 500495; // You hack at the tree for a while, but fail to produce any useable wood.
lumber.OutOfRangeMessage = 500446; // That is too far away.
lumber.PackFullMessage = 500497; // You can't place any wood into your backpack!
lumber.ToolBrokeMessage = 500499; // You broke your axe.
if (Core.ML)
{
res = new HarvestResource[]
{
new HarvestResource(00.0, 00.0, 100.0, 1072540, typeof(Log)),
new HarvestResource(65.0, 25.0, 105.0, 1072541, typeof(OakLog)),
new HarvestResource(80.0, 40.0, 120.0, 1072542, typeof(AshLog)),
new HarvestResource(95.0, 55.0, 135.0, 1072543, typeof(YewLog)),
new HarvestResource(100.0, 60.0, 140.0, 1072544, typeof(HeartwoodLog)),
new HarvestResource(100.0, 60.0, 140.0, 1072545, typeof(BloodwoodLog)),
new HarvestResource(100.0, 60.0, 140.0, 1072546, typeof(FrostwoodLog)),
};
veins = new HarvestVein[]
{
new HarvestVein(49.0, 0.0, res[0], null), // Ordinary Logs
new HarvestVein(30.0, 0.5, res[1], res[0]), // Oak
new HarvestVein(10.0, 0.5, res[2], res[0]), // Ash
new HarvestVein(05.0, 0.5, res[3], res[0]), // Yew
new HarvestVein(03.0, 0.5, res[4], res[0]), // Heartwood
new HarvestVein(02.0, 0.5, res[5], res[0]), // Bloodwood
new HarvestVein(01.0, 0.5, res[6], res[0]), // Frostwood
};
lumber.BonusResources = new BonusHarvestResource[]
{
new BonusHarvestResource(0, 83.9, null, null), //Nothing
new BonusHarvestResource(100, 10.0, 1072548, typeof(BarkFragment)),
new BonusHarvestResource(100, 03.0, 1072550, typeof(LuminescentFungi)),
new BonusHarvestResource(100, 02.0, 1072547, typeof(SwitchItem)),
new BonusHarvestResource(100, 01.0, 1072549, typeof(ParasiticPlant)),
new BonusHarvestResource(100, 00.1, 1072551, typeof(BrilliantAmber))
};
}
else
{
res = new HarvestResource[]
{
new HarvestResource(00.0, 00.0, 100.0, 500498, typeof(Log))
};
veins = new HarvestVein[]
{
new HarvestVein(100.0, 0.0, res[0], null)
};
}
lumber.Resources = res;
lumber.Veins = veins;
lumber.RaceBonus = Core.ML;
lumber.RandomizeVeins = Core.ML;
m_Definition = lumber;
Definitions.Add(lumber);
#endregion
}
public HoudiniEngineEditor(TargetInfo Target)
{
PCHUsage = PCHUsageMode.UseSharedPCHs;
bool bIsRelease = true;
string HFSPath = "";
string HoudiniVersion = "16.0.543";
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux)
{
string Err = string.Format("Houdini Engine Runtime: Compiling on unsupported platform.");
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
if (bIsRelease)
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// We first check if Houdini Engine is installed.
string HPath = "C:/Program Files/Side Effects Software/Houdini Engine " + HoudiniVersion;
if (!Directory.Exists(HPath))
{
// If Houdini Engine is not installed, we check for Houdini installation.
HPath = "C:/Program Files/Side Effects Software/Houdini " + HoudiniVersion;
if (!Directory.Exists(HPath))
{
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine : Please install Houdini or Houdini Engine {0}", HoudiniVersion);
System.Console.WriteLine(Err);
}
}
else
{
HFSPath = HPath;
}
}
else
{
HFSPath = HPath;
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string HPath = "/Applications/Houdini/" + HoudiniVersion + "/Frameworks/Houdini.framework/Versions/Current/Resources";
if (!Directory.Exists(HPath))
{
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine : Please install Houdini {0}", HoudiniVersion);
System.Console.WriteLine(Err);
}
}
else
{
HFSPath = HPath;
}
}
else
{
HFSPath = System.Environment.GetEnvironmentVariable("HFS");
System.Console.WriteLine("Linux - found HFS:" + HFSPath);
}
}
string HAPIIncludePath = "";
if (HFSPath != "")
{
HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
if (HAPIIncludePath != "")
{
PublicIncludePaths.Add(HAPIIncludePath);
// Add the custom include path as well in case the toolkit path doesn't exist yet.
PublicIncludePaths.Add(HFSPath + "/custom/houdini/include/HAPI");
}
PublicIncludePaths.AddRange(
new string[] {
"HoudiniEngineRuntime/Public/HAPI",
"HoudiniEngineRuntime/Public",
"HoudiniEngineEditor/Public"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngineEditor/Private",
"HoudiniEngineRuntime/Private"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"ShaderCore",
"InputCore",
"RHI",
"AssetTools",
"UnrealEd",
"Slate",
"SlateCore",
"Projects",
"PropertyEditor",
"ContentBrowser",
"RawMesh",
"TargetPlatform",
"LevelEditor",
"MainFrame",
"EditorStyle",
"EditorWidgets",
"AppFramework",
"DesktopWidgets",
"HoudiniEngineRuntime"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
private Fishing()
{
HarvestResource[] res;
HarvestVein[] veins;
#region Fishing
HarvestDefinition fish = new HarvestDefinition();
// Resource banks are every 8x8 tiles
fish.BankWidth = 8;
fish.BankHeight = 8;
// Every bank holds from 5 to 15 fish
fish.MinTotal = 5;
fish.MaxTotal = 15;
// A resource bank will respawn its content every 10 to 20 minutes
fish.MinRespawn = TimeSpan.FromMinutes(10.0);
fish.MaxRespawn = TimeSpan.FromMinutes(20.0);
// Skill checking is done on the Fishing skill
fish.Skill = SkillName.Fishing;
// Set the list of harvestable tiles
fish.Tiles = m_WaterTiles;
fish.RangedTiles = true;
// Players must be within 4 tiles to harvest
fish.MaxRange = 4;
// One fish per harvest action
fish.ConsumedPerHarvest = 1;
fish.ConsumedPerFeluccaHarvest = 1;
// The fishing
fish.EffectActions = new int[] { 12 };
fish.EffectSounds = new int[0];
fish.EffectCounts = new int[] { 1 };
fish.EffectDelay = TimeSpan.Zero;
fish.EffectSoundDelay = TimeSpan.FromSeconds(8.0);
fish.NoResourcesMessage = 503172; // The fish don't seem to be biting here.
fish.FailMessage = 503171; // You fish a while, but fail to catch anything.
fish.TimedOutOfRangeMessage = 500976; // You need to be closer to the water to fish!
fish.OutOfRangeMessage = 500976; // You need to be closer to the water to fish!
fish.PackFullMessage = 503176; // You do not have room in your backpack for a fish.
fish.ToolBrokeMessage = 503174; // You broke your fishing pole.
res = new HarvestResource[]
{
new HarvestResource(00.0, 00.0, 100.0, 1043297, typeof(Fish))
};
veins = new HarvestVein[]
{
new HarvestVein(100.0, 0.0, res[0], null)
};
fish.Resources = res;
fish.Veins = veins;
if (Core.ML)
{
fish.BonusResources = new BonusHarvestResource[]
{
new BonusHarvestResource(0, 99.4, null, null), //set to same chance as mining ml gems
new BonusHarvestResource(80.0, .6, 1072597, typeof(WhitePearl))
};
}
m_Definition = fish;
Definitions.Add(fish);
#endregion
}
public HTTP(ReadOnlyTargetRules Target) : base(Target)
{
Definitions.Add("HTTP_PACKAGE=1");
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Online/HTTP/Private",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Sockets"
}
);
bool bWithCurl = false;
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "WinInet");
AddEngineThirdPartyPrivateStaticDependencies(Target, "WinHttp");
AddEngineThirdPartyPrivateStaticDependencies(Target, "libcurl");
bWithCurl = true;
PrivateDependencyModuleNames.Add("SSL");
}
else if (Target.Platform == UnrealTargetPlatform.Linux ||
Target.Platform == UnrealTargetPlatform.Android ||
Target.Platform == UnrealTargetPlatform.Switch)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "libcurl");
PrivateDependencyModuleNames.Add("SSL");
bWithCurl = true;
}
else
{
Definitions.Add("WITH_SSL=0");
Definitions.Add("WITH_LIBCURL=0");
}
if (bWithCurl)
{
Definitions.Add("CURL_ENABLE_DEBUG_CALLBACK=1");
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
Definitions.Add("CURL_ENABLE_NO_TIMEOUTS_OPTION=1");
}
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS || Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("Security");
}
}
private Mining()
{
HarvestResource[] res;
HarvestVein[] veins;
#region Mining for ore and stone
HarvestDefinition oreAndStone = m_OreAndStone = new HarvestDefinition();
// Resource banks are every 8x8 tiles
oreAndStone.BankWidth = 8;
oreAndStone.BankHeight = 8;
oreAndStone.MinTotal = 5;
oreAndStone.MaxTotal = 15;
oreAndStone.MinRespawn = TimeSpan.FromMinutes(10.0);
oreAndStone.MaxRespawn = TimeSpan.FromMinutes(20.0);
// Skill checking is done on the Mining skill
oreAndStone.Skill = SkillName.Mining;
// Set the list of harvestable tiles
oreAndStone.Tiles = m_MountainAndCaveTiles;
// Players must be within 2 tiles to harvest
oreAndStone.MaxRange = 4;
// One ore per harvest action
oreAndStone.ConsumedPerHarvest = 1;
oreAndStone.ConsumedPerFeluccaHarvest = 1;
// The digging effect
oreAndStone.EffectActions = new int[] { 11 };
oreAndStone.EffectSounds = new int[] { 0x125, 0x126 };
oreAndStone.EffectCounts = new int[] { 1 };
oreAndStone.EffectDelay = TimeSpan.FromSeconds(1.6);
oreAndStone.EffectSoundDelay = TimeSpan.FromSeconds(0.9);
oreAndStone.NoResourcesMessage = 503040; // There is no metal here to mine.
oreAndStone.DoubleHarvestMessage = 503042; // Someone has gotten to the metal before you.
oreAndStone.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining.
oreAndStone.OutOfRangeMessage = 500446; // That is too far away.
oreAndStone.FailMessage = 503043; // You loosen some rocks but fail to find any useable ore.
oreAndStone.PackFullMessage = 1010481; // Your backpack is full, so the ore you mined is lost.
oreAndStone.ToolBrokeMessage = 1044038; // You have worn out your tool!
oreAndStone.PlaceAtFeetIfFull = true;
res = new HarvestResource[]
{
new HarvestResource(00.0, 00.0, 100.0, 1007072, typeof(IronOre)),
};
veins = new HarvestVein[]
{
new HarvestVein(100.0, 0.0, res[0], null), // Iron
};
oreAndStone.Resources = res;
oreAndStone.Veins = veins;
Definitions.Add(oreAndStone);
#endregion
#region Mining for sand
/*HarvestDefinition sand = m_Sand = new HarvestDefinition();
*
* // Resource banks are every 8x8 tiles
* sand.BankWidth = 8;
* sand.BankHeight = 8;
*
* // Every bank holds from 6 to 12 sand
* sand.MinTotal = 6;
* sand.MaxTotal = 12;
*
* // A resource bank will respawn its content every 10 to 20 minutes
* sand.MinRespawn = TimeSpan.FromMinutes( 10.0 );
* sand.MaxRespawn = TimeSpan.FromMinutes( 20.0 );
*
* // Skill checking is done on the Mining skill
* sand.Skill = SkillName.Mining;
*
* // Set the list of harvestable tiles
* sand.Tiles = m_SandTiles;
*
* // Players must be within 2 tiles to harvest
* sand.MaxRange = 2;
*
* // One sand per harvest action
* sand.ConsumedPerHarvest = 1;
* sand.ConsumedPerFeluccaHarvest = 1;
*
* // The digging effect
* sand.EffectActions = new int[]{ 11 };
* sand.EffectSounds = new int[]{ 0x125, 0x126 };
* sand.EffectCounts = new int[]{ 6 };
* sand.EffectDelay = TimeSpan.FromSeconds( 1.6 );
* sand.EffectSoundDelay = TimeSpan.FromSeconds( 0.9 );
*
* sand.NoResourcesMessage = 1044629; // There is no sand here to mine.
* sand.DoubleHarvestMessage = 1044629; // There is no sand here to mine.
* sand.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining.
* sand.OutOfRangeMessage = 500446; // That is too far away.
* sand.FailMessage = 1044630; // You dig for a while but fail to find any of sufficient quality for glassblowing.
* sand.PackFullMessage = 1044632; // Your backpack can't hold the sand, and it is lost!
* sand.ToolBrokeMessage = 1044038; // You have worn out your tool!
*
* res = new HarvestResource[]
* {
* new HarvestResource( 100.0, 70.0, 400.0, 1044631, typeof( Sand ) )
* };
*
* veins = new HarvestVein[]
* {
* new HarvestVein( 100.0, 0.0, res[0], null )
* };
*
* sand.Resources = res;
* sand.Veins = veins;
*
* Definitions.Add( sand );*/
#endregion
}
public PhysX(TargetInfo Target)
{
Type = ModuleType.External;
// Determine which kind of libraries to link against
PhysXLibraryMode LibraryMode = GetPhysXLibraryMode(Target.Configuration);
// Quick Mac hack
if (Target.Platform == UnrealTargetPlatform.Mac && (LibraryMode == PhysXLibraryMode.Checked || LibraryMode == PhysXLibraryMode.Shipping))
{
LibraryMode = PhysXLibraryMode.Profile;
}
string LibrarySuffix = GetPhysXLibrarySuffix(LibraryMode);
Definitions.Add("WITH_PHYSX=1");
if (UEBuildConfiguration.bCompileAPEX == false)
{
// Since APEX is dependent on PhysX, if APEX is not being include, set the flag properly.
// This will properly cover the case where PhysX is compiled but APEX is not.
Definitions.Add("WITH_APEX=0");
}
if (UEBuildConfiguration.bCompilePhysXVehicle == false)
{
// Since PhysX Vehicle is dependent on PhysX, if Vehicle is not being include, set the flag properly.
// This will properly cover the case where PhysX is compiled but Vehicle is not.
Definitions.Add("WITH_VEHICLE=0");
}
if (LibraryMode == PhysXLibraryMode.Shipping)
{
Definitions.Add("WITH_PHYSX_RELEASE=1");
}
else
{
Definitions.Add("WITH_PHYSX_RELEASE=0");
}
if (LibraryMode == PhysXLibraryMode.Checked)
{
Definitions.Add("WITH_PHYSX_CHECKED=1");
}
else
{
Definitions.Add("WITH_PHYSX_CHECKED=0");
}
string PhysXVersion = "PhysX-3.3";
string PhysXDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "PhysX/" + PhysXVersion + "/";
string PhysXLibDir = PhysXDir + "lib/";
PublicSystemIncludePaths.AddRange(
new string[] {
PhysXDir + "include",
PhysXDir + "include/foundation",
PhysXDir + "include/cooking",
PhysXDir + "include/common",
PhysXDir + "include/extensions",
PhysXDir + "include/geometry",
PhysXDir + "include/vehicle"
}
);
// Libraries and DLLs for windows platform
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/windows");
PhysXLibDir += "Win64/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicLibraryPaths.Add(PhysXLibDir);
string[] StaticLibrariesX64 = new string[] {
"PhysX3{0}_x64.lib",
"PhysX3Extensions{0}.lib",
"PhysX3Cooking{0}_x64.lib",
"PhysX3Common{0}_x64.lib",
"PhysX3Vehicle{0}.lib",
"PxTask{0}.lib",
"PhysXVisualDebuggerSDK{0}.lib",
"PhysXProfileSDK{0}.lib"
};
string[] DelayLoadDLLsX64 = new string[] {
"PhysX3{0}_x64.dll",
"PhysX3Cooking{0}_x64.dll",
"PhysX3Common{0}_x64.dll"
};
string[] RuntimeDependenciesX64 = new string[] {
"PhysX3{0}_x64.dll",
"PhysX3Common{0}_x64.dll",
"PhysX3Cooking{0}_x64.dll",
};
foreach (string Lib in StaticLibrariesX64)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
foreach (string DLL in DelayLoadDLLsX64)
{
PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix));
}
PublicDelayLoadDLLs.Add("nvToolsExt64_1.dll");
string PhysXBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX/{0}/Win64/VS{1}/", PhysXVersion, WindowsPlatform.GetVisualStudioCompilerVersionName());
foreach (string DLL in RuntimeDependenciesX64)
{
string FileName = PhysXBinariesDir + String.Format(DLL, LibrarySuffix);
RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
}
RuntimeDependencies.Add(PhysXBinariesDir + "nvToolsExt64_1.dll", StagedFileType.NonUFS);
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32"))
{
PublicIncludePaths.Add(PhysXDir + "include/foundation/windows");
PhysXLibDir += "Win32/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicLibraryPaths.Add(PhysXLibDir);
string[] StaticLibrariesX86 = new string[] {
"PhysX3{0}_x86.lib",
"PhysX3Extensions{0}.lib",
"PhysX3Cooking{0}_x86.lib",
"PhysX3Common{0}_x86.lib",
"PhysX3Vehicle{0}.lib",
"PxTask{0}.lib",
"PhysXVisualDebuggerSDK{0}.lib",
"PhysXProfileSDK{0}.lib"
};
string[] DelayLoadDLLsX86 = new string[] {
"PhysX3{0}_x86.dll",
"PhysX3Cooking{0}_x86.dll",
"PhysX3Common{0}_x86.dll"
};
string[] RuntimeDependenciesX86 = new string[] {
"PhysX3{0}_x86.dll",
"PhysX3Common{0}_x86.dll",
"PhysX3Cooking{0}_x86.dll",
};
foreach (string Lib in StaticLibrariesX86)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
foreach (string DLL in DelayLoadDLLsX86)
{
PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix));
}
PublicDelayLoadDLLs.Add("nvToolsExt32_1.dll");
string PhysXBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX/{0}/Win32/VS{1}/", PhysXVersion, WindowsPlatform.GetVisualStudioCompilerVersionName());
foreach (string DLL in RuntimeDependenciesX86)
{
string FileName = PhysXBinariesDir + String.Format(DLL, LibrarySuffix);
RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
}
RuntimeDependencies.Add(PhysXBinariesDir + "nvToolsExt32_1.dll", StagedFileType.NonUFS);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix");
PhysXLibDir += "/osx64";
PublicLibraryPaths.Add(PhysXLibDir);
string[] StaticLibrariesMac = new string[] {
PhysXLibDir + "/libLowLevel{0}.a",
PhysXLibDir + "/libLowLevelCloth{0}.a",
PhysXLibDir + "/libPhysX3{0}.a",
PhysXLibDir + "/libPhysX3Extensions{0}.a",
PhysXLibDir + "/libPhysX3Cooking{0}.a",
PhysXLibDir + "/libPhysX3Common{0}.a",
PhysXLibDir + "/libPhysX3Vehicle{0}.a",
PhysXLibDir + "/libPxTask{0}.a",
PhysXLibDir + "/libPhysXVisualDebuggerSDK{0}.a",
PhysXLibDir + "/libPhysXProfileSDK{0}.a",
PhysXLibDir + "/libPvdRuntime{0}.a",
PhysXLibDir + "/libSceneQuery{0}.a",
PhysXLibDir + "/libSimulationController{0}.a"
};
foreach (string Lib in StaticLibrariesMac)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix");
PublicLibraryPaths.Add(PhysXLibDir + "Android/ARMv7");
PublicLibraryPaths.Add(PhysXLibDir + "Android/x86");
PublicLibraryPaths.Add(PhysXLibDir + "Android/arm64");
PublicLibraryPaths.Add(PhysXLibDir + "Android/x64");
string[] StaticLibrariesAndroid = new string[] {
"LowLevel{0}",
"LowLevelCloth{0}",
"PhysX3{0}",
"PhysX3Extensions{0}",
// "PhysX3Cooking{0}", // not needed until Apex
"PhysX3Common{0}",
"PhysX3Vehicle{0}",
"PxTask{0}",
"PhysXVisualDebuggerSDK{0}",
"PhysXProfileSDK{0}",
"PvdRuntime{0}",
"SceneQuery{0}",
"SimulationController{0}",
};
// shipping libs do not need this
if (LibraryMode != PhysXLibraryMode.Shipping)
{
// use for profiling, but crash handler won't work
// PublicAdditionalLibraries.Add("nvToolsExt");
// disables profiling, crash handler will work
PublicAdditionalLibraries.Add("nvToolsExtStub");
}
foreach (string Lib in StaticLibrariesAndroid)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PhysXLibDir += "/Linux/" + Target.Architecture;
PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix");
PublicLibraryPaths.Add(PhysXLibDir);
string[] StaticLibrariesLinux = new string[] {
"rt",
"LowLevel{0}",
"LowLevelCloth{0}",
"PhysX3{0}",
"PhysX3Extensions{0}",
"PhysX3Cooking{0}",
"PhysX3Common{0}",
"PhysX3Vehicle{0}",
"PxTask{0}",
"PhysXVisualDebuggerSDK{0}",
"PhysXProfileSDK{0}",
"PvdRuntime{0}",
"SceneQuery{0}",
"SimulationController{0}",
};
if (LibraryMode == PhysXLibraryMode.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
{
//@TODO: Needed?
PublicAdditionalLibraries.Add("m");
}
foreach (string Lib in StaticLibrariesLinux)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix");
PhysXLibDir = Path.Combine(PhysXLibDir, Target.Platform.ToString());
PublicLibraryPaths.Add(PhysXLibDir);
string[] PhysXLibs = new string[]
{
"LowLevel",
"LowLevelCloth",
"PhysX3",
"PhysX3Common",
// "PhysX3Cooking", // not needed until Apex
"PhysX3Extensions",
"PhysX3Vehicle",
"PxTask",
"PhysXVisualDebuggerSDK",
"PhysXProfileSDK",
"PvdRuntime",
"SceneQuery",
"SimulationController",
};
foreach (string PhysXLib in PhysXLibs)
{
PublicAdditionalLibraries.Add(PhysXLib + LibrarySuffix);
PublicAdditionalShadowFiles.Add(Path.Combine(PhysXLibDir, "lib" + PhysXLib + LibrarySuffix + ".a"));
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix");
PhysXLibDir = Path.Combine(PhysXLibDir, "HTML5/");
string[] PhysXLibs = new string[]
{
"LowLevel",
"LowLevelCloth",
"PhysX3",
"PhysX3Common",
"PhysX3Cooking",
"PhysX3Extensions",
"PxTask",
"PhysXVisualDebuggerSDK",
"PhysXProfileSDK",
"PvdRuntime",
"SceneQuery",
"SimulationController",
};
foreach (var lib in PhysXLibs)
{
if (!lib.Contains("Cooking") || Target.IsCooked == false)
{
PublicAdditionalLibraries.Add(PhysXLibDir + lib + (UEBuildConfiguration.bCompileForSize ? "_Oz" : "") + ".bc");
}
}
if (UEBuildConfiguration.bCompilePhysXVehicle)
{
string[] PhysXVehicleLibs = new string[]
{
"PhysX3Vehicle",
};
foreach (var lib in PhysXVehicleLibs)
{
if (!lib.Contains("Cooking") || Target.IsCooked == false)
{
PublicAdditionalLibraries.Add(PhysXLibDir + lib + (UEBuildConfiguration.bCompileForSize ? "_Oz" : "") + ".bc");
}
}
}
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/PS4");
PublicLibraryPaths.Add(PhysXDir + "lib/PS4");
string[] StaticLibrariesPS4 = new string[] {
"PhysX3{0}",
"PhysX3Extensions{0}",
"PhysX3Cooking{0}",
"PhysX3Common{0}",
"PhysX3Vehicle{0}",
"PxTask{0}",
"PhysXVisualDebuggerSDK{0}",
"PhysXProfileSDK{0}"
};
foreach (string Lib in StaticLibrariesPS4)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
PublicSystemIncludePaths.Add("include/foundation/xboxone");
PublicLibraryPaths.Add(PhysXDir + "Lib/XboxOne/VS" + VersionName.ToString());
string[] StaticLibrariesXB1 = new string[] {
"PhysX3{0}.lib",
"PhysX3Extensions{0}.lib",
"PhysX3Cooking{0}.lib",
"PhysX3Common{0}.lib",
"PhysX3Vehicle{0}.lib",
"PxTask{0}.lib",
"PhysXVisualDebuggerSDK{0}.lib",
"PhysXProfileSDK{0}.lib"
};
foreach (string Lib in StaticLibrariesXB1)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
}
}
}
public HoudiniEngineRuntime(TargetInfo Target)
{
string HFSPath = "";
string HoudiniVersion = "14.0.374";
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac)
{
string Err = string.Format("Houdini Engine : Compiling on unsupported platform.");
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
if (HFSPath == "")
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// We first check if Houdini Engine is installed.
HFSPath = "C:/Program Files/Side Effects Software/Houdini Engine " + HoudiniVersion;
if (!Directory.Exists(HFSPath))
{
// If Houdini Engine is not installed, we check for Houdini installation.
HFSPath = "C:/Program Files/Side Effects Software/Houdini " + HoudiniVersion;
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine : Please install Houdini or Houdini Engine {0}", HoudiniVersion);
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
HFSPath = "/Library/Frameworks/Houdini.framework/Versions/" + HoudiniVersion + "/Resources";
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine : Please install Houdini {0}", HoudiniVersion);
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
}
}
string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (HFSPath != "")
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
HAPIIncludePath,
"HoudiniEngineRuntime/Public"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngineRuntime/Private"
// ... add other private include paths required here ...
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"ShaderCore",
"InputCore",
"RHI",
"TargetPlatform",
"Settings",
"Foliage"
}
);
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"AssetTools",
"UnrealEd",
"Slate",
"SlateCore",
"Projects",
"PropertyEditor",
"ContentBrowser",
"LevelEditor",
"MainFrame",
"EditorStyle",
"EditorWidgets",
"AppFramework",
"RawMesh"
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public GameLiftServerSDK(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"GameLiftServerSDK/Public"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"GameLiftServerSDK/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", ".."));
string SDKDirectory = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftServerSDK", Target.Platform.ToString());
bool bHasGameLiftSDK = System.IO.Directory.Exists(SDKDirectory);
if (bHasGameLiftSDK)
{
if (Target.Type == TargetRules.TargetType.Server)
{
Definitions.Add("WITH_GAMELIFT=1");
if (Target.Platform == UnrealTargetPlatform.Linux)
{
SDKDirectory = System.IO.Path.Combine(SDKDirectory, "x86_64-unknown-linux-gnu");
string SDKLib = System.IO.Path.Combine(SDKDirectory, "libaws-cpp-sdk-gamelift-server.so");
PublicLibraryPaths.Add(SDKDirectory);
PublicAdditionalLibraries.Add(SDKLib);
RuntimeDependencies.Add(new RuntimeDependency(SDKLib));
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicLibraryPaths.Add(SDKDirectory);
PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.lib"));
PublicDelayLoadDLLs.Add("aws-cpp-sdk-gamelift-server.dll");
string SDKLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.dll");
RuntimeDependencies.Add(new RuntimeDependency(SDKLibWindows));
}
}
else
{
Definitions.Add("WITH_GAMELIFT=0");
}
}
else
{
Definitions.Add("WITH_GAMELIFT=0");
}
}
public ICU(TargetInfo Target)
{
Type = ModuleType.External;
string ICUVersion = "icu4c-53_1";
string ICURootPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "ICU/" + ICUVersion + "/";
// Includes
PublicSystemIncludePaths.Add(ICURootPath + "include" + "/");
string PlatformFolderName = Target.Platform.ToString();
string TargetSpecificPath = ICURootPath + PlatformFolderName + "/";
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
TargetSpecificPath = ICURootPath + "Win32/";
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32"))
{
string VSVersionFolderName = "VS" + WindowsPlatform.GetVisualStudioCompilerVersionName();
TargetSpecificPath += VSVersionFolderName + "/";
string[] LibraryNameStems =
{
"dt", // Data
"uc", // Unicode Common
"in", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ?
"d" : string.Empty;
// Library Paths
PublicLibraryPaths.Add(TargetSpecificPath + "lib" + "/");
EICULinkType ICULinkType = Target.IsMonolithic ? EICULinkType.Static : EICULinkType.Dynamic;
switch (ICULinkType)
{
case EICULinkType.Static:
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "sicu" + Stem + LibraryNamePostfix + "." + "lib";
PublicAdditionalLibraries.Add(LibraryName);
}
break;
case EICULinkType.Dynamic:
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "icu" + Stem + LibraryNamePostfix + "." + "lib";
PublicAdditionalLibraries.Add(LibraryName);
}
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "icu" + Stem + LibraryNamePostfix + "53" + "." + "dll";
PublicDelayLoadDLLs.Add(LibraryName);
}
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
string BinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/ICU/{0}/{1}/VS{2}/", ICUVersion, Target.Platform.ToString(), WindowsPlatform.GetVisualStudioCompilerVersionName());
foreach (string Stem in LibraryNameStems)
{
string LibraryName = BinariesDir + String.Format("icu{0}{1}53.dll", Stem, LibraryNamePostfix);
RuntimeDependencies.Add(new RuntimeDependency(LibraryName));
}
}
break;
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Android)
{
string StaticLibraryExtension = "a";
switch (Target.Platform)
{
case UnrealTargetPlatform.Linux:
TargetSpecificPath += Target.Architecture + "/";
break;
case UnrealTargetPlatform.Android:
PublicLibraryPaths.Add(TargetSpecificPath + "ARMv7/lib");
PublicLibraryPaths.Add(TargetSpecificPath + "ARM64/lib");
PublicLibraryPaths.Add(TargetSpecificPath + "x86/lib");
PublicLibraryPaths.Add(TargetSpecificPath + "x64/lib");
break;
}
string[] LibraryNameStems =
{
"data", // Data
"uc", // Unicode Common
"i18n", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ?
"d" : string.Empty;
// Library Paths
EICULinkType ICULinkType = (Target.Platform == UnrealTargetPlatform.Android || Target.IsMonolithic) ? EICULinkType.Static : EICULinkType.Dynamic;
switch (ICULinkType)
{
case EICULinkType.Static:
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "icu" + Stem + LibraryNamePostfix;
if (Target.Platform == UnrealTargetPlatform.Android)
{
// we will filter out in the toolchain
PublicAdditionalLibraries.Add(LibraryName); // Android requires only the filename.
}
else
{
PublicAdditionalLibraries.Add(TargetSpecificPath + "lib/" + "lib" + LibraryName + "." + StaticLibraryExtension); // Linux seems to need the path, not just the filename.
}
}
break;
case EICULinkType.Dynamic:
if (Target.Platform == UnrealTargetPlatform.Linux)
{
string PathToBinary = String.Format("$(EngineDir)/Binaries/ThirdParty/ICU/{0}/{1}/{2}/", ICUVersion, Target.Platform.ToString(),
Target.Architecture);
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "icu" + Stem + LibraryNamePostfix;
string LibraryPath = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Linux/" + Target.Architecture + "/";
PublicLibraryPaths.Add(LibraryPath);
PublicAdditionalLibraries.Add(LibraryName);
// add runtime dependencies (for staging)
RuntimeDependencies.Add(new RuntimeDependency(PathToBinary + "lib" + LibraryName + ".so"));
RuntimeDependencies.Add(new RuntimeDependency(PathToBinary + "lib" + LibraryName + ".so.53")); // version-dependent
}
}
break;
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS)
{
string StaticLibraryExtension = "a";
string DynamicLibraryExtension = "dylib";
string[] LibraryNameStems =
{
"data", // Data
"uc", // Unicode Common
"i18n", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ?
"d" : string.Empty;
EICULinkType ICULinkType = (Target.Platform == UnrealTargetPlatform.IOS || Target.IsMonolithic) ? EICULinkType.Static : EICULinkType.Dynamic;
// Library Paths
switch (ICULinkType)
{
case EICULinkType.Static:
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "libicu" + Stem + LibraryNamePostfix + "." + StaticLibraryExtension;
PublicAdditionalLibraries.Add(TargetSpecificPath + "lib/" + LibraryName);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalShadowFiles.Add(TargetSpecificPath + "lib/" + LibraryName);
}
}
break;
case EICULinkType.Dynamic:
foreach (string Stem in LibraryNameStems)
{
if (Target.Platform == UnrealTargetPlatform.Mac)
{
string LibraryName = "libicu" + Stem + ".53.1" + LibraryNamePostfix + "." + DynamicLibraryExtension;
string LibraryPath = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Mac/" + LibraryName;
PublicDelayLoadDLLs.Add(LibraryPath);
PublicAdditionalShadowFiles.Add(LibraryPath);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
string LibraryName = "icu" + Stem + LibraryNamePostfix;
string LibraryPath = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Linux/" + Target.Architecture + "/";
PublicLibraryPaths.Add(LibraryPath);
PublicAdditionalLibraries.Add(LibraryName);
}
}
break;
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
// we don't bother with debug libraries on HTML5. Mainly because debugging isn't viable on html5 currently
string StaticLibraryExtension = "bc";
string[] LibraryNameStems =
{
"data", // Data
"uc", // Unicode Common
"i18n", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "libicu" + Stem + "." + StaticLibraryExtension;
PublicAdditionalLibraries.Add(TargetSpecificPath + LibraryName);
}
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
string LibraryNamePrefix = "sicu";
string[] LibraryNameStems =
{
"dt", // Data
"uc", // Unicode Common
"in", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug) ?
"d" : string.Empty;
string LibraryExtension = "lib";
foreach (string Stem in LibraryNameStems)
{
string LibraryName = ICURootPath + "PS4/lib/" + LibraryNamePrefix + Stem + LibraryNamePostfix + "." + LibraryExtension;
PublicAdditionalLibraries.Add(LibraryName);
}
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
string LibraryNamePrefix = "sicu";
string[] LibraryNameStems =
{
"dt", // Data
"uc", // Unicode Common
"in", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ?
"d" : string.Empty;
string LibraryExtension = "lib";
foreach (string Stem in LibraryNameStems)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
string LibraryName = ICURootPath + "XboxOne/VS" + VersionName.ToString() + "/lib/" + LibraryNamePrefix + Stem + LibraryNamePostfix + "." + LibraryExtension;
PublicAdditionalLibraries.Add(LibraryName);
}
}
}
// common defines
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Linux) ||
(Target.Platform == UnrealTargetPlatform.Android) ||
(Target.Platform == UnrealTargetPlatform.Mac) ||
(Target.Platform == UnrealTargetPlatform.IOS) ||
(Target.Platform == UnrealTargetPlatform.PS4) ||
(Target.Platform == UnrealTargetPlatform.XboxOne) ||
(Target.Platform == UnrealTargetPlatform.HTML5))
{
// Definitions
Definitions.Add("U_USING_ICU_NAMESPACE=0"); // Disables a using declaration for namespace "icu".
Definitions.Add("U_STATIC_IMPLEMENTATION"); // Necessary for linking to ICU statically.
Definitions.Add("U_NO_DEFAULT_INCLUDE_UTF_HEADERS=1"); // Disables unnecessary inclusion of headers - inclusions are for ease of use.
Definitions.Add("UNISTR_FROM_CHAR_EXPLICIT=explicit"); // Makes UnicodeString constructors for ICU character types explicit.
Definitions.Add("UNISTR_FROM_STRING_EXPLICIT=explicit"); // Makes UnicodeString constructors for "char"/ICU string types explicit.
Definitions.Add("UCONFIG_NO_TRANSLITERATION=1"); // Disables declarations and compilation of unused ICU transliteration functionality.
}
if (Target.Platform == UnrealTargetPlatform.PS4)
{
// Definitions
Definitions.Add("ICU_NO_USER_DATA_OVERRIDE=1");
Definitions.Add("U_PLATFORM=U_PF_ORBIS");
}
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Definitions
Definitions.Add("ICU_NO_USER_DATA_OVERRIDE=1");
Definitions.Add("U_PLATFORM=U_PF_DURANGO");
}
}
public Engine(TargetInfo Target)
{
PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";
SharedPCHHeaderFile = "Public/EngineSharedPCH.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"MovieSceneCapture",
"DesktopPlatform",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"RenderCore",
"RHI",
"ShaderCore",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"AIModule",
"DatabaseSupport",
"PacketHandler",
"HardwareSurvey",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "CrashTracker" });
DynamicallyLoadedModuleNames.AddRange(new string[] { "CrashTracker" });
PublicDependencyModuleNames.AddRange(
new string[] {
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"Internationalization",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET",
}
);
// to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
if (Target.Type == TargetRules.TargetType.Editor)
{
// for now we depend on this
PrivateDependencyModuleNames.Add("RawMesh");
}
bool bVariadicTemplatesSupported = true;
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
if (VersionName.ToString().Equals("2012"))
{
bVariadicTemplatesSupported = false;
}
}
}
if (bVariadicTemplatesSupported)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("GameplayTags");
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
CircularlyReferencedDependentModules.Add("CinematicCamera");
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
// So does Geometry Cache
DynamicallyLoadedModuleNames.Add("GeometryCache");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"StreamingPauseRendering",
}
);
PrivateIncludePathModuleNames.Add("LightPropagationVolumeRuntime");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetRules.TargetType.Server || Target.Type == TargetRules.TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (UEBuildConfiguration.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
});
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.Type.Value != TargetRules.TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper",
"GameLiveStreaming"
}
);
}
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
PrivateIncludePathModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("HierarchicalLODUtilities");
}
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
PrivateIncludePathModuleNames.Add("PhysXFormats");
}
SetupModuleBox2DSupport(Target);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus",
"OpenSubdiv"
);
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectShow");
}
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import this also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
Definitions.Add("WITH_RECAST=0");
}
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (UEBuildConfiguration.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
DynamicallyLoadedModuleNames.Add("Niagara");
}
private Mining()
{
HarvestResource[] res;
HarvestVein[] veins;
#region Mining for ore and stone
HarvestDefinition oreAndStone = new HarvestDefinition();
// Resource banks are every 8x8 tiles
oreAndStone.BankWidth = 8;
oreAndStone.BankHeight = 8;
// Every bank holds from 10 to 34 ore
oreAndStone.MinTotal = 10;
oreAndStone.MaxTotal = 34;
// A resource bank will respawn its content every 10 to 20 minutes
oreAndStone.MinRespawn = TimeSpan.FromMinutes(10.0);
oreAndStone.MaxRespawn = TimeSpan.FromMinutes(20.0);
// Skill checking is done on the Mining skill
oreAndStone.Skill = SkillName.Mining;
// Set the list of harvestable tiles
oreAndStone.Tiles = m_MountainAndCaveTiles;
// Players must be within 2 tiles to harvest
oreAndStone.MaxRange = 2;
// One ore per harvest action
oreAndStone.ConsumedPerHarvest = 1;
oreAndStone.ConsumedPerFeluccaHarvest = 2;
// The digging effect
oreAndStone.EffectActions = new[] { 11 };
oreAndStone.EffectSounds = new[] { 0x125, 0x126 };
oreAndStone.EffectCounts = new[] { 1 };
oreAndStone.EffectDelay = TimeSpan.FromSeconds(1.6);
oreAndStone.EffectSoundDelay = TimeSpan.FromSeconds(0.9);
oreAndStone.NoResourcesMessage = 503040; // There is no metal here to mine.
oreAndStone.DoubleHarvestMessage = 503042; // Someone has gotten to the metal before you.
oreAndStone.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining.
oreAndStone.OutOfRangeMessage = 500446; // That is too far away.
oreAndStone.FailMessage = 503043; // You loosen some rocks but fail to find any useable ore.
oreAndStone.PackFullMessage = 1010481; // Your backpack is full, so the ore you mined is lost.
oreAndStone.ToolBrokeMessage = 1044038; // You have worn out your tool!
// "You dig some ~ore~ and put in your backpack."
res = new[]
{
new HarvestResource(0.0, 0.0, 0.0, "You dig some Iron ore and put it in your backpack.", typeof(IronOre)),
new HarvestResource(1.0, 1.0, 1.0, "You dig some Gold ore and put it in your backpack.", typeof(GoldOre)),
new HarvestResource(5.0, 5.0, 5.0, "You dig some Spike ore and put it in your backpack.", typeof(SpikeOre)),
new HarvestResource(10.0, 10.0, 10.0, "You dig some Fruity ore and put it in your backpack.", typeof(FruityOre)),
new HarvestResource(15.0, 15.0, 15.0, "You dig some Bronze ore and put it in your backpack.", typeof(BronzeOre)),
new HarvestResource(20.0, 20.0, 20.0, "You dig some Ice Rock ore and put it in your backpack.", typeof(IceRockOre)),
new HarvestResource(25.0, 25.0, 25.0, "You dig some Black Dwarf ore and put it in your backpack.", typeof(BlackDwarfOre)),
new HarvestResource(30.0, 30.0, 30.0, "You dig some Dull Copper ore and put it in your backpack.", typeof(DullCopperOre)),
new HarvestResource(35.0, 35.0, 35.0, "You dig some Platinum ore and put it in your backpack.", typeof(PlatinumOre)),
new HarvestResource(40.0, 40.0, 40.0, "You dig some Silver Rock ore and put it in your backpack.", typeof(SilverRockOre)),
new HarvestResource(45.0, 45.0, 45.0, "You dig some Dark Pagan ore and put it in your backpack.", typeof(DarkPaganOre)),
new HarvestResource(50.0, 50.0, 50.0, "You dig some Copper ore and put it in your backpack.", typeof(CopperOre)),
new HarvestResource(55.0, 55.0, 55.0, "You dig some Mystic ore and put it in your backpack.", typeof(MysticOre)),
new HarvestResource(60.0, 60.0, 60.0, "You dig some Spectral ore and put it in your backpack.", typeof(SpectralOre)),
new HarvestResource(65.0, 65.0, 65.0, "You dig some Old Britain ore and put it in your backpack.", typeof(OldBritainOre)),
new HarvestResource(70.0, 70.0, 70.0, "You dig some Onyx ore and put it in your backpack.", typeof(OnyxOre)),
new HarvestResource(75.0, 75.0, 75.0, "You dig some Red Elven ore and put it in your backpack.", typeof(RedElvenOre)),
new HarvestResource(80.0, 80.0, 80.0, "You dig some Undead ore and put it in your backpack.", typeof(UndeadOre)),
new HarvestResource(85.0, 85.0, 85.0, "You dig some Pyrite ore and put it in your backpack.", typeof(PyriteOre)),
new HarvestResource(90.0, 90.0, 90.0, "You dig some Virginity ore and put it in your backpack.", typeof(VirginityOre)),
new HarvestResource(95.0, 95.0, 95.0, "You dig some Malachite ore and put it in your backpack.", typeof(MalachiteOre)),
new HarvestResource(97.0, 97.0, 97.0, "You dig some Lavarock ore and put it in your backpack.", typeof(LavarockOre)),
new HarvestResource(98.0, 98.0, 98.0, "You dig some Azurite ore and put it in your backpack.", typeof(AzuriteOre)),
new HarvestResource(100.0, 100.0, 100.0, "You dig some Dripstone ore and put it in your backpack.", typeof(DripstoneOre)),
new HarvestResource(104.0, 104.0, 104.0, "You dig some Executor ore and put it in your backpack.", typeof(ExecutorOre)),
new HarvestResource(108.0, 108.0, 108.0, "You dig some Peachblue ore and put it in your backpack.", typeof(PeachblueOre)),
new HarvestResource(112.0, 112.0, 112.0, "You dig some Destruction ore and put it in your backpack.", typeof(DestructionOre)),
new HarvestResource(116.0, 116.0, 116.0, "You dig some Anra ore and put it in your backpack.", typeof(AnraOre)),
new HarvestResource(119.0, 119.0, 119.0, "You dig some Crystal ore and put it in your backpack.", typeof(CrystalOre)),
new HarvestResource(122.0, 122.0, 122.0, "You dig some Doom ore and put it in your backpack.", typeof(DoomOre)),
new HarvestResource(125.0, 125.0, 125.0, "You dig some Goddess ore and put it in your backpack.", typeof(GoddessOre)),
new HarvestResource(129.0, 129.0, 129.0, "You dig some New Zulu ore and put it in your backpack.", typeof(NewZuluOre)),
new HarvestResource(130.0, 130.0, 130.0, "You dig some Dark Sable Ruby ore and put it in your backpack.", typeof(DarkSableRubyOre)),
new HarvestResource(130.0, 130.0, 130.0, "You dig some Ebon Twilight Sapphire ore and put it in your backpack.", typeof(EbonTwilightSapphireOre)),
new HarvestResource(140.0, 140.0, 140.0, "You dig some Radiant Nimbus Diamond ore and put it in your backpack.", typeof(RadiantNimbusDiamondOre)),
};
veins = new[]
{
new HarvestVein(49.6, 0.0, res[0], null), // Iron
new HarvestVein(11.2, 0.5, res[1], res[0]), // Gold
new HarvestVein(09.8, 0.5, res[2], res[0]), // Spike
new HarvestVein(08.4, 0.5, res[4], res[0]), // Fruity
new HarvestVein(07.0, 0.5, res[5], res[0]), // Bronze
new HarvestVein(05.6, 0.5, res[6], res[0]), // IceRock
new HarvestVein(04.2, 0.5, res[7], res[0]), // BlackDwarf
new HarvestVein(02.8, 0.5, res[8], res[0]), // DullCopper
new HarvestVein(01.4, 0.5, res[9], res[0]), // Platinum
new HarvestVein(0.1, 0.5, res[10], res[0]), // SilverRock
new HarvestVein(0.1, 0.5, res[11], res[0]), // DarkPagan
new HarvestVein(0.1, 0.5, res[12], res[0]), // Copper
new HarvestVein(0.1, 0.5, res[13], res[0]), // Mystic
new HarvestVein(0.1, 0.5, res[14], res[0]), // Spectral
new HarvestVein(0.1, 0.5, res[15], res[0]), // OldBritain
new HarvestVein(0.1, 0.5, res[16], res[0]), // Onyx
new HarvestVein(0.1, 0.5, res[17], res[0]), // RedElven
new HarvestVein(0.1, 0.5, res[18], res[0]), // Undead
new HarvestVein(0.1, 0.5, res[19], res[0]), // Pyrite
new HarvestVein(0.1, 0.5, res[20], res[0]), // Virginity
new HarvestVein(0.1, 0.5, res[21], res[0]), // Malachite
new HarvestVein(0.1, 0.5, res[22], res[0]), // Lavarock
new HarvestVein(0.1, 0.5, res[23], res[0]), // Azurite
new HarvestVein(0.1, 0.5, res[24], res[0]), // Dripstone
new HarvestVein(0.1, 0.5, res[24], res[0]), // Executor
new HarvestVein(0.1, 0.5, res[25], res[0]), // Peachblue
new HarvestVein(0.1, 0.5, res[26], res[0]), // Destruction
new HarvestVein(0.1, 0.5, res[27], res[0]), // Anra
new HarvestVein(0.1, 0.5, res[28], res[0]), // Crystal
new HarvestVein(0.1, 0.5, res[29], res[0]), // Doom
new HarvestVein(0.1, 0.5, res[30], res[0]), // Goddess
new HarvestVein(0.1, 0.5, res[31], res[0]), // NewZulu
new HarvestVein(0.1, 0.5, res[32], res[0]), // DarkSableRuby
new HarvestVein(0.1, 0.5, res[33], res[0]), // EbonTwilightSapphire
new HarvestVein(0.1, 0.5, res[34], res[0]), // RadiantNimbusDiamond
};
oreAndStone.Resources = res;
oreAndStone.Veins = veins;
oreAndStone.RaceBonus = false;
oreAndStone.RandomizeVeins = false;
Definitions.Add(oreAndStone);
#endregion
}
public ROSIntegration(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string BSONPath = Path.Combine(ThirdPartyPath, "bson");
// Console.WriteLine("");
Console.WriteLine("BSONPath: " + BSONPath);
// Include std::string functions for rapidjson
Definitions.Add("RAPIDJSON_HAS_STDSTRING=1");
PublicIncludePaths.AddRange(
new string[] {
"ROSIntegration/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"ROSIntegration/Private",
"ROSIntegration/Private/rosbridge2cpp"
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Sockets",
"Networking"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
Console.WriteLine("Using Windows BSON files");
PublicAdditionalLibraries.Add(Path.Combine(BSONPath, "lib", "bson-static-1.0.lib"));
PublicIncludePaths.Add(Path.Combine(BSONPath, "include", "windows"));
}
}
private HerbGathering()
{
HarvestResource[] res;
HarvestVein[] veins;
#region HerbGathering
HarvestDefinition herbs = new HarvestDefinition();
// Resource banks are every 4x3 tiles
herbs.BankWidth = 1;
herbs.BankHeight = 1;
// Every bank holds from 20 to 45 logs
herbs.MinTotal = 2;
herbs.MaxTotal = 8;
// A resource bank will respawn its content every 20 to 30 minutes
herbs.MinRespawn = TimeSpan.FromMinutes(30.0);
herbs.MaxRespawn = TimeSpan.FromMinutes(60.0);
// Skill checking is done on the Camping skill
herbs.Skill = SkillName.Camping;
// Set the list of harvestable tiles
herbs.Tiles = m_PlantTiles;
// Players must be within 2 tiles to harvest
herbs.MaxRange = 2;
// Ten logs per harvest action
herbs.ConsumedPerHarvest = 2;
herbs.ConsumedPerFeluccaHarvest = 2;
// The chopping effect
herbs.EffectActions = new int[] { 13 };
herbs.EffectSounds = new int[] { 0x13E };
herbs.EffectCounts = (Core.AOS ? new int[] { 1 } : new int[] { 1, 2, 2, 2, 3 });
herbs.EffectDelay = TimeSpan.FromSeconds(1.6);
herbs.EffectSoundDelay = TimeSpan.FromSeconds(0.9);
herbs.NoResourcesMessage = "There's not enough herbs left to harvest."; // There's not enough wood here to harvest.
herbs.FailMessage = "You fail to find any usable herbs."; // You hack at the tree for a while, but fail to produce any useable wood.
herbs.OutOfRangeMessage = 500446; // That is too far away.
herbs.PackFullMessage = "You can't place any more herbs in your pack."; // You can't place any wood into your backpack!
herbs.ToolBrokeMessage = "You broke your sickle."; // You broke your axe.
var common = "You find some common herbs.";
res = new HarvestResource[]
{
new HarvestResource(00.0, 00.0, 100.0, common, typeof(BlackPearl)),
new HarvestResource(00.0, 00.0, 100.0, common, typeof(Bloodmoss)),
new HarvestResource(00.0, 00.0, 100.0, common, typeof(Garlic)),
new HarvestResource(00.0, 00.0, 100.0, common, typeof(Ginseng)),
new HarvestResource(00.0, 00.0, 100.0, common, typeof(MandrakeRoot)),
new HarvestResource(00.0, 00.0, 100.0, common, typeof(Nightshade)),
new HarvestResource(00.0, 00.0, 100.0, common, typeof(SpidersSilk)),
new HarvestResource(00.0, 00.0, 100.0, common, typeof(SulfurousAsh)),
new HarvestResource(99.9, 60.0, 140.0, "You find some batwings.", typeof(BatWing)),
new HarvestResource(99.9, 60.0, 140.0, "You find some eyes of newt.", typeof(EyeOfNewt)),
};
veins = new HarvestVein[]
{
new HarvestVein(10.0, 0.0, res[0], null),
new HarvestVein(10.0, 0.5, res[1], res[0]),
new HarvestVein(10.0, 0.5, res[2], res[0]),
new HarvestVein(10.0, 0.5, res[3], res[0]),
new HarvestVein(10.0, 0.5, res[4], res[0]),
new HarvestVein(10.0, 0.5, res[5], res[0]),
new HarvestVein(10.0, 0.5, res[6], res[0]),
new HarvestVein(10.0, 0.5, res[7], res[0]),
new HarvestVein(10.0, 0.5, res[8], res[0]),
new HarvestVein(10.0, 0.5, res[9], res[0]),
};
herbs.BonusResources = new BonusHarvestResource[]
{
new BonusHarvestResource(0, 83.9, null, null), //Nothing
//new BonusHarvestResource( 100, 10.0, 1072548, typeof( CommonSeeds ) ),
new BonusHarvestResource(100, 03.0, 1072550, typeof(Seed)),
//new BonusHarvestResource( 100, 02.0, 1072547, typeof( UnCommonSeeds ) ),
new BonusHarvestResource(100, 01.0, 1072549, typeof(ParasiticPlant)),
//new BonusHarvestResource( 100, 00.1, 1072551, typeof( ExoticSeeds ) )
};
herbs.Resources = res;
herbs.Veins = veins;
herbs.RaceBonus = false;
herbs.RandomizeVeins = false;
m_Definition = herbs;
Definitions.Add(herbs);
#endregion
}
private Mining()
{
HarvestResource[] res;
HarvestVein[] veins;
#region Mining for ore and stone
HarvestDefinition oreAndStone = m_OreAndStone = new HarvestDefinition();
// Resource banks are every 8x8 tiles
oreAndStone.BankWidth = 8;
oreAndStone.BankHeight = 8;
// Every bank holds from 10 to 34 ore
oreAndStone.MinTotal = 10;
oreAndStone.MaxTotal = 34;
// A resource bank will respawn its content every 10 to 20 minutes
oreAndStone.MinRespawn = TimeSpan.FromMinutes(10.0);
oreAndStone.MaxRespawn = TimeSpan.FromMinutes(20.0);
// Skill checking is done on the Mining skill
oreAndStone.Skill = SkillName.Mining;
// Set the list of harvestable tiles
oreAndStone.Tiles = m_MountainAndCaveTiles;
// Players must be within 2 tiles to harvest
oreAndStone.MaxRange = 2;
// One ore per harvest action
oreAndStone.ConsumedPerHarvest = 1;
oreAndStone.ConsumedPerFeluccaHarvest = 2;
// The digging effect
oreAndStone.EffectActions = new int[] { 11 };
oreAndStone.EffectSounds = new int[] { 0x125, 0x126 };
oreAndStone.EffectCounts = new int[] { 1 };
oreAndStone.EffectDelay = TimeSpan.FromSeconds(1.6);
oreAndStone.EffectSoundDelay = TimeSpan.FromSeconds(0.9);
oreAndStone.NoResourcesMessage = 503040; // There is no metal here to mine.
oreAndStone.DoubleHarvestMessage = 503042; // Someone has gotten to the metal before you.
oreAndStone.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining.
oreAndStone.OutOfRangeMessage = 500446; // That is too far away.
oreAndStone.FailMessage = 503043; // You loosen some rocks but fail to find any useable ore.
oreAndStone.PackFullMessage = 1010481; // Your backpack is full, so the ore you mined is lost.
oreAndStone.ToolBrokeMessage = 1044038; // You have worn out your tool!
res = new HarvestResource[]
{
new HarvestResource(00.0, 00.0, 100.0, 1007072, typeof(IronOre), typeof(Granite), typeof(Amber)),
new HarvestResource(65.0, 25.0, 105.0, 1007073, typeof(DullCopperOre), typeof(DullCopperGranite), typeof(Citrine), typeof(DullCopperElemental)),
new HarvestResource(70.0, 30.0, 110.0, 1007074, typeof(ShadowIronOre), typeof(ShadowIronGranite), typeof(Tourmaline), typeof(ShadowIronElemental)),
new HarvestResource(75.0, 35.0, 115.0, 1007075, typeof(CopperOre), typeof(CopperGranite), typeof(Ruby), typeof(CopperElemental)),
new HarvestResource(80.0, 40.0, 120.0, 1007076, typeof(BronzeOre), typeof(BronzeGranite), typeof(Amethyst), typeof(BronzeElemental)),
new HarvestResource(85.0, 45.0, 125.0, 1007077, typeof(GoldOre), typeof(GoldGranite), typeof(Sapphire), typeof(GoldenElemental)),
new HarvestResource(90.0, 50.0, 130.0, 1007078, typeof(AgapiteOre), typeof(AgapiteGranite), typeof(Emerald), typeof(AgapiteElemental)),
new HarvestResource(95.0, 55.0, 135.0, 1007079, typeof(VeriteOre), typeof(VeriteGranite), typeof(StarSapphire), typeof(VeriteElemental)),
new HarvestResource(99.0, 59.0, 139.0, 1007080, typeof(ValoriteOre), typeof(ValoriteGranite), typeof(Diamond), typeof(ValoriteElemental))
};
veins = new HarvestVein[]
{
new HarvestVein(49.6, 0.0, res[0], null), // Iron
new HarvestVein(11.2, 0.5, res[1], res[0]), // Dull Copper
new HarvestVein(09.8, 0.5, res[2], res[0]), // Shadow Iron
new HarvestVein(08.4, 0.5, res[3], res[0]), // Copper
new HarvestVein(07.0, 0.5, res[4], res[0]), // Bronze
new HarvestVein(05.6, 0.5, res[5], res[0]), // Gold
new HarvestVein(04.2, 0.5, res[6], res[0]), // Agapite
new HarvestVein(02.8, 0.5, res[7], res[0]), // Verite
new HarvestVein(01.4, 0.5, res[8], res[0]) // Valorite
};
oreAndStone.Resources = res;
oreAndStone.Veins = veins;
if (Core.ML)
{
oreAndStone.BonusResources = new BonusHarvestResource[]
{
new BonusHarvestResource(0, 99.4, null, null), //Nothing
new BonusHarvestResource(100, .1, 1072562, typeof(BlueDiamond)),
new BonusHarvestResource(100, .1, 1072567, typeof(DarkSapphire)),
new BonusHarvestResource(100, .1, 1072570, typeof(EcruCitrine)),
new BonusHarvestResource(100, .1, 1072564, typeof(FireRuby)),
new BonusHarvestResource(100, .1, 1072566, typeof(PerfectEmerald)),
new BonusHarvestResource(100, .1, 1072568, typeof(Turquoise))
};
}
oreAndStone.RaceBonus = Core.ML;
oreAndStone.RandomizeVeins = Core.ML;
Definitions.Add(oreAndStone);
#endregion
#region Mining for sand
HarvestDefinition sand = m_Sand = new HarvestDefinition();
// Resource banks are every 8x8 tiles
sand.BankWidth = 8;
sand.BankHeight = 8;
// Every bank holds from 6 to 12 sand
sand.MinTotal = 6;
sand.MaxTotal = 12;
// A resource bank will respawn its content every 10 to 20 minutes
sand.MinRespawn = TimeSpan.FromMinutes(10.0);
sand.MaxRespawn = TimeSpan.FromMinutes(20.0);
// Skill checking is done on the Mining skill
sand.Skill = SkillName.Mining;
// Set the list of harvestable tiles
sand.Tiles = m_SandTiles;
// Players must be within 2 tiles to harvest
sand.MaxRange = 2;
// One sand per harvest action
sand.ConsumedPerHarvest = 1;
sand.ConsumedPerFeluccaHarvest = 1;
// The digging effect
sand.EffectActions = new int[] { 11 };
sand.EffectSounds = new int[] { 0x125, 0x126 };
sand.EffectCounts = new int[] { 6 };
sand.EffectDelay = TimeSpan.FromSeconds(1.6);
sand.EffectSoundDelay = TimeSpan.FromSeconds(0.9);
sand.NoResourcesMessage = 1044629; // There is no sand here to mine.
sand.DoubleHarvestMessage = 1044629; // There is no sand here to mine.
sand.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining.
sand.OutOfRangeMessage = 500446; // That is too far away.
sand.FailMessage = 1044630; // You dig for a while but fail to find any of sufficient quality for glassblowing.
sand.PackFullMessage = 1044632; // Your backpack can't hold the sand, and it is lost!
sand.ToolBrokeMessage = 1044038; // You have worn out your tool!
res = new HarvestResource[]
{
new HarvestResource(100.0, 70.0, 400.0, 1044631, typeof(Sand))
};
veins = new HarvestVein[]
{
new HarvestVein(100.0, 0.0, res[0], null)
};
sand.Resources = res;
sand.Veins = veins;
Definitions.Add(sand);
#endregion
}
public Core(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
bAddDefaultIncludePaths = false;
PublicIncludePaths.AddRange(
new string[] {
"Runtime/Core/Public",
"Runtime/Core/Public/Internationalization",
"Runtime/Core/Public/Async",
"Runtime/Core/Public/Concurrency",
"Runtime/Core/Public/Containers",
"Runtime/Core/Public/Delegates",
"Runtime/Core/Public/GenericPlatform",
"Runtime/Core/Public/HAL",
"Runtime/Core/Public/Logging",
"Runtime/Core/Public/Math",
"Runtime/Core/Public/Misc",
"Runtime/Core/Public/Modules",
"Runtime/Core/Public/Modules/Boilerplate",
"Runtime/Core/Public/ProfilingDebugging",
"Runtime/Core/Public/Serialization",
"Runtime/Core/Public/Serialization/Csv",
"Runtime/Core/Public/Stats",
"Runtime/Core/Public/Templates",
"Runtime/Core/Public/UObject",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Core/Private",
"Runtime/Core/Private/Misc",
"Runtime/Core/Private/Serialization/Json",
"Runtime/Core/Private/Internationalization",
"Runtime/Core/Private/Internationalization/Cultures",
"Runtime/Analytics/Public",
"Runtime/Engine/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"InputDevice",
"Analytics",
"RHI"
}
);
if (UEBuildConfiguration.bBuildEditor == true)
{
DynamicallyLoadedModuleNames.Add("SourceCodeAccess");
PrivateIncludePathModuleNames.Add("DirectoryWatcher");
DynamicallyLoadedModuleNames.Add("DirectoryWatcher");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicIncludePaths.Add("Runtime/Core/Public/Windows");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"XInput"
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/Mac" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"zlib",
"OpenGL",
"PLCrashReporter"
);
PublicFrameworks.AddRange(new string[] { "Cocoa", "Carbon", "IOKit", "Security" });
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport");
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/IOS" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib"
);
PublicFrameworks.AddRange(new string[] { "UIKit", "Foundation", "AudioToolbox", "AVFoundation", "GameKit", "StoreKit", "CoreVideo", "CoreMedia", "CoreGraphics", "GameController", "SystemConfiguration" });
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(new string[] { "CoreMotion", "AdSupport" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"PLCrashReporter"
);
}
bool bSupportAdvertising = Target.Platform == UnrealTargetPlatform.IOS;
if (bSupportAdvertising)
{
PublicFrameworks.AddRange(new string[] { "iAD" });
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.Add("Runtime/Core/Public/Android");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"cxademangle",
"zlib"
);
}
else if ((Target.Platform == UnrealTargetPlatform.Linux))
{
PublicIncludePaths.Add("Runtime/Core/Public/Linux");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib",
"jemalloc",
"elftoolchain",
"SDL2"
);
// Core uses dlopen()
PublicAdditionalLibraries.Add("dl");
// We need FreeType2 and GL for the Splash, but only in the Editor
if (Target.Type == TargetType.Editor)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "FreeType2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
PrivateIncludePathModuleNames.Add("ImageWrapper");
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
PublicIncludePaths.Add("Runtime/Core/Public/HTML5");
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenAL");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
PrivateDependencyModuleNames.Add("HTML5JS");
PrivateDependencyModuleNames.Add("MapPakDownloader");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicAdditionalLibraries.Add("SceRtc_stub_weak"); //ORBIS SDK rtc.h, used in PS4Time.cpp
}
if (UEBuildConfiguration.bCompileICU == true)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
Definitions.Add("UE_ENABLE_ICU=" + (UEBuildConfiguration.bCompileICU ? "1" : "0")); // Enable/disable (=1/=0) ICU usage in the codebase. NOTE: This flag is for use while integrating ICU and will be removed afterward.
// If we're compiling with the engine, then add Core's engine dependencies
if (UEBuildConfiguration.bCompileAgainstEngine == true)
{
if (!UEBuildConfiguration.bBuildRequiresCookedData)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "DerivedDataCache" });
}
}
// On Windows platform, VSPerfExternalProfiler.cpp needs access to "VSPerf.h". This header is included with Visual Studio, but it's not in a standard include path.
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
var VisualStudioVersionNumber = "11.0";
var SubFolderName = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64/PerfSDK" : "PerfSDK";
string PerfIncludeDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), String.Format("Microsoft Visual Studio {0}/Team Tools/Performance Tools/{1}", VisualStudioVersionNumber, SubFolderName));
if (File.Exists(Path.Combine(PerfIncludeDirectory, "VSPerf.h")))
{
PrivateIncludePaths.Add(PerfIncludeDirectory);
Definitions.Add("WITH_VS_PERF_PROFILER=1");
}
else
{
Definitions.Add("WITH_VS_PERF_PROFILER=0");
}
}
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
WhitelistRestrictedFolders.Add("Private/Windows/NoRedist");
}
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
Definitions.Add("WITH_DIRECTXMATH=1");
}
else if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
// To enable this requires Win8 SDK
Definitions.Add("WITH_DIRECTXMATH=0"); // Enable to test on Win64/32.
//PublicDependencyModuleNames.AddRange( // Enable to test on Win64/32.
// new string[] {
// "DirectXMath"
//});
}
else
{
Definitions.Add("WITH_DIRECTXMATH=0");
}
}
public AgogCore(ReadOnlyTargetRules Target) : base(Target)
{
// Ignore warnings about hokey code in windows.h
bEnableUndefinedIdentifierWarnings = false;
// Check if Sk source code is present (Pro-RT license)
var bFullSource = File.Exists(Path.Combine(ModuleDirectory, "..", "SkookumScript", "Private", "SkookumScript", "Sk.cpp"));
// Allow packaging script to force a lib build by creating a temp file (Agog Labs internal)
bFullSource = bFullSource && !File.Exists(Path.Combine(ModuleDirectory, "..", "SkookumScript", "force-lib-build.txt"));
// If full source is present, build module from source, otherwise link with binary library
Type = bFullSource ? ModuleType.CPlusPlus : ModuleType.External;
// Enable fussy level of checking (Agog Labs internal)
ExternalDependencies.Add("enable-mad-check.txt");
var bMadCheck = File.Exists(Path.Combine(ModuleDirectory, "enable-mad-check.txt"));
if (bMadCheck)
{
Definitions.Add("A_MAD_CHECK");
}
// Add user define if exists (Agog Labs internal)
ExternalDependencies.Add("mad-define.txt");
var userDefineFilePath = Path.Combine(ModuleDirectory, "mad-define.txt");
if (File.Exists(userDefineFilePath))
{
var userDefine = File.ReadAllText(userDefineFilePath).Trim();
if (userDefine.Length > 0)
{
Definitions.Add(userDefine);
}
}
var bPlatformAllowed = false;
List <string> platPathSuffixes = new List <string>();
string libNameExt = ".a";
string libNamePrefix = "lib";
string libNameSuffix = "";
string platformName = "";
bool useDebugCRT = Target.bDebugBuildsActuallyUseDebugCRT;
switch (Target.Platform)
{
case UnrealTargetPlatform.Win32:
case UnrealTargetPlatform.Win64:
bPlatformAllowed = true;
platformName = Target.Platform == UnrealTargetPlatform.Win64 ? "Win64" : "Win32";
platPathSuffixes.Add(Path.Combine(platformName, Target.WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015 ? "VS2015" : "VS2013"));
libNameExt = ".lib";
libNamePrefix = "";
break;
case UnrealTargetPlatform.Mac:
bPlatformAllowed = true;
platformName = "Mac";
platPathSuffixes.Add(platformName);
useDebugCRT = true;
Definitions.Add("A_PLAT_OSX");
// On Mac, in library mode, always assume DLL since libs are universal for both dylib and static builds
if (!bFullSource)
{
Definitions.Add("A_IS_DLL");
}
break;
case UnrealTargetPlatform.Linux:
bPlatformAllowed = true;
platformName = "Linux";
platPathSuffixes.Add(platformName);
useDebugCRT = true;
Definitions.Add("A_PLAT_LINUX64");
//UEBuildConfiguration.bForceEnableExceptions = true;
break;
case UnrealTargetPlatform.IOS:
bPlatformAllowed = true;
platformName = "IOS";
platPathSuffixes.Add(platformName);
useDebugCRT = true;
Definitions.Add("A_PLAT_iOS");
break;
case UnrealTargetPlatform.TVOS:
bPlatformAllowed = true;
platformName = "TVOS";
platPathSuffixes.Add(platformName);
useDebugCRT = true;
Definitions.Add("A_PLAT_tvOS");
break;
case UnrealTargetPlatform.Android:
bPlatformAllowed = true;
platformName = "Android";
platPathSuffixes.Add(Path.Combine(platformName, "ARM"));
platPathSuffixes.Add(Path.Combine(platformName, "ARM64"));
platPathSuffixes.Add(Path.Combine(platformName, "x86"));
platPathSuffixes.Add(Path.Combine(platformName, "x64"));
useDebugCRT = true;
Definitions.Add("A_PLAT_ANDROID");
break;
case UnrealTargetPlatform.XboxOne:
bPlatformAllowed = bFullSource;
platformName = "XONE";
Definitions.Add("A_PLAT_X_ONE");
break;
case UnrealTargetPlatform.PS4:
bPlatformAllowed = bFullSource;
platformName = "PS4";
Definitions.Add("A_PLAT_PS4");
break;
}
// NOTE: All modules inside the SkookumScript plugin folder must use the exact same definitions!
switch (Target.Configuration)
{
case UnrealTargetConfiguration.Debug:
case UnrealTargetConfiguration.DebugGame:
libNameSuffix = useDebugCRT ? "-Debug" : "-DebugCRTOpt";
Definitions.Add("A_EXTRA_CHECK=1");
Definitions.Add("A_UNOPTIMIZED=1");
break;
case UnrealTargetConfiguration.Development:
case UnrealTargetConfiguration.Test:
libNameSuffix = "-Development";
Definitions.Add("A_EXTRA_CHECK=1");
break;
case UnrealTargetConfiguration.Shipping:
libNameSuffix = "-Shipping";
Definitions.Add("A_SYMBOL_STR_DB=1");
Definitions.Add("A_NO_SYMBOL_REF_LINK=1");
break;
}
// Determine if monolithic build
var bIsMonolithic = (Target.LinkType == TargetLinkType.Monolithic);
if (!bIsMonolithic)
{
Definitions.Add("A_IS_DLL");
}
// Public include paths
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public"));
if (bFullSource)
{
// We're building SkookumScript from source - not much else needed
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private"));
}
else if (bPlatformAllowed)
{
var moduleName = "AgogCore";
// Link with monolithic library on all platforms except UE4Editor Win64 which requires a specific DLL import library
var libFileNameStem = libNamePrefix + moduleName + ((!bIsMonolithic && Target.Platform == UnrealTargetPlatform.Win64) ? "-" + platformName : "") + libNameSuffix;
var libFileName = libFileNameStem + libNameExt;
var libDirPathBase = Path.Combine(ModuleDirectory, "Lib");
// Add library paths to linker parameters
foreach (var platPathSuffix in platPathSuffixes)
{
var libDirPath = Path.Combine(libDirPathBase, platPathSuffix);
var libFilePath = Path.Combine(libDirPath, libFileName);
PublicLibraryPaths.Add(libDirPath);
// For non-Android, add full path
if (Target.Platform != UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(libFilePath);
}
}
// For Android, just add core of library name, e.g. "SkookumScript-Development"
if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(moduleName + libNameSuffix);
}
}
}
public IOSApsalar(TargetInfo Target)
{
BinariesSubFolder = "NotForLicensees";
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
// ... add private dependencies that you statically link with here ...
}
);
PublicIncludePathModuleNames.Add("Analytics");
PublicFrameworks.AddRange(
new string[] {
"CoreTelephony",
"SystemConfiguration",
"UIKit",
"Foundation",
"CoreGraphics",
"MobileCoreServices",
"StoreKit",
"CFNetwork",
"CoreData",
"Security",
"CoreLocation"
});
PublicAdditionalLibraries.AddRange(
new string[] {
"sqlite3",
"z"
});
bool bHasApsalarSDK =
(System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "Apsalar")) &&
System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "Apsalar", "IOS"))) ||
(System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "NotForLicensees")) &&
System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "NotForLicensees", "Apsalar")) &&
System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "NotForLicensees", "Apsalar", "IOS")));
if (bHasApsalarSDK)
{
PublicIncludePaths.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "NotForLicensees/Apsalar/IOS/");
PublicAdditionalLibraries.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "NotForLicensees/Apsalar/IOS/libApsalar.a");
Definitions.Add("WITH_APSALAR=1");
}
else
{
Definitions.Add("WITH_APSALAR=0");
}
}