weyne/DCSOlympus
1
0
Fork 0
mirror of https://github.com/Pax1601/DCSOlympus.git synced 2025-10-29 16:56:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Started units spawn functions and major refactoring

Browse Source
This commit is contained in:
Pax1601
2022-12-07 19:46:54 +01:00
parent a10762ac0c
commit 3a46a6df21
41 changed files with 1104 additions and 1121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/Olympus.sln
View File

@@ -3,12 +3,18 @@ Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.3.32929.385
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Olympus", "Olympus\Olympus.vcxproj", "{5F3FC91E-1FBC-4223-8011-9708DE913474}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "core", "core\core.vcxproj", "{8A48D855-0E01-42BA-BD8C-07B0877C68DF}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "logger", "logger\logger.vcxproj", "{873ECABE-FCFE-4217-AC15-91959C3CF1C6}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dcstools", "dcstools\dcstools.vcxproj", "{2B255368-39A0-431A-A6DE-CC739AC70DC1}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "luatools", "luatools\luatools.vcxproj", "{DE139EC1-4F88-47D5-BE73-F41915FE14A3}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "utils", "utils\utils.vcxproj", "{B85009CE-4A5C-4A5A-B85D-001B3A2651B2}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "olympus", "olympus\olympus.vcxproj", "{5F3FC91E-1FBC-4223-8011-9708DE913474}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
@@ -17,14 +23,6 @@ Global
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Debug|x64.ActiveCfg = Debug|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Debug|x64.Build.0 = Debug|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Debug|x86.ActiveCfg = Debug|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Debug|x86.Build.0 = Debug|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Release|x64.ActiveCfg = Release|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Release|x64.Build.0 = Release|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Release|x86.ActiveCfg = Release|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Release|x86.Build.0 = Release|x64
{8A48D855-0E01-42BA-BD8C-07B0877C68DF}.Debug|x64.ActiveCfg = Debug|x64
{8A48D855-0E01-42BA-BD8C-07B0877C68DF}.Debug|x64.Build.0 = Debug|x64
{8A48D855-0E01-42BA-BD8C-07B0877C68DF}.Debug|x86.ActiveCfg = Debug|Win32
@@ -33,6 +31,30 @@ Global
{8A48D855-0E01-42BA-BD8C-07B0877C68DF}.Release|x64.Build.0 = Release|x64
{8A48D855-0E01-42BA-BD8C-07B0877C68DF}.Release|x86.ActiveCfg = Release|Win32
{8A48D855-0E01-42BA-BD8C-07B0877C68DF}.Release|x86.Build.0 = Release|Win32
{873ECABE-FCFE-4217-AC15-91959C3CF1C6}.Debug|x64.ActiveCfg = Debug|x64
{873ECABE-FCFE-4217-AC15-91959C3CF1C6}.Debug|x64.Build.0 = Debug|x64
{873ECABE-FCFE-4217-AC15-91959C3CF1C6}.Debug|x86.ActiveCfg = Debug|Win32
{873ECABE-FCFE-4217-AC15-91959C3CF1C6}.Debug|x86.Build.0 = Debug|Win32
{873ECABE-FCFE-4217-AC15-91959C3CF1C6}.Release|x64.ActiveCfg = Release|x64
{873ECABE-FCFE-4217-AC15-91959C3CF1C6}.Release|x64.Build.0 = Release|x64
{873ECABE-FCFE-4217-AC15-91959C3CF1C6}.Release|x86.ActiveCfg = Release|Win32
{873ECABE-FCFE-4217-AC15-91959C3CF1C6}.Release|x86.Build.0 = Release|Win32
{2B255368-39A0-431A-A6DE-CC739AC70DC1}.Debug|x64.ActiveCfg = Debug|x64
{2B255368-39A0-431A-A6DE-CC739AC70DC1}.Debug|x64.Build.0 = Debug|x64
{2B255368-39A0-431A-A6DE-CC739AC70DC1}.Debug|x86.ActiveCfg = Debug|Win32
{2B255368-39A0-431A-A6DE-CC739AC70DC1}.Debug|x86.Build.0 = Debug|Win32
{2B255368-39A0-431A-A6DE-CC739AC70DC1}.Release|x64.ActiveCfg = Release|x64
{2B255368-39A0-431A-A6DE-CC739AC70DC1}.Release|x64.Build.0 = Release|x64
{2B255368-39A0-431A-A6DE-CC739AC70DC1}.Release|x86.ActiveCfg = Release|Win32
{2B255368-39A0-431A-A6DE-CC739AC70DC1}.Release|x86.Build.0 = Release|Win32
{DE139EC1-4F88-47D5-BE73-F41915FE14A3}.Debug|x64.ActiveCfg = Debug|x64
{DE139EC1-4F88-47D5-BE73-F41915FE14A3}.Debug|x64.Build.0 = Debug|x64
{DE139EC1-4F88-47D5-BE73-F41915FE14A3}.Debug|x86.ActiveCfg = Debug|Win32
{DE139EC1-4F88-47D5-BE73-F41915FE14A3}.Debug|x86.Build.0 = Debug|Win32
{DE139EC1-4F88-47D5-BE73-F41915FE14A3}.Release|x64.ActiveCfg = Release|x64
{DE139EC1-4F88-47D5-BE73-F41915FE14A3}.Release|x64.Build.0 = Release|x64
{DE139EC1-4F88-47D5-BE73-F41915FE14A3}.Release|x86.ActiveCfg = Release|Win32
{DE139EC1-4F88-47D5-BE73-F41915FE14A3}.Release|x86.Build.0 = Release|Win32
{B85009CE-4A5C-4A5A-B85D-001B3A2651B2}.Debug|x64.ActiveCfg = Debug|x64
{B85009CE-4A5C-4A5A-B85D-001B3A2651B2}.Debug|x64.Build.0 = Debug|x64
{B85009CE-4A5C-4A5A-B85D-001B3A2651B2}.Debug|x86.ActiveCfg = Debug|Win32
@@ -41,6 +63,14 @@ Global
{B85009CE-4A5C-4A5A-B85D-001B3A2651B2}.Release|x64.Build.0 = Release|x64
{B85009CE-4A5C-4A5A-B85D-001B3A2651B2}.Release|x86.ActiveCfg = Release|Win32
{B85009CE-4A5C-4A5A-B85D-001B3A2651B2}.Release|x86.Build.0 = Release|Win32
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Debug|x64.ActiveCfg = Debug|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Debug|x64.Build.0 = Debug|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Debug|x86.ActiveCfg = Debug|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Debug|x86.Build.0 = Debug|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Release|x64.ActiveCfg = Release|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Release|x64.Build.0 = Release|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Release|x86.ActiveCfg = Release|x64
{5F3FC91E-1FBC-4223-8011-9708DE913474}.Release|x86.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

18
src/Olympus/Olympus.vcxproj
View File

@@ -11,12 +11,17 @@
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\main.cpp" />
<ClCompile Include="src\olympus.cpp" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\dcstools\dcstools.vcxproj">
<Project>{2b255368-39a0-431a-a6de-cc739ac70dc1}</Project>
</ProjectReference>
<ProjectReference Include="..\logger\logger.vcxproj">
<Project>{873ecabe-fcfe-4217-ac15-91959c3cf1c6}</Project>
</ProjectReference>
<ProjectReference Include="..\utils\utils.vcxproj">
<Project>{b85009ce-4a5c-4a5a-b85d-001b3a2651b2}</Project>
<UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
</ProjectReference>
</ItemGroup>
<PropertyGroup Label="Globals">
@@ -25,7 +30,7 @@
<ProjectGuid>{5f3fc91e-1fbc-4223-8011-9708de913474}</ProjectGuid>
<RootNamespace>Olympus</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
<ProjectName>Olympus</ProjectName>
<ProjectName>olympus</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
@@ -93,9 +98,10 @@
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS; NDEBUG;OLYMPUS_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
<AdditionalIncludeDirectories>include; ..\..\third-party\lua\include; ..\utils\include; ..\shared\include</AdditionalIncludeDirectories>
<LanguageStandard>stdcpp17</LanguageStandard>
<PrecompiledHeaderFile>
</PrecompiledHeaderFile>
<AdditionalIncludeDirectories>include;..\..\third-party\lua\include;..\utils\include;..\shared\include;..\dcstools\include;..\logger\include;..\luatools\include</AdditionalIncludeDirectories>
<LanguageStandard>stdcpp20</LanguageStandard>
<AssemblerOutput>NoListing</AssemblerOutput>
</ClCompile>
<Link>

2
src/Olympus/Olympus.vcxproj.filters
View File

@@ -9,7 +9,7 @@
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\main.cpp">
<ClCompile Include="src\olympus.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>

172
src/Olympus/src/main.cpp
View File

@@ -1,172 +0,0 @@
#include "framework.h"
#include "DCSUtils.h"
#include "Logger.h"
#include "Utils.h"
#define DllExport __declspec( dllexport )
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
/* Run-time linking to core dll allows for "hot swap"*/
HINSTANCE hGetProcIDDLL = NULL;
typedef int(__stdcall* f_coreInit)(lua_State* L);
typedef int(__stdcall* f_coreDeinit)(lua_State* L);
typedef int(__stdcall* f_coreFrame)(lua_State* L);
typedef int(__stdcall* f_coreMissionData)(lua_State* L);
f_coreInit coreInit = nullptr;
f_coreDeinit coreDeinit = nullptr;
f_coreFrame coreFrame = nullptr;
f_coreMissionData coreMissionData = nullptr;
static int onSimulationStart(lua_State* L)
{
LOGGER->Log("onSimulationStart callback called successfully");
string modLocation;
string dllLocation;
char* buf = nullptr;
size_t sz = 0;
if (_dupenv_s(&buf, &sz, "OLYMPUS") == 0 && buf != nullptr)
{
modLocation = buf;
free(buf);
}
else
{
LOGGER->Log("OLYMPUS environment variable is missing");
goto error;
}
dllLocation = modLocation + "\\bin\\core.dll";
LOGGER->Log("Loading core.dll");
hGetProcIDDLL = LoadLibrary(Utils::to_wstring(dllLocation).c_str());
if (!hGetProcIDDLL) {
DCSUtils::LogError(L, "Error loading core DLL");
goto error;
}
LOGGER->Log("Core DLL loaded successfully");
coreInit = (f_coreInit)GetProcAddress(hGetProcIDDLL, "coreInit");
if (!coreInit)
{
DCSUtils::LogError(L, "Error getting coreInit ProcAddress from DLL");
goto error;
}
coreDeinit = (f_coreDeinit)GetProcAddress(hGetProcIDDLL, "coreDeinit");
if (!coreInit)
{
DCSUtils::LogError(L, "Error getting coreDeinit ProcAddress from DLL");
goto error;
}
coreFrame = (f_coreFrame)GetProcAddress(hGetProcIDDLL, "coreFrame");
if (!coreFrame)
{
DCSUtils::LogError(L, "Error getting coreFrame ProcAddress from DLL");
goto error;
}
coreMissionData = (f_coreFrame)GetProcAddress(hGetProcIDDLL, "coreMissionData");
if (!coreFrame)
{
DCSUtils::LogError(L, "Error getting coreMissionData ProcAddress from DLL");
goto error;
}
coreInit(L);
DCSUtils::LogInfo(L, "Module loaded and started successfully.");
return 0;
error:
DCSUtils::LogError(L, "Error while loading module, see Olympus.log in temporary folder for additional details.");
return 0;
}
static int onSimulationFrame(lua_State* L)
{
if (coreFrame)
{
coreFrame(L);
}
return 0;
}
static int onSimulationStop(lua_State* L)
{
LOGGER->Log("onSimulationStop callback called successfully");
if (hGetProcIDDLL)
{
LOGGER->Log("Trying to unload core DLL");
if (coreDeinit)
{
coreDeinit(L);
}
if (FreeLibrary(hGetProcIDDLL))
{
LOGGER->Log("Core DLL unloaded successfully");
}
else
{
DCSUtils::LogError(L, "Error unloading DLL");
goto error;
}
coreInit = nullptr;
coreDeinit = nullptr;
coreFrame = nullptr;
coreMissionData = nullptr;
}
hGetProcIDDLL = NULL;
return 0;
error:
DCSUtils::LogError(L, "Error while unloading module, see Olympus.log in temporary folder for additional details.");
return 0;
}
static int setMissionData(lua_State* L)
{
if (coreMissionData)
{
coreMissionData(L);
}
return 0;
}
static const luaL_Reg Map[] = {
{"onSimulationStart", onSimulationStart},
{"onSimulationFrame", onSimulationFrame},
{"onSimulationStop", onSimulationStop},
{"setMissionData", setMissionData },
{NULL, NULL}
};
extern "C" DllExport int luaopen_Olympus(lua_State * L)
{
luaL_register(L, "Olympus", Map);
return 1;
}

44
src/core/core.vcxproj
View File

@@ -19,27 +19,34 @@
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\Commands.h" />
<ClInclude Include="include\LUAFunctions.h" />
<ClInclude Include="include\RESTServer.h" />
<ClInclude Include="include\Scheduler.h" />
<ClInclude Include="include\Unit.h" />
<ClInclude Include="include\UnitsHandler.h" />
<ClInclude Include="include\commands.h" />
<ClInclude Include="include\scriptLoader.h" />
<ClInclude Include="include\server.h" />
<ClInclude Include="include\scheduler.h" />
<ClInclude Include="include\unit.h" />
<ClInclude Include="include\unitsFactory.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\Commands.cpp" />
<ClCompile Include="src\LUAFunctions.cpp" />
<ClCompile Include="src\main.cpp" />
<ClCompile Include="src\RESTServer.cpp" />
<ClCompile Include="src\Scheduler.cpp" />
<ClCompile Include="src\Unit.cpp" />
<ClCompile Include="src\UnitsHandler.cpp" />
<ClCompile Include="src\commands.cpp" />
<ClCompile Include="src\scriptLoader.cpp" />
<ClCompile Include="src\core.cpp" />
<ClCompile Include="src\server.cpp" />
<ClCompile Include="src\scheduler.cpp" />
<ClCompile Include="src\unit.cpp" />
<ClCompile Include="src\unitsFactory.cpp" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\dcstools\dcstools.vcxproj">
<Project>{2b255368-39a0-431a-a6de-cc739ac70dc1}</Project>
</ProjectReference>
<ProjectReference Include="..\logger\logger.vcxproj">
<Project>{873ecabe-fcfe-4217-ac15-91959c3cf1c6}</Project>
</ProjectReference>
<ProjectReference Include="..\luatools\luatools.vcxproj">
<Project>{de139ec1-4f88-47d5-be73-f41915fe14a3}</Project>
</ProjectReference>
<ProjectReference Include="..\utils\utils.vcxproj">
<Project>{b85009ce-4a5c-4a5a-b85d-001b3a2651b2}</Project>
<LinkLibraryDependencies>true</LinkLibraryDependencies>
<UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
</ProjectReference>
</ItemGroup>
<PropertyGroup Label="Globals">
@@ -162,9 +169,10 @@
<PreprocessorDefinitions>NDEBUG;CORE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
<AdditionalIncludeDirectories>include; ..\..\third-party\lua\include; ..\utils\include; ..\shared\include</AdditionalIncludeDirectories>
<LanguageStandard>stdcpp17</LanguageStandard>
<PrecompiledHeaderFile>
</PrecompiledHeaderFile>
<AdditionalIncludeDirectories>include;..\..\third-party\lua\include;..\utils\include;..\shared\include;..\dcstools\include;..\logger\include;..\luatools\include</AdditionalIncludeDirectories>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>

26
src/core/core.vcxproj.filters
View File

@@ -9,45 +9,45 @@
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\Commands.h">
<ClInclude Include="include\commands.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\RESTServer.h">
<ClInclude Include="include\server.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\Scheduler.h">
<ClInclude Include="include\scheduler.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\Unit.h">
<ClInclude Include="include\unit.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\UnitsHandler.h">
<ClInclude Include="include\unitsFactory.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\LUAFunctions.h">
<ClInclude Include="include\scriptLoader.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\Commands.cpp">
<ClCompile Include="src\commands.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\main.cpp">
<ClCompile Include="src\core.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\RESTServer.cpp">
<ClCompile Include="src\server.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\Scheduler.cpp">
<ClCompile Include="src\scheduler.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\Unit.cpp">
<ClCompile Include="src\unit.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\UnitsHandler.cpp">
<ClCompile Include="src\unitsFactory.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\LUAFunctions.cpp">
<ClCompile Include="src\scriptLoader.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>

76
src/core/include/Commands.h
View File

@@ -1,13 +1,14 @@
#pragma once
#include "LUAUtils.h"
#include "Utils.h"
#include "framework.h"
#include "luatools.h"
#include "utils.h"
namespace CommandPriority {
enum CommandPriorities { LOW, MEDIUM, HIGH };
};
namespace CommandType {
enum CommandTypes { NO_TYPE, MOVE };
enum CommandTypes { NO_TYPE, MOVE, SMOKE, LASE, EXPLODE, SPAWN_AIR, SPAWN_GROUND };
};
/* Base command class */
@@ -27,11 +28,78 @@ protected:
class MoveCommand : public Command
{
public:
MoveCommand(int ID, wstring unitName, Coords destination) : ID(ID), unitName(unitName), destination(destination) { priority = CommandPriority::LOW; type = CommandType::MOVE; };
MoveCommand(int ID, wstring unitName, Coords destination, int unitCategory) :
ID(ID),
unitName(unitName),
destination(destination),
unitCategory(unitCategory)
{
priority = CommandPriority::LOW;
type = CommandType::MOVE;
};
virtual void execute(lua_State* L);
private:
const int ID;
const wstring unitName;
const Coords destination;
const int unitCategory;
};
/* Smoke command */
class SmokeCommand : public Command
{
public:
SmokeCommand(wstring color, Coords location) :
color(color),
location(location)
{
priority = CommandPriority::LOW;
type = CommandType::SMOKE;
};
virtual void execute(lua_State* L);
private:
const wstring color;
const Coords location;
};
/* Spawn ground unit command */
class SpawnGroundCommand : public Command
{
public:
SpawnGroundCommand(wstring coalition, wstring unitType, Coords location) :
coalition(coalition),
unitType(unitType),
location(location)
{
priority = CommandPriority::LOW;
type = CommandType::SPAWN_GROUND;
};
virtual void execute(lua_State* L);
private:
const wstring coalition;
const wstring unitType;
const Coords location;
};
/* Spawn air unit command */
class SpawnAirCommand : public Command
{
public:
SpawnAirCommand(wstring coalition, wstring unitType, Coords location) :
coalition(coalition),
unitType(unitType),
location(location)
{
priority = CommandPriority::LOW;
type = CommandType::SPAWN_AIR;
};
virtual void execute(lua_State* L);
private:
const wstring coalition;
const wstring unitType;
const Coords location;
};

7
src/core/include/LUAFunctions.h
View File

@@ -1,7 +0,0 @@
#pragma once
#include "framework.h"
namespace LUAFunctions
{
void registerLuaFunctions(lua_State* L);
}

29
src/core/include/RESTServer.h
View File

@@ -1,29 +0,0 @@
#pragma once
#include "framework.h"
#include "LUAUtils.h"
using namespace web::http;
using namespace web::http::experimental::listener;
class UnitsFactory;
class Scheduler;
class RESTServer
{
public:
RESTServer(lua_State* L);
~RESTServer();
private:
std::thread* serverThread;
void handle_options(http_request request);
void handle_get(http_request request);
void handle_request(http_request request, function<void(json::value const&, json::value&)> action);
void handle_put(http_request request);
void task();
atomic<bool> runListener;
};

4
src/core/include/Scheduler.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include "LUAUtils.h"
#include "framework.h"
#include "Commands.h"
#include "luatools.h"
#include "commands.h"
class Scheduler
{

21
src/core/include/Unit.h
View File

@@ -1,8 +1,12 @@
#pragma once
#include "Utils.h"
#include "DCSUtils.h"
#include "LUAUtils.h"
#include "framework.h"
#include "utils.h"
#include "dcstools.h"
#include "luatools.h"
namespace UnitCategory {
enum UnitCategories { NO_CATEGORY, AIR, GROUND, NAVY }; // Do not edit, this codes are tied to values in DCS
};
class Unit
{
@@ -13,28 +17,31 @@ public:
void update(json::value json);
void setPath(list<Coords> path);
void setAlive(bool newAlive) { alive = newAlive; }
int getID() { return ID; }
wstring getName() { return name; }
wstring getUnitName() { return unitName; }
wstring getGroupName() { return groupName; }
int getType() { return type; }
wstring getCountry() { return country; }
json::value getType() { return type; } // This functions returns the complete type of the object (Level1, Level2, Level3, Level4)
int getCountry() { return country; }
int getCoalitionID() { return coalitionID; }
double getLatitude() { return latitude; }
double getLongitude() { return longitude; }
double getAltitude() { return altitude; }
double getHeading() { return heading; }
int getCategory();
json::value json();
protected:
int ID;
bool alive = true;
wstring name = L"undefined";
wstring unitName = L"undefined";
wstring groupName = L"undefined";
int type = 0;
wstring country = L"undefined";
json::value type = json::value::null();
int country = 0;
int coalitionID = 0;
double latitude = 0;
double longitude = 0;

23
src/core/include/UnitsHandler.h
View File

@@ -1,23 +0,0 @@
#pragma once
#include "framework.h"
#include "DCSUtils.h"
class Unit;
class UnitsFactory
{
public:
UnitsFactory(lua_State* L);
~UnitsFactory();
Unit* getUnit(int ID);
void getMissionDB(lua_State* L);
void update(lua_State* L);
void updateAnswer(json::value& answer);
private:
map<int, Unit*> units;
json::value missionDB;
};

77
src/core/src/Commands.cpp
View File

@@ -1,12 +1,12 @@
#include "Commands.h"
#include "framework.h"
#include "Logger.h"
#include "commands.h"
#include "logger.h"
/* Move command */
void MoveCommand::execute(lua_State* L)
{
std::ostringstream command;
command << "Olympus.move(\"" << Utils::to_string(unitName) << "\"," << destination.lat << "," << destination.lng << "," << 10 << ")";
command.precision(10);
command << "Olympus.move(\"" << to_string(unitName) << "\", " << destination.lat << ", " << destination.lng << ", " << 10 << ", " << unitCategory << ")";
lua_getglobal(L, "net");
lua_getfield(L, -1, "dostring_in");
@@ -14,10 +14,73 @@ void MoveCommand::execute(lua_State* L)
lua_pushstring(L, command.str().c_str());
if (lua_pcall(L, 2, 0, 0) != 0)
{
LOGGER->Log("Error executing MoveCommand");
log("Error executing MoveCommand");
}
else
{
LOGGER->Log("MoveCommand executed successfully");
log("MoveCommand executed successfully");
}
}
/* Smoke command */
void SmokeCommand::execute(lua_State* L)
{
std::ostringstream command;
command.precision(10);
command << "Olympus.smoke(\"" << to_string(color) << "\", " << location.lat << ", " << location.lng << ")";
lua_getglobal(L, "net");
lua_getfield(L, -1, "dostring_in");
lua_pushstring(L, "server");
lua_pushstring(L, command.str().c_str());
if (lua_pcall(L, 2, 0, 0) != 0)
{
log("Error executing SmokeCommand");
}
else
{
log("SmokeCommand executed successfully");
}
}
/* Spawn ground command */
void SpawnGroundCommand::execute(lua_State* L)
{
std::ostringstream command;
command.precision(10);
command << "Olympus.spawnGround(\"" << to_string(coalition) << "\", \"" << to_string(unitType) << "\", " << location.lat << ", " << location.lng << ")";
lua_getglobal(L, "net");
lua_getfield(L, -1, "dostring_in");
lua_pushstring(L, "server");
lua_pushstring(L, command.str().c_str());
if (lua_pcall(L, 2, 0, 0) != 0)
{
log("Error executing SpawnGroundCommand");
}
else
{
log("SpawnGroundCommand executed successfully");
}
}
/* Spawn air command */
void SpawnAirCommand::execute(lua_State* L)
{
std::ostringstream command;
command.precision(10);
command << "Olympus.spawnAir(\"" << to_string(coalition) << "\", \"" << to_string(unitType) << "\", " << location.lat << ", " << location.lng << ")";
lua_getglobal(L, "net");
lua_getfield(L, -1, "dostring_in");
lua_pushstring(L, "server");
lua_pushstring(L, command.str().c_str());
if (lua_pcall(L, 2, 0, 0) != 0)
{
log("Error executing SpawnGroundCommand");
}
else
{
log("SpawnAirCommand executed successfully");
}
}

84
src/core/src/LUAFunctions.cpp
View File

@@ -1,84 +0,0 @@
#include "LUAFunctions.h"
#include "Logger.h"
/* Executes the "OlympusCommand.lua" file to load in the "Server" Lua space all the Lua functions necessary to perform DCS commands (like moving units) */
void LUAFunctions::registerLuaFunctions(lua_State* L)
{
string modLocation;
char* buf = nullptr;
size_t sz = 0;
if (_dupenv_s(&buf, &sz, "OLYMPUS") == 0 && buf != nullptr)
{
modLocation = buf;
free(buf);
}
else
{
LOGGER->Log("OLYMPUS environment variable is missing");
return;
}
{
ifstream f(modLocation + "\\Scripts\\mist_4_4_90.lua");
string str;
LOGGER->Log("Reading MIST from " + modLocation + "\\Scripts\\mist_4_4_90.lua");
if (f) {
ostringstream ss;
ss << f.rdbuf();
str = ss.str();
LOGGER->Log("MIST read succesfully");
}
else
{
LOGGER->Log("Error reading MIST");
return;
}
lua_getglobal(L, "net");
lua_getfield(L, -1, "dostring_in");
lua_pushstring(L, "server");
lua_pushstring(L, str.c_str());
if (lua_pcall(L, 2, 0, 0) != 0)
{
LOGGER->Log("Error registering MIST");
}
else
{
LOGGER->Log("MIST registered successfully");
}
}
{
ifstream f(modLocation + "\\Scripts\\OlympusCommand.lua");
string str;
LOGGER->Log("Reading OlympusCommand.lua from " + modLocation + "\\Scripts\\OlympusCommand.lua");
if (f) {
ostringstream ss;
ss << f.rdbuf();
str = ss.str();
LOGGER->Log("OlympusCommand.lua read succesfully");
}
else
{
LOGGER->Log("Error reading OlympusCommand.lua");
return;
}
lua_getglobal(L, "net");
lua_getfield(L, -1, "dostring_in");
lua_pushstring(L, "server");
lua_pushstring(L, str.c_str());
if (lua_pcall(L, 2, 0, 0) != 0)
{
LOGGER->Log("Error registering OlympusCommand.lua");
}
else
{
LOGGER->Log("OlympusCommand.lua registered successfully");
}
}
}

130
src/core/src/RESTServer.cpp
View File

@@ -1,130 +0,0 @@
#include "RESTServer.h"
#include "Logger.h"
#include "defines.h"
#include "UnitsHandler.h"
#include "Scheduler.h"
#include "LUAUtils.h"
extern UnitsFactory* unitsHandler;
extern Scheduler* scheduler;
extern json::value missionData;
RESTServer::RESTServer(lua_State* L):
runListener(true)
{
DCSUtils::LogInfo(L, "Starting RESTServer");
serverThread = new thread(&RESTServer::task, this);
}
RESTServer::~RESTServer()
{
runListener = false;
}
void RESTServer::handle_options(http_request request)
{
http_response response(status_codes::OK);
response.headers().add(U("Allow"), U("GET, POST, PUT, OPTIONS"));
response.headers().add(U("Access-Control-Allow-Origin"), U("*"));
response.headers().add(U("Access-Control-Allow-Methods"), U("GET, POST, PUT, OPTIONS"));
response.headers().add(U("Access-Control-Allow-Headers"), U("Content-Type"));
request.reply(response);
}
void RESTServer::handle_get(http_request request)
{
http_response response(status_codes::OK);
response.headers().add(U("Allow"), U("GET, POST, PUT, OPTIONS"));
response.headers().add(U("Access-Control-Allow-Origin"), U("*"));
response.headers().add(U("Access-Control-Allow-Methods"), U("GET, POST, PUT, OPTIONS"));
response.headers().add(U("Access-Control-Allow-Headers"), U("Content-Type"));
auto answer = json::value::object();
try
{
unitsHandler->updateAnswer(answer);
answer[L"missionData"] = missionData;
}
catch (http_exception const& e)
{
LOGGER->Log(e.what());
}
response.set_body(answer);
request.reply(response);
}
void RESTServer::handle_request(http_request request, function<void(json::value const&, json::value&)> action)
{
auto answer = json::value::object();
request.extract_json().then([&answer, &action](pplx::task<json::value> task)
{
try
{
auto const& jvalue = task.get();
if (!jvalue.is_null())
{
action(jvalue, answer);
}
}
catch (http_exception const& e)
{
LOGGER->Log(e.what());
}
}).wait();
http_response response(status_codes::OK);
response.headers().add(U("Allow"), U("GET, POST, PUT, OPTIONS"));
response.headers().add(U("Access-Control-Allow-Origin"), U("*"));
response.headers().add(U("Access-Control-Allow-Methods"), U("GET, POST, PUT, OPTIONS"));
response.headers().add(U("Access-Control-Allow-Headers"), U("Content-Type"));
response.set_body(answer);
request.reply(response);
}
void RESTServer::handle_put(http_request request)
{
handle_request(
request,
[](json::value const& jvalue, json::value& answer)
{
for (auto const& e : jvalue.as_object())
{
auto key = e.first;
auto value = e.second;
scheduler->handleRequest(key, value);
}
});
}
void RESTServer::task()
{
http_listener listener(REST_ADDRESS);
std::function<void(http_request)> handle_options = std::bind(&RESTServer::handle_options, this, std::placeholders::_1);
std::function<void(http_request)> handle_get = std::bind(&RESTServer::handle_get, this, std::placeholders::_1);
std::function<void(http_request)> handle_put = std::bind(&RESTServer::handle_put, this, std::placeholders::_1);
listener.support(methods::OPTIONS, handle_options);
listener.support(methods::GET, handle_get);
listener.support(methods::PUT, handle_put);
try
{
listener.open()
.then([&listener]() {LOGGER->Log("RESTServer starting to listen"); })
.wait();
while (runListener);
listener.close();
LOGGER->Log("RESTServer stopped listening");
}
catch (exception const& e)
{
LOGGER->Log(e.what());
}
}

85
src/core/src/Scheduler.cpp
View File

@@ -1,15 +1,15 @@
#include "Scheduler.h"
#include "Logger.h"
#include "DCSUtils.h"
#include "UnitsHandler.h"
#include "Utils.h"
#include "Unit.h"
#include "scheduler.h"
#include "logger.h"
#include "dcstools.h"
#include "unitsFactory.h"
#include "utils.h"
#include "unit.h"
extern UnitsFactory* unitsHandler;
extern UnitsFactory* unitsFactory;
Scheduler::Scheduler(lua_State* L)
{
DCSUtils::LogInfo(L, "Units Factory constructor called successfully");
LogInfo(L, "Units Factory constructor called successfully");
}
Scheduler::~Scheduler()
@@ -32,7 +32,7 @@ void Scheduler::execute(lua_State* L)
{
if (command->getPriority() == priority)
{
LOGGER->Log("Executing command");
log("Executing command");
switch (command->getType())
{
case CommandType::MOVE:
@@ -42,7 +42,30 @@ void Scheduler::execute(lua_State* L)
commands.remove(command);
break;
}
case CommandType::SMOKE:
{
SmokeCommand* smokeCommand = dynamic_cast<SmokeCommand*>(command);
smokeCommand->execute(L);
commands.remove(command);
break;
}
case CommandType::SPAWN_GROUND:
{
SpawnGroundCommand* spawnCommand = dynamic_cast<SpawnGroundCommand*>(command);
spawnCommand->execute(L);
commands.remove(command);
break;
}
case CommandType::SPAWN_AIR:
{
SpawnAirCommand* spawnCommand = dynamic_cast<SpawnAirCommand*>(command);
spawnCommand->execute(L);
commands.remove(command);
break;
}
default:
log("Unknown command of type " + to_string(command->getType()));
commands.remove(command);
break;
}
goto exit;
@@ -62,12 +85,11 @@ void Scheduler::handleRequest(wstring key, json::value value)
lock.lock();
Command* command = nullptr;
LOGGER->Log(L"Received request with ID: " + key);
log(L"Received request with ID: " + key);
if (key.compare(L"setPath") == 0)
{
int ID = value[L"ID"].as_integer();
wstring unitName = value[L"unitName"].as_string();
LOGGER->Log(unitName);
json::value path = value[L"path"];
list<Coords> newPath;
for (auto const& e : path.as_object())
@@ -75,21 +97,54 @@ void Scheduler::handleRequest(wstring key, json::value value)
wstring WP = e.first;
double lat = path[WP][L"lat"].as_double();
double lng = path[WP][L"lng"].as_double();
LOGGER->Log(unitName + L" set path destination " + WP + L" (" + to_wstring(lat) + L", " + to_wstring(lng) + L")");
log(unitName + L" set path destination " + WP + L" (" + to_wstring(lat) + L", " + to_wstring(lng) + L")");
Coords dest; dest.lat = lat; dest.lng = lng;
newPath.push_back(dest);
Unit* unit = unitsHandler->getUnit(ID);
Unit* unit = unitsFactory->getUnit(ID);
if (unit != nullptr)
{
unit->setPath(newPath);
LOGGER->Log(unitName + L" new path set successfully");
log(unitName + L" new path set successfully");
}
else
{
LOGGER->Log(unitName + L" not found, request will be discarded");
log(unitName + L" not found, request will be discarded");
}
}
}
else if (key.compare(L"smoke") == 0)
{
wstring color = value[L"color"].as_string();
double lat = value[L"location"][L"lat"].as_double();
double lng = value[L"location"][L"lng"].as_double();
log(L"Adding " + color + L" smoke at (" + to_wstring(lat) + L", " + to_wstring(lng) + L")");
Coords loc; loc.lat = lat; loc.lng = lng;
command = dynamic_cast<Command*>(new SmokeCommand(color, loc));
}
else if (key.compare(L"spawnGround") == 0)
{
wstring coalition = value[L"coalition"].as_string();
wstring type = value[L"type"].as_string();
double lat = value[L"location"][L"lat"].as_double();
double lng = value[L"location"][L"lng"].as_double();
log(L"Spawning " + coalition + L" ground unit of type " + type + L" at (" + to_wstring(lat) + L", " + to_wstring(lng) + L")");
Coords loc; loc.lat = lat; loc.lng = lng;
command = dynamic_cast<Command*>(new SpawnGroundCommand(coalition, type, loc));
}
else if (key.compare(L"spawnAir") == 0)
{
wstring coalition = value[L"coalition"].as_string();
wstring type = value[L"type"].as_string();
double lat = value[L"location"][L"lat"].as_double();
double lng = value[L"location"][L"lng"].as_double();
log(L"Spawning " + coalition + L" air unit of type " + type + L" at (" + to_wstring(lat) + L", " + to_wstring(lng) + L")");
Coords loc; loc.lat = lat; loc.lng = lng;
command = dynamic_cast<Command*>(new SpawnAirCommand(coalition, type, loc));
}
else
{
log(L"Unknown command: " + key);
}
if (command != nullptr)
{

45
src/core/src/Unit.cpp
View File

@@ -1,15 +1,15 @@
#include "Unit.h"
#include "Utils.h"
#include "Logger.h"
#include "Commands.h"
#include "Scheduler.h"
#include "unit.h"
#include "utils.h"
#include "logger.h"
#include "commands.h"
#include "scheduler.h"
extern Scheduler* scheduler;
Unit::Unit(json::value json, int ID) :
ID(ID)
{
LOGGER->Log("Creating unit with ID: " + to_string(ID));
log("Creating unit with ID: " + to_string(ID));
update(json);
}
@@ -18,20 +18,36 @@ Unit::~Unit()
}
int Unit::getCategory()
{
if (type.has_number_field(L"level1"))
{
return type[L"level1"].as_number().is_int32();
}
else
{
return UnitCategory::NO_CATEGORY;
}
}
void Unit::update(json::value json)
{
name = json[L"Name"].as_string();
unitName = json[L"UnitName"].as_string();
groupName = json[L"GroupName"].as_string();
//type = json[L"Type"].as_number().to_int32();
//country = json[L"Country"].as_string();
//coalitionID = json[L"CoalitionID"].as_number().to_int32();
type = json[L"Type"];
country = json[L"Country"].as_number().to_int32();
coalitionID = json[L"CoalitionID"].as_number().to_int32();
latitude = json[L"LatLongAlt"][L"Lat"].as_number().to_double();
longitude = json[L"LatLongAlt"][L"Long"].as_number().to_double();
altitude = json[L"LatLongAlt"][L"Alt"].as_number().to_double();
heading = json[L"Heading"].as_number().to_double();
AIloop();
/* If the unit is alive, run the AI Loop that performs the requested commands and instructions (moving, attacking, etc) */
if (alive)
{
AIloop();
}
}
void Unit::setPath(list<Coords> path)
@@ -46,7 +62,7 @@ void Unit::AIloop()
if (activeDestination != activePath.front())
{
activeDestination = activePath.front();
Command* command = dynamic_cast<Command*>(new MoveCommand(ID, unitName, activeDestination));
Command* command = dynamic_cast<Command*>(new MoveCommand(ID, unitName, activeDestination, getCategory()));
scheduler->appendCommand(command);
}
}
@@ -56,12 +72,13 @@ json::value Unit::json()
{
auto json = json::value::object();
json[L"alive"] = alive;
json[L"name"] = json::value::string(name);
json[L"unitName"] = json::value::string(unitName);
json[L"groupName"] = json::value::string(groupName);
//json[L"type"] = type;
//json[L"country"] = json::value::string(country);
json[L"coalitionID"] = type;
json[L"type"] = type;
json[L"country"] = country;
json[L"coalitionID"] = coalitionID;
json[L"latitude"] = latitude;
json[L"longitude"] = longitude;
json[L"altitude"] = altitude;

59
src/core/src/UnitsHandler.cpp
View File

@@ -1,59 +0,0 @@
#include "UnitsHandler.h"
#include "Logger.h"
#include "Unit.h"
#include "framework.h"
#include "Utils.h"
UnitsFactory::UnitsFactory(lua_State* L)
{
DCSUtils::LogInfo(L, "Units Factory constructor called successfully");
}
UnitsFactory::~UnitsFactory()
{
}
Unit* UnitsFactory::getUnit(int ID)
{
if (units.find(ID) == units.end()) {
return nullptr;
}
else {
return units[ID];
}
}
void UnitsFactory::update(lua_State* L)
{
//lua_getglobal(L, "net");
//lua_getfield(L, -1, "dostring_in");
//lua_pushstring(L, "server");
//lua_pushstring(L, "dostring_in(\"export\", \"Olympus.OlympusDLL.test()\")");
//lua_pcall(L, 2, 0, 0);
map<int, json::value> unitJSONs = DCSUtils::getAllUnits(L);
for (auto const& p : unitJSONs)
{
int ID = p.first;
if (units.count(ID) == 0)
{
units[ID] = new Unit(p.second, ID);
}
units[ID]->update(p.second);
}
}
void UnitsFactory::updateAnswer(json::value& answer)
{
// TODO THREAT SAFEY!
auto unitsJson = json::value::object();
for (auto const& p : units)
{
unitsJson[to_wstring(p.first)] = p.second->json();
}
answer[L"units"] = unitsJson;
}

90
src/core/src/main.cpp
View File

@@ -1,90 +0,0 @@
#include "framework.h"
#include "DCSUtils.h"
#include "Logger.h"
#include "defines.h"
#include "UnitsHandler.h"
#include "RESTServer.h"
#include "Scheduler.h"
#include "LUAFunctions.h"
auto before = std::chrono::system_clock::now();
UnitsFactory* unitsHandler = nullptr;
RESTServer* restserver = nullptr;
Scheduler* scheduler = nullptr;
json::value missionData;
/* Standard DllMain entry point */
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
#define DllExport __declspec( dllexport )
/* Called when DCS simulation stops. All singleton instances are deleted. */
extern "C" DllExport int coreDeinit(lua_State* L)
{
LOGGER->Log("Olympus coreDeinit called successfully");
delete unitsHandler;
delete restserver;
delete scheduler;
LOGGER->Log("All singletons objects destroyed successfully");
return(0);
}
/* Called when DCS simulation starts. All singletons are instantiated, and the custom Lua functions are registered in the Lua state. */
extern "C" DllExport int coreInit(lua_State* L)
{
unitsHandler = new UnitsFactory(L);
restserver = new RESTServer(L);
scheduler = new Scheduler(L);
LUAFunctions::registerLuaFunctions(L);
return(0);
}
extern "C" DllExport int coreFrame(lua_State* L)
{
const std::chrono::duration<double> duration = std::chrono::system_clock::now() - before;
// TODO make intervals editable
if (duration.count() > UPDATE_TIME_INTERVAL)
{
if (unitsHandler != nullptr)
{
unitsHandler->update(L);
}
// TODO allow for different intervals
if (scheduler != nullptr)
{
scheduler->execute(L);
}
before = std::chrono::system_clock::now();
}
return(0);
}
extern "C" DllExport int coreMissionData(lua_State * L)
{
lua_getglobal(L, "Olympus");
lua_getfield(L, -1, "missionData");
missionData = LUAUtils::tableToJSON(L, -1);
return(0);
}

13
src/utils/include/DCSUtils.h
View File

@@ -1,13 +0,0 @@
#pragma once
#include "framework.h"
#include "LUAUtils.h"
namespace DCSUtils
{
void LogInfo(lua_State* L, string message);
void LogWarning(lua_State* L, string message);
void LogError(lua_State* L, string message);
void Log(lua_State* L, string message, int level);
map<int, json::value> getAllUnits(lua_State* L);
}

15
src/utils/include/LUAUtils.h
View File

@@ -1,15 +0,0 @@
#pragma once
#include "framework.h"
namespace LUAUtils
{
void stackUpdate(lua_State* L, int& stackDepth, int initialStack = 0);
void stackPop(lua_State* L, int popDepth = 1);
void stackClean(lua_State* L, int stackDepth);
json::value tableToJSON(lua_State* L, int index);
}
#define STACK_UPDATE LUAUtils::stackUpdate(L, stackDepth, initialStack);
#define STACK_INIT int stackDepth = 0; int initialStack = 0; LUAUtils::stackUpdate(L, initialStack);
#define STACK_POP(X) LUAUtils::stackPop(L, X); STACK_UPDATE;
#define STACK_CLEAN STACK_UPDATE; LUAUtils::stackClean(L, stackDepth);

26
src/utils/include/Logger.h
View File

@@ -1,26 +0,0 @@
#pragma once
#include "framework.h"
#define LOGGER Logger::GetLogger()
class Logger
{
public:
void Log(const std::string& sMessage);
void Log(const std::wstring& sMessage);
void Log(const char* format, ...);
Logger& operator<<(const string& sMessage);
static Logger* GetLogger();
private:
Logger();
Logger(const Logger&) {}; // copy constructor is private
Logger& operator=(const Logger&) { return *this; }; // assignment operator is private
static const std::string m_sFileName;
static Logger* m_pThis;
static ofstream m_Logfile;
void Open();
void Close();
};

19
src/utils/include/Utils.h
View File

@@ -7,15 +7,12 @@ struct Coords {
double alt = 0;
};
bool operator== (const Coords& a, const Coords& b);
bool operator!= (const Coords& a, const Coords& b);
bool operator== (const Coords& a, const int& b);
bool operator!= (const Coords& a, const int& b);
// Get current date/time, format is YYYY-MM-DD.HH:mm:ss
const DllExport std::string CurrentDateTime();
std::wstring DllExport to_wstring(const std::string& str);
std::string DllExport to_string(const std::wstring& wstr);
namespace Utils
{
// Get current date/time, format is YYYY-MM-DD.HH:mm:ss
const std::string CurrentDateTime();
std::wstring to_wstring(const std::string& str);
std::string to_string(const std::wstring& wstr);
}
bool DllExport operator== (const Coords& a, const Coords& b);
bool DllExport operator!= (const Coords& a, const Coords& b);
bool DllExport operator== (const Coords& a, const int& b);
bool DllExport operator!= (const Coords& a, const int& b);

96
src/utils/src/DCSUtils.cpp
View File

@@ -1,96 +0,0 @@
#include "DCSUtils.h"
#include "Logger.h"
void DCSUtils::LogInfo(lua_State* L, string message)
{
STACK_INIT;
lua_getglobal(L, "log");
lua_getfield(L, -1, "INFO");
int infoLevel = (int) lua_tointeger(L, -1);
STACK_POP(1);
STACK_CLEAN;
DCSUtils::Log(L, message, infoLevel);
}
void DCSUtils::LogWarning(lua_State* L, string message)
{
STACK_INIT;
lua_getglobal(L, "log");
lua_getfield(L, -1, "WARNING");
int warningLevel = (int)lua_tointeger(L, -1);
STACK_POP(1);
STACK_CLEAN;
DCSUtils::Log(L, message, warningLevel);
}
void DCSUtils::LogError(lua_State* L, string message)
{
STACK_INIT;
lua_getglobal(L, "log");
lua_getfield(L, -1, "ERROR");
int errorLevel = (int)lua_tointeger(L, -1);
STACK_POP(1);
STACK_CLEAN;
DCSUtils::Log(L, message, errorLevel);
}
void DCSUtils::Log(lua_State* L, string message, int level)
{
STACK_INIT;
lua_getglobal(L, "log");
lua_getfield(L, -1, "write");
lua_pushstring(L, "Olympus.dll");
lua_pushnumber(L, level);
lua_pushstring(L, message.c_str());
lua_pcall(L, 3, 0, 0);
STACK_CLEAN;
}
map<int, json::value> DCSUtils::getAllUnits(lua_State* L)
{
int res = 0;
map<int, json::value> units;
STACK_INIT;
lua_getglobal(L, "Export");
lua_getfield(L, -1, "LoGetWorldObjects");
res = lua_pcall(L, 0, 1, 0);
if (res != 0)
{
DCSUtils::LogError(L, "Error retrieving World Objects");
goto exit;
}
if (!lua_istable(L, 2))
{
DCSUtils::LogError(L, "Error retrieving World Objects");
goto exit;
}
else
{
lua_pushnil(L);
while (lua_next(L, 2) != 0)
{
int ID = lua_tonumber(L, -2);
units[ID] = LUAUtils::tableToJSON(L, -1);
STACK_POP(1)
}
}
exit:
STACK_CLEAN;
return units;
}

57
src/utils/src/LUAUtils.cpp
View File

@@ -1,57 +0,0 @@
#include "LUAUtils.h"
#include "Logger.h"
#include "Utils.h"
void LUAUtils::stackUpdate(lua_State* L, int& stackDepth, int initialStack)
{
stackDepth = lua_gettop(L) - initialStack;
}
void LUAUtils::stackPop(lua_State* L, int popDepth)
{
lua_pop(L, popDepth);
}
void LUAUtils::stackClean(lua_State* L, int stackDepth)
{
lua_pop(L, stackDepth);
}
json::value LUAUtils::tableToJSON(lua_State* L, int index)
{
auto json = json::value::object();
if (lua_istable(L, index))
{
STACK_INIT;
lua_pushvalue(L, index);
lua_pushnil(L);
while (lua_next(L, -2))
{
lua_pushvalue(L, -2);
const char* key = lua_tostring(L, -1);
if (lua_istable(L, -2))
{
json[Utils::to_wstring(key)] = tableToJSON(L, -2);
}
else if (lua_isnumber(L, -2))
{
json[Utils::to_wstring(key)] = json::value::number(lua_tonumber(L, -2));
}
else if (lua_isboolean(L, -2))
{
json[Utils::to_wstring(key)] = json::value::boolean(lua_toboolean(L, -2));
}
else if (lua_isstring(L, -2)) // Keep last, only checks if it can be stringified
{
json[Utils::to_wstring(key)] = json::value::string(Utils::to_wstring(lua_tostring(L, -2)));
}
lua_pop(L, 2);
}
lua_pop(L, 1);
STACK_CLEAN;
}
return json;
}

79
src/utils/src/Logger.cpp
View File

@@ -1,79 +0,0 @@
#include "Logger.h"
#include "Utils.h"
#include "defines.h"
const string Logger::m_sFileName = LOG_NAME;
Logger* Logger::m_pThis = NULL;
ofstream Logger::m_Logfile;
Logger::Logger()
{
}
Logger* Logger::GetLogger()
{
if (m_pThis == NULL) {
m_pThis = new Logger();
std::filesystem::path dirPath = std::filesystem::temp_directory_path();
m_Logfile.open((dirPath.string() + m_sFileName).c_str(), ios::out | ios::app);
m_pThis->Log("**************************************************");
}
return m_pThis;
}
void Logger::Open()
{
std::filesystem::path dirPath = std::filesystem::temp_directory_path();
m_Logfile.open((dirPath.string() + m_sFileName).c_str(), ios::out | ios::app);
}
void Logger::Close()
{
m_Logfile.close();
}
void Logger::Log(const char* format, ...)
{
Open();
char* sMessage = NULL;
int nLength = 0;
va_list args;
va_start(args, format);
// Return the number of characters in the string referenced the list of arguments.
// _vscprintf doesn't count terminating '\0' (that's why +1)
nLength = _vscprintf(format, args) + 1;
sMessage = new char[nLength];
vsprintf_s(sMessage, nLength, format, args);
//vsprintf(sMessage, format, args);
m_Logfile << Utils::CurrentDateTime() << ":\t";
m_Logfile << sMessage << "\n";
va_end(args);
Close();
delete[] sMessage;
}
void Logger::Log(const string& sMessage)
{
Open();
m_Logfile << Utils::CurrentDateTime() << ":\t";
m_Logfile << sMessage << "\n";
Close();
}
void Logger::Log(const wstring& sMessage)
{
Open();
m_Logfile << Utils::CurrentDateTime() << ":\t";
m_Logfile << Utils::to_string(sMessage) << "\n";
Close();
}
Logger& Logger::operator<<(const string& sMessage)
{
Open();
m_Logfile << "\n" << Utils::CurrentDateTime() << ":\t";
m_Logfile << sMessage << "\n";
return *this;
Close();
}

8
src/utils/src/Utils.cpp
View File

@@ -1,8 +1,8 @@
#include "framework.h"
#include "Utils.h"
#include "utils.h"
// Get current date/time, format is YYYY-MM-DD.HH:mm:ss
const std::string Utils::CurrentDateTime()
const std::string CurrentDateTime()
{
time_t now = time(NULL);
struct tm tstruct;
@@ -12,7 +12,7 @@ const std::string Utils::CurrentDateTime()
return buf;
}
std::wstring Utils::to_wstring(const std::string& str)
std::wstring to_wstring(const std::string& str)
{
int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
std::wstring wstrTo(size_needed, 0);
@@ -20,7 +20,7 @@ std::wstring Utils::to_wstring(const std::string& str)
return wstrTo;
}
std::string Utils::to_string(const std::wstring& wstr)
std::string to_string(const std::wstring& wstr)
{
if (wstr.empty())
{

18
src/utils/src/main.cpp
View File

@@ -1,18 +0,0 @@
#include "framework.h"
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}

18
src/utils/utils.vcxproj
View File

@@ -19,17 +19,10 @@
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\DCSUtils.h" />
<ClInclude Include="include\Logger.h" />
<ClInclude Include="include\LUAUtils.h" />
<ClInclude Include="include\Utils.h" />
<ClInclude Include="include\utils.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\DCSUtils.cpp" />
<ClCompile Include="src\main.cpp" />
<ClCompile Include="src\Logger.cpp" />
<ClCompile Include="src\LUAUtils.cpp" />
<ClCompile Include="src\Utils.cpp" />
<ClCompile Include="src\utils.cpp" />
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>16.0</VCProjectVersion>
@@ -59,7 +52,7 @@
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
@@ -151,9 +144,10 @@
<PreprocessorDefinitions>NDEBUG;UTILS_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
<PrecompiledHeaderFile>
</PrecompiledHeaderFile>
<AdditionalIncludeDirectories>include;..\..\third-party\lua\include;..\shared\include</AdditionalIncludeDirectories>
<LanguageStandard>stdcpp17</LanguageStandard>
<LanguageStandard>stdcpp20</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>

25
src/utils/utils.vcxproj.filters
View File

@@ -11,33 +11,12 @@
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\DCSUtils.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\LUAUtils.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\Utils.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\Logger.h">
<ClInclude Include="include\utils.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\DCSUtils.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\main.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\LUAUtils.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\Utils.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\Logger.cpp">
<ClCompile Include="src\utils.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>