Further Tidy of unused files

Creation of NodeJS Branch
2026-07-13 10:13:42 +00:00 · 2020-01-28 23:16:33 +00:00 · 2020-01-28 23:04:21 +00:00
53 changed files with 1708 additions and 4702 deletions
@@ -1,5 +0,0 @@
 ---
 BasedOnStyle: WebKit
 BreakBeforeBraces: Attach
 ...
@@ -1,41 +0,0 @@
 name: CMake Linux Build
 on: [push, pull_request]
 env:
  BUILD_TYPE: Release
 jobs:
  linux-build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
      with:
          submodules: 'true'
    - name: Install Dependencies
      run: |
          sudo apt-get update
          sudo apt-get install -y libz-dev rapidjson-dev liblua5.3 libssl-dev libwebsocketpp-dev
          sudo add-apt-repository ppa:mhier/libboost-latest
          sudo apt-get install -y libboost1.70-dev libboost1.70
    - name: Create Build Environment
      run: cmake -E make_directory ${{github.workspace}}/build-linux
    - name: Configure CMake
      shell: bash
      working-directory: ${{github.workspace}}/build-linux
      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_CXX_COMPILER=g++-10
    - name: Build
      working-directory: ${{github.workspace}}/build-linux
      shell: bash
      run: cmake --build . --config $BUILD_TYPE
    - name: Archive artifacts
      uses: actions/upload-artifact@v2
      with:
        name: BeamMP-Server-linux
        path: ${{github.workspace}}/build-linux/BeamMP-Server
@@ -1,45 +0,0 @@
 name: CMake Windows Build
 on: [push, pull_request]
 env:
  BUILD_TYPE: Release
 jobs:
  windows-build:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v2
        with:
            submodules: 'true'
      - name: Restore artifacts, or run vcpkg, build and cache artifacts
        uses: lukka/run-vcpkg@main
        id: runvcpkg
        with:
            vcpkgArguments: 'lua zlib rapidjson boost-beast boost-asio openssl websocketpp'
            vcpkgDirectory: '${{ runner.workspace }}/b/vcpkg'
            vcpkgGitCommitId: '75522bb1f2e7d863078bcd06322348f053a9e33f'
            vcpkgTriplet: 'x64-windows-static'
      - name: Create Build Environment
        run: cmake -E make_directory ${{github.workspace}}/build-windows
      - name: Configure CMake
        shell: bash
        working-directory: ${{github.workspace}}/build-windows
        run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_TOOLCHAIN_FILE='${{ runner.workspace }}/b/vcpkg/scripts/buildsystems/vcpkg.cmake' -DVCPKG_TARGET_TRIPLET=x64-windows-static
      - name: Build
        working-directory: ${{github.workspace}}/build-windows
        shell: bash
        run: cmake --build . --config $BUILD_TYPE
      - name: Archive artifacts
        uses: actions/upload-artifact@v2
        with:
          name: BeamMP-Server.exe
          path: ${{github.workspace}}/build-windows/Release/BeamMP-Server.exe
@@ -1,114 +0,0 @@
 name: Release Create & Build
 on:
  push:
    # Sequence of patterns matched against refs/tags
    tags:
    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
 env:
  BUILD_TYPE: Release
 jobs:
  create-release:
    runs-on: ubuntu-latest
    name: Create Release
    outputs: 
      upload_url: ${{ steps.create_release.outputs.upload_url }} 
    steps:
      - name: Create Release
        id: create_release
        uses: actions/create-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name: ${{ github.ref }}
          release_name: Release ${{ github.ref }}
          draft: false
          prerelease: false 
          body: |
              Files included in this release:
              - `BeamMP-Server.exe` is the windows build
              - `BeamMP-Server-linux` is a ubuntu build, so you need the dependencies listed in README.md to run it. For any other distros please build from source as described in README.md.
  upload-release-files-linux:
    name: Upload Linux Release Files
    runs-on: ubuntu-latest
    needs: create-release
    steps:
      - uses: actions/checkout@v2
        with:
            submodules: 'true'
      - name: Install Dependencies
        run: |
            sudo apt-get update
            sudo apt-get install -y libz-dev rapidjson-dev liblua5.3 libssl-dev libwebsocketpp-dev
            sudo add-apt-repository ppa:mhier/libboost-latest
            sudo apt-get install -y libboost1.70-dev libboost1.70
      - name: Create Build Environment
        run: cmake -E make_directory ${{github.workspace}}/build-linux
      - name: Configure CMake
        shell: bash
        working-directory: ${{github.workspace}}/build-linux
        run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_CXX_COMPILER=g++-10
      - name: Build
        working-directory: ${{github.workspace}}/build-linux
        shell: bash
        run: cmake --build . --config $BUILD_TYPE
      - name: Upload Release Asset
        id: upload-release-asset 
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.create-release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
          asset_path: ${{github.workspace}}/build-linux/BeamMP-Server
          asset_name: BeamMP-Server-linux
          asset_content_type: application/x-elf
  upload-release-files-windows:
    name: Upload Windows Release Files
    runs-on: windows-latest
    needs: create-release
    steps:
      - uses: actions/checkout@v2
        with:
            submodules: 'true'
      - name: Restore artifacts, or run vcpkg, build and cache artifacts
        uses: lukka/run-vcpkg@main
        id: runvcpkg
        with:
            vcpkgArguments: 'lua zlib rapidjson boost-beast boost-asio openssl websocketpp'
            vcpkgDirectory: '${{ runner.workspace }}/b/vcpkg'
            vcpkgGitCommitId: '75522bb1f2e7d863078bcd06322348f053a9e33f'
            vcpkgTriplet: 'x64-windows-static'
      - name: Create Build Environment
        run: cmake -E make_directory ${{github.workspace}}/build-windows
      - name: Configure CMake
        shell: bash
        working-directory: ${{github.workspace}}/build-windows
        run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_TOOLCHAIN_FILE='${{ runner.workspace }}/b/vcpkg/scripts/buildsystems/vcpkg.cmake' -DVCPKG_TARGET_TRIPLET=x64-windows-static
      - name: Build
        working-directory: ${{github.workspace}}/build-windows
        shell: bash
        run: cmake --build . --config $BUILD_TYPE
      - name: Upload Release Asset
        id: upload-release-asset 
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.create-release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
          asset_path: ${{github.workspace}}/build-windows/Release/BeamMP-Server.exe
          asset_name: BeamMP-Server.exe
          asset_content_type: application/vnd.microsoft.portable-executable
@@ -1,470 +1,104 @@
-boost_*
+# Logs
-Resources
+logs
 ## Ignore Visual Studio temporary files, build results, and
 ## files generated by popular Visual Studio add-ons.
 ##
 ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
 # User-specific files
 *.rsuser
 *.suo
 *.user
 *.userosscache
 *.sln.docstates
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
 # Mono auto generated files
 mono_crash.*
 #VS Files
 out/
 #Clion Files
 cmake-build-debug/
 cmake-build-release/
 .idea/
 # Build results
 [Dd]ebug/
 [Dd]ebugPublic/
 [Rr]elease/
 [Rr]eleases/
 x64/
 x86/
 [Aa][Rr][Mm]/
 [Aa][Rr][Mm]64/
 bld/
 [Bb]in/
 [Oo]bj/
 [Ll]og/
 [Ll]ogs/
 # Visual Studio 2015/2017 cache/options directory
 .vs/
 # Uncomment if you have tasks that create the project's static files in wwwroot
 #wwwroot/
 # Visual Studio 2017 auto generated files
 Generated\ Files/
 # MSTest test Results
 [Tt]est[Rr]esult*/
 [Bb]uild[Ll]og.*
 # NUnit
 *.VisualState.xml
 TestResult.xml
 nunit-*.xml
 # Build Results of an ATL Project
 [Dd]ebugPS/
 [Rr]eleasePS/
 dlldata.c
 # Benchmark Results
 BenchmarkDotNet.Artifacts/
 # .NET Core
 project.lock.json
 project.fragment.lock.json
 artifacts/
 # StyleCop
 StyleCopReport.xml
 # Files built by Visual Studio
 *_i.c
 *_p.c
 *_h.h
 *.ilk
 *.meta
 *.obj
 *.iobj
 *.pch
 *.pdb
 *.ipdb
 *.pgc
 *.pgd
 *.rsp
 *.sbr
 *.tlb
 *.tli
 *.tlh
 *.tmp
 *.tmp_proj
 *_wpftmp.csproj
 *.log
-*.vspscc
+npm-debug.log*
-*.vssscc
+yarn-debug.log*
-.builds
+yarn-error.log*
-*.pidb
+lerna-debug.log*
 *.svclog
 *.scc
-# Chutzpah Test files
+# Diagnostic reports (https://nodejs.org/api/report.html)
-_Chutzpah*
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
-# Visual C++ cache files
+# Runtime data
-ipch/
+pids
-*.aps
+*.pid
-*.ncb
+*.seed
-*.opendb
+*.pid.lock
 *.opensdf
 *.sdf
 *.cachefile
 *.VC.db
 *.VC.VC.opendb
-# Visual Studio profiler
+# Directory for instrumented libs generated by jscoverage/JSCover
-*.psess
+lib-cov
 *.vsp
 *.vspx
 *.sap
-# Visual Studio Trace Files
+# Coverage directory used by tools like istanbul
-*.e2e
+coverage
 *.lcov
-# TFS 2012 Local Workspace
+# nyc test coverage
-$tf/
+.nyc_output
-# Guidance Automation Toolkit
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
-*.gpState
+.grunt
-# ReSharper is a .NET coding add-in
+# Bower dependency directory (https://bower.io/)
-_ReSharper*/
+bower_components
 *.[Rr]e[Ss]harper
 *.DotSettings.user
-# TeamCity is a build add-in
+# node-waf configuration
-_TeamCity*
+.lock-wscript
-# DotCover is a Code Coverage Tool
+# Compiled binary addons (https://nodejs.org/api/addons.html)
-*.dotCover
+build/Release
-# AxoCover is a Code Coverage Tool
+# Dependency directories
 .axoCover/*
 !.axoCover/settings.json
 # Visual Studio code coverage results
 *.coverage
 *.coveragexml
 # NCrunch
 _NCrunch_*
 .*crunch*.local.xml
 nCrunchTemp_*
 # MightyMoose
 *.mm.*
 AutoTest.Net/
 # Web workbench (sass)
 .sass-cache/
 # Installshield output folder
 [Ee]xpress/
 # DocProject is a documentation generator add-in
 DocProject/buildhelp/
 DocProject/Help/*.HxT
 DocProject/Help/*.HxC
 DocProject/Help/*.hhc
 DocProject/Help/*.hhk
 DocProject/Help/*.hhp
 DocProject/Help/Html2
 DocProject/Help/html
 # Click-Once directory
 publish/
 # Publish Web Output
 *.[Pp]ublish.xml
 *.azurePubxml
 # Note: Comment the next line if you want to checkin your web deploy settings,
 # but database connection strings (with potential passwords) will be unencrypted
 *.pubxml
 *.publishproj
 # Microsoft Azure Web App publish settings. Comment the next line if you want to
 # checkin your Azure Web App publish settings, but sensitive information contained
 # in these scripts will be unencrypted
 PublishScripts/
 # NuGet Packages
 *.nupkg
 # NuGet Symbol Packages
 *.snupkg
 # The packages folder can be ignored because of Package Restore
 **/[Pp]ackages/*
 # except build/, which is used as an MSBuild target.
 !**/[Pp]ackages/build/
 # Uncomment if necessary however generally it will be regenerated when needed
 #!**/[Pp]ackages/repositories.config
 # NuGet v3's project.json files produces more ignorable files
 *.nuget.props
 *.nuget.targets
 # Microsoft Azure Build Output
 csx/
 *.build.csdef
 # Microsoft Azure Emulator
 ecf/
 rcf/
 # Windows Store app package directories and files
 AppPackages/
 BundleArtifacts/
 Package.StoreAssociation.xml
 _pkginfo.txt
 *.appx
 *.appxbundle
 *.appxupload
 # Visual Studio cache files
 # files ending in .cache can be ignored
 *.[Cc]ache
 # but keep track of directories ending in .cache
 !?*.[Cc]ache/
 # Others
 ClientBin/
 ~$*
 *~
 *.dbmdl
 *.dbproj.schemaview
 *.jfm
 *.pfx
 *.publishsettings
 orleans.codegen.cs
 # Including strong name files can present a security risk
 # (https://github.com/github/gitignore/pull/2483#issue-259490424)
 #*.snk
 # Since there are multiple workflows, uncomment next line to ignore bower_components
 # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
 #bower_components/
 # RIA/Silverlight projects
 Generated_Code/
 # Backup & report files from converting an old project file
 # to a newer Visual Studio version. Backup files are not needed,
 # because we have git ;-)
 _UpgradeReport_Files/
 Backup*/
 UpgradeLog*.XML
 UpgradeLog*.htm
 ServiceFabricBackup/
 *.rptproj.bak
 # SQL Server files
 *.mdf
 *.ldf
 *.ndf
 # Business Intelligence projects
 *.rdl.data
 *.bim.layout
 *.bim_*.settings
 *.rptproj.rsuser
 *- [Bb]ackup.rdl
 *- [Bb]ackup ([0-9]).rdl
 *- [Bb]ackup ([0-9][0-9]).rdl
 # Microsoft Fakes
 FakesAssemblies/
 # GhostDoc plugin setting file
 *.GhostDoc.xml
 # Node.js Tools for Visual Studio
 .ntvs_analysis.dat
 node_modules/
 jspm_packages/
-# Visual Studio 6 build log
+# TypeScript v1 declaration files
-*.plg
+typings/
-# Visual Studio 6 workspace options file
+# TypeScript cache
-*.opt
+*.tsbuildinfo
-# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+# Optional npm cache directory
-*.vbw
+.npm
-# Visual Studio LightSwitch build output
+# Optional eslint cache
-**/*.HTMLClient/GeneratedArtifacts
+.eslintcache
 **/*.DesktopClient/GeneratedArtifacts
 **/*.DesktopClient/ModelManifest.xml
 **/*.Server/GeneratedArtifacts
 **/*.Server/ModelManifest.xml
 _Pvt_Extensions
-# Paket dependency manager
+# Microbundle cache
-.paket/paket.exe
+.rpt2_cache/
-paket-files/
+.rts2_cache_cjs/
 .rts2_cache_es/
 .rts2_cache_umd/
-# FAKE - F# Make
+# Optional REPL history
-.fake/
+.node_repl_history
-# CodeRush personal settings
+# Output of 'npm pack'
-.cr/personal
+*.tgz
-# Python Tools for Visual Studio (PTVS)
+# Yarn Integrity file
-__pycache__/
+.yarn-integrity
 *.pyc
-# Cake - Uncomment if you are using it
+# dotenv environment variables file
-# tools/**
+.env
-# !tools/packages.config
+.env.test
-# Tabs Studio
+# parcel-bundler cache (https://parceljs.org/)
-*.tss
+.cache
-# Telerik's JustMock configuration file
+# Next.js build output
-*.jmconfig
+.next
-# BizTalk build output
+# Nuxt.js build / generate output
-*.btp.cs
+.nuxt
-*.btm.cs
+dist
 *.odx.cs
 *.xsd.cs
-# OpenCover UI analysis results
+# Gatsby files
-OpenCover/
+.cache/
 # Comment in the public line in if your project uses Gatsby and *not* Next.js
 # https://nextjs.org/blog/next-9-1#public-directory-support
 # public
-# Azure Stream Analytics local run output
+# vuepress build output
-ASALocalRun/
+.vuepress/dist
-# MSBuild Binary and Structured Log
+# Serverless directories
-*.binlog
+.serverless/
-# NVidia Nsight GPU debugger configuration file
+# FuseBox cache
-*.nvuser
+.fusebox/
-# MFractors (Xamarin productivity tool) working folder
+# DynamoDB Local files
-.mfractor/
+.dynamodb/
-# Local History for Visual Studio
+# TernJS port file
-.localhistory/
+.tern-port
 # BeatPulse healthcheck temp database
 healthchecksdb
 # Backup folder for Package Reference Convert tool in Visual Studio 2017
 MigrationBackup/
 # Ionide (cross platform F# VS Code tools) working folder
 .ionide/
 out/build/x86-Debug/VSInheritEnvironments.txt
 out/build/x86-Debug/rules.ninja
 out/build/x86-Debug/CMakeFiles/untitled.dir/manifest.res
 out/build/x86-Debug/CMakeFiles/untitled.dir/manifest.rc
 out/build/x86-Debug/CMakeFiles/untitled.dir/intermediate.manifest
 out/build/x86-Debug/CMakeFiles/untitled.dir/embed.manifest
 out/build/x86-Debug/CMakeFiles/TargetDirectories.txt
 out/build/x86-Debug/CMakeFiles/ShowIncludes/main.c
 out/build/x86-Debug/CMakeFiles/ShowIncludes/foo.h
 out/build/x86-Debug/CMakeFiles/cmake.check_cache
 out/build/x86-Debug/CMakeFiles/3.15.19101501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.exe
 out/build/x86-Debug/CMakeFiles/3.15.19101501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.cpp
 out/build/x86-Debug/CMakeFiles/3.15.19101501-MSVC_2/CompilerIdC/CMakeCCompilerId.exe
 out/build/x86-Debug/CMakeFiles/3.15.19101501-MSVC_2/CompilerIdC/CMakeCCompilerId.c
 out/build/x86-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeSystem.cmake
 out/build/x86-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeRCCompiler.cmake
 out/build/x86-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeDetermineCompilerABI_CXX.bin
 out/build/x86-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeDetermineCompilerABI_C.bin
 out/build/x86-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeCXXCompiler.cmake
 out/build/x86-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeCCompiler.cmake
 out/build/x86-Debug/CMakeCache.txt
 out/build/x86-Debug/cmake_install.cmake
 out/build/x86-Debug/build.ninja
 out/build/x86-Debug/.ninja_log
 out/build/x86-Debug/.ninja_deps
 out/build/x86-Debug/.cmake/api/v1/reply/target-untitled-Debug-03f16c5921ae0bd48990.json
 out/build/x86-Debug/.cmake/api/v1/reply/index-2020-01-27T23-42-34-0718.json
 out/build/x86-Debug/.cmake/api/v1/reply/codemodel-v2-2b93246ca751d7a49cd1.json
 out/build/x86-Debug/.cmake/api/v1/reply/cmakeFiles-v1-d93b224eb363971ee2c4.json
 out/build/x86-Debug/.cmake/api/v1/reply/cache-v2-43521627501184045d13.json
 out/build/x86-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json
 out/build/x64-Debug/VSInheritEnvironments.txt
 out/build/x64-Debug/rules.ninja
 out/build/x64-Debug/CMakeFiles/untitled.dir/manifest.res
 out/build/x64-Debug/CMakeFiles/untitled.dir/manifest.rc
 out/build/x64-Debug/CMakeFiles/untitled.dir/intermediate.manifest
 out/build/x64-Debug/CMakeFiles/untitled.dir/embed.manifest
 out/build/x64-Debug/CMakeFiles/TargetDirectories.txt
 out/build/x64-Debug/CMakeFiles/ShowIncludes/main.c
 out/build/x64-Debug/CMakeFiles/ShowIncludes/foo.h
 out/build/x64-Debug/CMakeFiles/cmake.check_cache
 out/build/x64-Debug/CMakeFiles/3.15.19101501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.exe
 out/build/x64-Debug/CMakeFiles/3.15.19101501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.cpp
 out/build/x64-Debug/CMakeFiles/3.15.19101501-MSVC_2/CompilerIdC/CMakeCCompilerId.exe
 out/build/x64-Debug/CMakeFiles/3.15.19101501-MSVC_2/CompilerIdC/CMakeCCompilerId.c
 out/build/x64-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeSystem.cmake
 out/build/x64-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeRCCompiler.cmake
 out/build/x64-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeDetermineCompilerABI_CXX.bin
 out/build/x64-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeDetermineCompilerABI_C.bin
 out/build/x64-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeCXXCompiler.cmake
 out/build/x64-Debug/CMakeFiles/3.15.19101501-MSVC_2/CMakeCCompiler.cmake
 out/build/x64-Debug/CMakeCache.txt
 out/build/x64-Debug/cmake_install.cmake
 out/build/x64-Debug/build.ninja
 out/build/x64-Debug/.ninja_log
 out/build/x64-Debug/.ninja_deps
 out/build/x64-Debug/.cmake/api/v1/reply/target-untitled-Debug-8918286eee207fe0275b.json
 out/build/x64-Debug/.cmake/api/v1/reply/index-2020-01-27T23-42-03-0431.json
 out/build/x64-Debug/.cmake/api/v1/reply/codemodel-v2-ee254da00ecbf4b22928.json
 out/build/x64-Debug/.cmake/api/v1/reply/cmakeFiles-v1-ee926bd040d82c324cbe.json
 out/build/x64-Debug/.cmake/api/v1/reply/cache-v2-6f7cb0917968b934d35c.json
 out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json
 CMakeSettings.json
 cmake-build-debug/Resource1.resx
 out/build/x64-Debug/.cmake/api/v1/reply/index-2020-01-28T10-34-19-0746.json
 out/build/x64-Debug/untitled.exe
 out/build/x64-Debug/.cmake/api/v1/reply/index-2020-01-28T11-19-41-0061.json
 out/build/x64-Debug/.cmake/api/v1/reply/cmakeFiles-v1-52c1d9386071c1490278.json
 out/build/x86-Debug/CMakeFiles/cmake-main.dir/manifest.res
 out/build/x86-Debug/CMakeFiles/cmake-main.dir/manifest.rc
 out/build/x86-Debug/CMakeFiles/cmake-main.dir/intermediate.manifest
 out/build/x86-Debug/CMakeFiles/cmake-main.dir/embed.manifest
 out/build/x86-Debug/cmake-main.exe
 out/build/x86-Debug/.cmake/api/v1/reply/target-enet-Debug-1cc90e5d191bd520f961.json
 out/build/x86-Debug/.cmake/api/v1/reply/target-cmake-main-Debug-0c9bd3464adc40e447af.json
 out/build/x86-Debug/.cmake/api/v1/reply/index-2020-01-28T11-21-26-0362.json
 out/build/x86-Debug/.cmake/api/v1/reply/codemodel-v2-1850e17888d5bab56568.json
 out/build/x86-Debug/.cmake/api/v1/reply/cmakeFiles-v1-7c376457f6b736ad28ac.json
 out/build/x64-Debug/CMakeFiles/cmake-main.dir/manifest.res
 out/build/x64-Debug/CMakeFiles/cmake-main.dir/manifest.rc
 out/build/x64-Debug/CMakeFiles/cmake-main.dir/intermediate.manifest
 out/build/x64-Debug/CMakeFiles/cmake-main.dir/embed.manifest
 out/build/x64-Debug/cmake-main.exe
 out/build/x64-Debug/.cmake/api/v1/reply/target-enet-Debug-645fd45f5bd4fab53aa9.json
 out/build/x64-Debug/.cmake/api/v1/reply/target-cmake-main-Debug-b124668c8fb6ca5df286.json
 out/build/x64-Debug/.cmake/api/v1/reply/index-2020-01-28T11-21-06-0706.json
 out/build/x64-Debug/.cmake/api/v1/reply/codemodel-v2-63a6ab1789a1732f4563.json
 out/build/x86-Debug/.cmake/api/v1/reply/target-enet-Debug-d301abed48f6c38bdcfb.json
 out/build/x86-Debug/.cmake/api/v1/reply/index-2020-01-28T12-30-44-0946.json
 out/build/x86-Debug/.cmake/api/v1/reply/codemodel-v2-3eaabe43603befc605b1.json
 out/build/x86-Debug/.cmake/api/v1/reply/target-cmake-main-Debug-70eff68e1e381b42992e.json
 *.xml
 out/build/x86-Debug/.cmake/api/v1/reply/target-enet-Debug-48db38ae5d08e27876b8.json
 out/build/x86-Debug/.cmake/api/v1/reply/target-cmake-main-Debug-540e487569703b71c785.json
 out/build/x86-Debug/.cmake/api/v1/reply/index-2020-01-28T17-35-38-0764.json
 out/build/x86-Debug/.cmake/api/v1/reply/codemodel-v2-6a61e390ef8eaf17e9f8.json
 out/build/x86-Debug/Server.cfg
 *Server.cfg*
 *.cmake
 *.make
 *.xml
 *.includecache
 cmake-build-release/include/commandline/Makefile
 *.lib
 *.cbp
 *.marks
 *.internal
 *.xml
 cmake-build-debug/include/commandline/Makefile
 *.manifest
 *.rc
 *.res
@@ -1,12 +0,0 @@
 [submodule "include/commandline"]
    path = include/commandline
    url = https://github.com/lionkor/commandline
 [submodule "socket.io-client-cpp"]
 	path = socket.io-client-cpp
 	url = https://github.com/socketio/socket.io-client-cpp
 [submodule "asio"]
 	path = asio
 	url = https://github.com/chriskohlhoff/asio
 [submodule "rapidjson"]
 	path = rapidjson
 	url = https://github.com/Tencent/rapidjson
@@ -1 +0,0 @@
 Server
@@ -1,4 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
 </project>
@@ -1,16 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="VcsDirectoryMappings">
    <mapping directory="$PROJECT_DIR$" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/asio" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/include/commandline" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/rapidjson" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/rapidjson/thirdparty/gtest" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/socket.io-client-cpp" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/socket.io-client-cpp/lib/asio" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/socket.io-client-cpp/lib/catch" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/socket.io-client-cpp/lib/rapidjson" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/socket.io-client-cpp/lib/rapidjson/thirdparty/gtest" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/socket.io-client-cpp/lib/websocketpp" vcs="Git" />
  </component>
 </project>
@@ -1,68 +0,0 @@
 cmake_minimum_required(VERSION 3.0)
 project(Server)
 if (WIN32)
    message(STATUS "MSVC -> forcing use of statically-linked runtime.")
    STRING(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE})
    STRING(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
    #-DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static
    set(VcpkgRoot ${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET})
    include_directories(${VcpkgRoot}/include)
    link_directories(${VcpkgRoot}/lib)
 elseif (UNIX)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic -static-libstdc++")
    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g")
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2 -s -fno-builtin")
    if (SANITIZE)
        message(STATUS "sanitize is ON")
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined,thread")
    endif (SANITIZE)
 endif ()
 # this has to happen before -DDEBUG since it wont compile properly with -DDEBUG
 include_directories("asio/asio/include")
 include_directories("rapidjson/include")
 include_directories("websocketpp")
 add_subdirectory("socket.io-client-cpp")
 add_subdirectory("include/commandline")
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG")
 find_package(Boost REQUIRED COMPONENTS system thread)
 add_executable(BeamMP-Server
        src/main.cpp
        include/TConsole.h src/TConsole.cpp
        include/TServer.h src/TServer.cpp
        include/Compat.h src/Compat.cpp
        include/Common.h src/Common.cpp
        include/Client.h src/Client.cpp
        include/VehicleData.h src/VehicleData.cpp
        include/TConfig.h src/TConfig.cpp
        include/TLuaEngine.h src/TLuaEngine.cpp
        include/TLuaFile.h src/TLuaFile.cpp
        include/TResourceManager.h src/TResourceManager.cpp
        include/THeartbeatThread.h src/THeartbeatThread.cpp
        include/Http.h src/Http.cpp
        #include/SocketIO.h src/SocketIO.cpp
        include/TPPSMonitor.h src/TPPSMonitor.cpp
        include/TNetwork.h src/TNetwork.cpp)
 target_include_directories(BeamMP-Server PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/commandline")
 find_package(Lua REQUIRED)
 target_include_directories(BeamMP-Server PUBLIC ${Boost_INCLUDE_DIRS} ${LUA_INCLUDE_DIR} "socket.io-client-cpp/src")
 find_package(OpenSSL REQUIRED)
 if (UNIX)
    target_link_libraries(BeamMP-Server z pthread stdc++fs ${Boost_LINK_DIRS} ${LUA_LIBRARIES} dl crypto ${OPENSSL_LIBRARIES} ${Boost_LIBRARIES} commandline sioclient_tls)
 elseif (WIN32)
    include(FindLua)
    find_package(ZLIB REQUIRED)
    find_package(RapidJSON CONFIG REQUIRED)
    target_include_directories(BeamMP-Server PRIVATE ${RAPIDJSON_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS})
    target_link_libraries(BeamMP-Server PRIVATE ws2_32 ZLIB::ZLIB ${LUA_LIBRARIES} ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES} commandline sioclient_tls)
 endif ()
@@ -1 +0,0 @@
 Copyright (c) 2019-present Anonymous275. BeamMP Server code is not in the public domain and is not free software. One must be granted explicit permission by the copyright holder in order to modify or distribute any part of the source or binaries, the only permission that has been granted is to use the software in its compiled form as distributed from the BeamMP.com website. Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
@@ -1,73 +1 @@
-# BeamMP-Server
+# BeamNG-MP-Server
 [![CMake Windows Build](https://github.com/BeamMP/BeamMP-Server/workflows/CMake%20Windows%20Build/badge.svg?branch=master)](https://github.com/BeamMP/BeamMP-Server/actions?query=workflow%3A%22CMake+Windows+Build%22)
 [![CMake Linux Build](https://github.com/BeamMP/BeamMP-Server/workflows/CMake%20Linux%20Build/badge.svg?branch=master)](https://github.com/BeamMP/BeamMP-Server/actions?query=workflow%3A%22CMake+Linux+Build%22)
 This is the server for the multiplayer mod **[BeamMP](https://beammp.com/)** for the game [BeamNG.drive](https://www.beamng.com/).
 The server is the point throug which all clients communicate. You can write lua mods for the server, detailed instructions on the [BeamMP Wiki](https://wiki.beammp.com).
 ## About Building from Source
 We only allow building unmodified (original) source code. `master` is considered **unstable** and we will not provide technical support if such a build doesn't work, so always build from a tag. You can checkout a tag with `git checkout tags/TAGNAME`, where `TAGNAME` is the tag, for example `v1.20`. 
 ## Supported Operating Systems
 The code itself supports (latest stable) Linux and Windows. In terms of actual build support, for now we usually only distribute windows binaries and sometimes linux. For any other distro or OS, you just have to find the same libraries listed in the Linux Build [Prerequisites](#prerequisites) further down the page, and it should build fine. We don't currently support any big-endian architectures.
 Recommended compilers: MSVC, GCC, CLANG. 
 You can find precompiled binaries under [Releases](https://github.com/BeamMP/BeamMP-Server/releases/).
 ## Build Instructions
 **__Do not compile from `master`. Always build from a release tag, i.e. `tags/v2.0`!__**
 Currently only linux and windows are supported (generally). See [Releases](https://github.com/BeamMP/BeamMP-Server/releases/) for official binary releases. On systems to which we do not provide binaries (so anything but windows), you are allowed to compile the program and use it. Other restrictions, such as not being allowed to distribute those binaries, still apply (see [copyright notice](#copyright)).
 ### Prerequisites
 #### Windows
 Please use the prepackaged binaries in [Releases](https://github.com/BeamMP/BeamMP-Server/releases/).
 Dependencies for windows can be installed with `vcpkg`, in which case the current dependencies are the `x64-windows-static` versions of `lua`, `zlib`, `rapidjson`, `boost-beast`, `boost-asio` and `openssl`.
 #### Linux / \*nix
 These package names are in the debian / ubuntu style. Feel free to PR your own guide for a different distro.
 - `git`
 - `make`
 - `cmake`
 - `g++`
  Must support ISO C++17. If your distro's `g++` doesn't support C++17, chances are that it has a `g++-8` or `g++-10` package that does. If this is the case. you just need to run CMake with `-DCMAKE_CXX_COMPILER=g++-10` (replace `g++-10` with your compiler's name).
 - `liblua5.3` 
  Any 5.x version should work, but 5.3 is what we officially use. Any other version might break in the future.
  You can also use any version of `libluajit`, but the same applies regarding the version.
 - `libz-dev`
 - `rapidjson-dev`
 - `libboost1.70-dev`
  If your distro doesn't have 1.7x version of libboost, you'll have to compile it from source or find another way to get it for your distro.
 - `libopenssl-dev`
 ### How to build
 On windows. use git-bash for these commands.
 1. Make sure you have all [prerequisites](#prerequisites) installed
 2. Clone the repository in a location of your choice with `git clone --recursive https://github.com/BeamMP/BeamMP-Server`
 3. Checkout the branch of the release you want to compile (`master` is often unstable), for example `git checkout tags/v1.20` for version 1.20.
 4. `cd` into it with `cd BeamMP-Server`
 5. Run `cmake .` (with `.`)
 6. Run `make`
 7. You will now have a `BeamMP-Server` file in your directory, which is executable with `./BeamMP-Server` (`.\BeamMP-Server.exe` for windows). Follow the (windows or linux, doesnt matter) instructions on the [wiki](https://wiki.beammp.com/en/home/Server_Mod) for further setup after installation (which we just did), such as port-forwarding and getting a key to actually run the server.
 *tip: to run the server in the background, simply (in bash, zsh, etc) run:* `nohup ./BeamMP-Server &`*.*
 ## Copyright
 Copyright (c) 2019-present Anonymous275 (@Anonymous-275), Lion Kortlepel (@lionkor).
 BeamMP-Server code is not in the public domain and is not free software. One must be granted explicit permission by the copyright holder(s) in order to modify or distribute any part of the source or binaries. Special permission to modify the source-code is implicitly granted only for the purpose of upstreaming those changes directly to github.com/BeamMP/BeamMP-Server via a GitHub pull-request.
@@ -1,88 +0,0 @@
 #pragma once
 #include <chrono>
 #include <memory>
 #include <queue>
 #include <string>
 #include <unordered_set>
 #include "Common.h"
 #include "Compat.h"
 #include "VehicleData.h"
 class TServer;
 class TClient final {
 public:
    using TSetOfVehicleData = std::unordered_set<TVehicleData>;
    struct TVehicleDataLockPair {
        TSetOfVehicleData& VehicleData;
        std::unique_lock<std::mutex> Lock;
    };
    explicit TClient(TServer& Server);
    TClient(const TClient&) = delete;
    TClient& operator=(const TClient&) = delete;
    void AddNewCar(int Ident, const std::string& Data);
    void SetCarData(int Ident, const std::string& Data);
    TVehicleDataLockPair GetAllCars();
    void SetName(const std::string& Name) { mName = Name; }
    void SetRoles(const std::string& Role) { mRole = Role; }
    void AddIdentifier(const std::string& ID) { mIdentifiers.insert(ID); };
    std::string GetCarData(int Ident);
    void SetUDPAddr(sockaddr_in Addr) { mUDPAddress = Addr; }
    void SetDownSock(SOCKET CSock) { mSocket[1] = CSock; }
    void SetTCPSock(SOCKET CSock) { mSocket[0] = CSock; }
    void SetStatus(int Status) { mStatus = Status; }
    void DeleteCar(int Ident);
    [[nodiscard]] std::set<std::string> GetIdentifiers() const { return mIdentifiers; }
    [[nodiscard]] sockaddr_in GetUDPAddr() const { return mUDPAddress; }
    [[nodiscard]] SOCKET GetDownSock() const { return mSocket[1]; }
    [[nodiscard]] SOCKET GetTCPSock() const { return mSocket[0]; }
    [[nodiscard]] std::string GetRoles() const { return mRole; }
    [[nodiscard]] std::string GetName() const { return mName; }
    void SetID(int ID) { mID = ID; }
    [[nodiscard]] int GetOpenCarID() const;
    [[nodiscard]] int GetCarCount() const;
    void ClearCars();
    [[nodiscard]] int GetStatus() const { return mStatus; }
    [[nodiscard]] int GetID() const { return mID; }
    [[nodiscard]] bool IsConnected() const { return mIsConnected; }
    [[nodiscard]] bool IsSynced() const { return mIsSynced; }
    [[nodiscard]] bool IsSyncing() const { return mIsSyncing; }
    [[nodiscard]] bool IsGuest() const { return mIsGuest; }
    void SetIsGuest(bool NewIsGuest) { mIsGuest = NewIsGuest; }
    void SetIsSynced(bool NewIsSynced) { mIsSynced = NewIsSynced; }
    void SetIsSyncing(bool NewIsSyncing) { mIsSyncing = NewIsSyncing; }
    void EnqueuePacket(const std::string& Packet);
    [[nodiscard]] std::queue<std::string>& MissedPacketQueue() { return mMissedPacketsDuringSyncing; }
    [[nodiscard]] const std::queue<std::string>& MissedPacketQueue() const { return mMissedPacketsDuringSyncing; }
    [[nodiscard]] size_t MissedPacketQueueSize() const { return mMissedPacketsDuringSyncing.size(); }
    [[nodiscard]] std::mutex& MissedPacketQueueMutex() const { return mMissedPacketsMutex; }
    void SetIsConnected(bool NewIsConnected) { mIsConnected = NewIsConnected; }
    [[nodiscard]] TServer& Server() const;
    void UpdatePingTime();
    int SecondsSinceLastPing();
 private:
    TServer& mServer;
    bool mIsConnected = false;
    bool mIsSynced = false;
    bool mIsSyncing = false;
    mutable std::mutex mMissedPacketsMutex;
    std::queue<std::string> mMissedPacketsDuringSyncing;
    std::set<std::string> mIdentifiers;
    bool mIsGuest = false;
    std::mutex mVehicleDataMutex;
    TSetOfVehicleData mVehicleData;
    std::string mName = "Unknown Client";
    SOCKET mSocket[2] { SOCKET(-1) };
    sockaddr_in mUDPAddress {}; // is this initialization OK? yes it is
    std::string mRole;
    std::string mDID;
    int mStatus = 0;
    int mID = -1;
    std::chrono::time_point<std::chrono::high_resolution_clock> mLastPingTime;
 };
@@ -1,115 +0,0 @@
 #pragma once
 #include <atomic>
 #include <deque>
 #include <functional>
 #include <memory>
 #include <mutex>
 #include "TConsole.h"
 // static class handling application start, shutdown, etc.
 // yes, static classes, singletons, globals are all pretty
 // bad idioms. In this case we need a central way to access
 // stuff like graceful shutdown, global settings (its in the name),
 // etc.
 class Application final {
 public:
    // types
    struct TSettings {
        TSettings() noexcept
            : DebugModeEnabled(true) { }
        std::string ServerName;
        std::string ServerDesc;
        std::string Resource;
        std::string MapName;
        std::string Key;
        int MaxPlayers {};
        bool Private {};
        int MaxCars {};
        bool DebugModeEnabled;
        int Port {};
        std::string CustomIP;
        [[nodiscard]] bool HasCustomIP() const { return !CustomIP.empty(); }
    };
    using TShutdownHandler = std::function<void()>;
    // methods
    Application() = delete;
    // 'Handler' is called when GracefullyShutdown is called
    static void RegisterShutdownHandler(const TShutdownHandler& Handler);
    // Causes all threads to finish up and exit gracefull gracefully
    static void GracefullyShutdown();
    static TConsole& Console() { return *mConsole; }
    static std::string ServerVersion() { return "2.0.1"; }
    static std::string ClientVersion() { return "2.0"; }
    static std::string PPS() { return mPPS; }
    static void SetPPS(std::string NewPPS) { mPPS = NewPPS; }
    static inline TSettings Settings {};
    static std::string GetBackendUrlForAuth() { return "auth.beammp.com"; }
    static std::string GetBackendHostname() { return "backend.beammp.com"; }
    static std::string GetBackendUrlForSocketIO() { return "https://backend.beammp.com"; }
 private:
    static inline std::string mPPS;
    static std::unique_ptr<TConsole> mConsole;
    static inline std::mutex mShutdownHandlersMutex {};
    static inline std::deque<TShutdownHandler> mShutdownHandlers {};
 };
 std::string ThreadName();
 void RegisterThread(const std::string str);
 #define RegisterThreadAuto() RegisterThread(__func__)
 #define KB 1024
 #define MB (KB * 1024)
 #define _file_basename std::filesystem::path(__FILE__).filename().string()
 #define _line std::to_string(__LINE__)
 #define _in_lambda (std::string(__func__) == "operator()")
 // we would like the full function signature 'void a::foo() const'
 // on windows this is __FUNCSIG__, on GCC it's __PRETTY_FUNCTION__,
 // feel free to add more
 #if defined(WIN32)
 #define _function_name std::string(__FUNCSIG__)
 #elif defined(__unix) || defined(__unix__)
 #define _function_name std::string(__PRETTY_FUNCTION__)
 #else
 #define _function_name std::string(__func__)
 #endif
 #if defined(DEBUG)
 // if this is defined, we will show the full function signature infront of
 // each info/debug/warn... call instead of the 'filename:line' format.
 #if defined(BMP_FULL_FUNCTION_NAMES)
 #define _this_location (ThreadName() + _function_name + " ")
 #else
 #define _this_location (ThreadName() + _file_basename + ":" + _line + " ")
 #endif
 #else // !defined(DEBUG)
 #define _this_location (ThreadName())
 #endif // defined(DEBUG)
 #define warn(x) Application::Console().Write(_this_location + std::string("[WARN] ") + (x))
 #define info(x) Application::Console().Write(_this_location + std::string("[INFO] ") + (x))
 #define error(x) Application::Console().Write(_this_location + std::string("[ERROR] ") + (x))
 #define luaprint(x) Application::Console().Write(_this_location + std::string("[LUA] ") + (x))
 #define debug(x)                                                                          \
    do {                                                                                  \
        if (Application::Settings.DebugModeEnabled) {                                     \
            Application::Console().Write(_this_location + std::string("[DEBUG] ") + (x)); \
        }                                                                                 \
    } while (false)
 #define Biggest 30000
 std::string Comp(std::string Data);
 std::string DeComp(std::string Compressed);
@@ -1,36 +0,0 @@
 #pragma once
 // ======================= UNIX ========================
 #ifdef __unix
 #include <arpa/inet.h>
 #include <sys/socket.h>
 #include <termios.h>
 #include <unistd.h>
 using SOCKET = int;
 using DWORD = unsigned long;
 using PDWORD = unsigned long*;
 using LPDWORD = unsigned long*;
 char _getch();
 inline void CloseSocketProper(int socket) {
    shutdown(socket, SHUT_RDWR);
    close(socket);
 }
 #endif // unix
 // ======================= WIN32 =======================
 #ifdef WIN32
 #include <conio.h>
 #include <winsock2.h>
 inline void CloseSocketProper(SOCKET socket) {
    shutdown(socket, SD_BOTH);
    closesocket(socket);
 }
 #endif // WIN32
 // ======================= OTHER =======================
 #if !defined(WIN32) && !defined(__unix)
 #error "OS not supported"
 #endif
@@ -1,68 +0,0 @@
 // Author: lionkor
 /*
 * Asserts are to be used anywhere where assumptions about state are made
 * implicitly. AssertNotReachable is used where code should never go, like in
 * default switch cases which shouldn't trigger. They make it explicit
 * that a place cannot normally be reached and make it an error if they do.
 */
 #pragma once
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <sstream>
 #include <thread>
 #include "Common.h"
 static const char* const ANSI_RESET = "\u001b[0m";
 static const char* const ANSI_BLACK = "\u001b[30m";
 static const char* const ANSI_RED = "\u001b[31m";
 static const char* const ANSI_GREEN = "\u001b[32m";
 static const char* const ANSI_YELLOW = "\u001b[33m";
 static const char* const ANSI_BLUE = "\u001b[34m";
 static const char* const ANSI_MAGENTA = "\u001b[35m";
 static const char* const ANSI_CYAN = "\u001b[36m";
 static const char* const ANSI_WHITE = "\u001b[37m";
 static const char* const ANSI_BLACK_BOLD = "\u001b[30;1m";
 static const char* const ANSI_RED_BOLD = "\u001b[31;1m";
 static const char* const ANSI_GREEN_BOLD = "\u001b[32;1m";
 static const char* const ANSI_YELLOW_BOLD = "\u001b[33;1m";
 static const char* const ANSI_BLUE_BOLD = "\u001b[34;1m";
 static const char* const ANSI_MAGENTA_BOLD = "\u001b[35;1m";
 static const char* const ANSI_CYAN_BOLD = "\u001b[36;1m";
 static const char* const ANSI_WHITE_BOLD = "\u001b[37;1m";
 static const char* const ANSI_BOLD = "\u001b[1m";
 static const char* const ANSI_UNDERLINE = "\u001b[4m";
 #if DEBUG
 #include <iostream>
 inline void _assert([[maybe_unused]] const char* file, [[maybe_unused]] const char* function, [[maybe_unused]] unsigned line,
    [[maybe_unused]] const char* condition_string, [[maybe_unused]] bool result) {
    if (!result) {
        std::cout << std::flush << "(debug build) TID "
                  << std::this_thread::get_id() << ": ASSERTION FAILED: at "
                  << file << ":" << line << " \n\t-> in "
                  << function << ", Line " << line << ": \n\t\t-> "
                  << "Failed Condition: " << condition_string << std::endl;
        std::cout << "... terminating ..." << std::endl;
        abort();
    }
 }
 #define Assert(cond) _assert(__FILE__, __func__, __LINE__, #cond, (cond))
 #define AssertNotReachable() _assert(__FILE__, __func__, __LINE__, "reached unreachable code", false)
 #else
 // In release build, these macros turn into NOPs. The compiler will optimize these out.
 #define Assert(x) \
    do {          \
    } while (false)
 #define AssertNotReachable() \
    do {                     \
    } while (false)
 #endif // DEBUG
@@ -1,9 +0,0 @@
 #pragma once
 #include <string>
 #include <unordered_map>
 namespace Http {
 std::string GET(const std::string& host, int port, const std::string& target);
 std::string POST(const std::string& host, const std::string& target, const std::unordered_map<std::string, std::string>& fields, const std::string& body, bool json);
 }
@@ -1,19 +0,0 @@
 #pragma once
 #include <thread>
 // pure virtual class to be inherited from by classes which intend to be threaded
 class IThreaded {
 public:
    IThreaded()
        // invokes operator() on this object
        : mThread() { }
    virtual void Start() final {
        mThread = std::thread([this] { (*this)(); });
    }
    virtual void operator()() = 0;
 protected:
    std::thread mThread;
 };
@@ -1,19 +0,0 @@
 // Author: lionkor
 #pragma once
 /*
 * An RWMutex allows multiple simultaneous readlocks but only one writelock at a time,
 * and write locks and read locks are mutually exclusive.
 */
 #include <shared_mutex>
 // Use ReadLock(m) and WriteLock(m) to lock it.
 using RWMutex = std::shared_mutex;
 // Construct with an RWMutex as a non-const reference.
 // locks the mutex in lock_shared mode (for reading). Locking in a thread that already owns a lock
 // i.e. locking multiple times successively is UB. Construction may be blocking. Destruction is guaranteed to release the lock.
 using ReadLock = std::shared_lock<RWMutex>;
 // Construct with an RWMutex as a non-const reference.
 // locks the mutex for writing. Construction may be blocking. Destruction is guaranteed to release the lock.
 using WriteLock = std::unique_lock<RWMutex>;
@@ -1,69 +0,0 @@
 #pragma once
 #include <atomic>
 #include <deque>
 #include <mutex>
 #include <sio_client.h>
 #include <thread>
 #include <memory>
 /*
 * We send relevant server events over socket.io to the backend.
 *
 * We send all events to `backend.beammp.com`, to the room `/key` 
 * where `key` is the currently active auth-key. 
 */
 enum class SocketIOEvent {
    ConsoleOut,
    CPUUsage,
    MemoryUsage,
    NetworkUsage,
    PlayerList,
 };
 enum class SocketIORoom {
    None,
    Stats,
    Player,
    Info,
    Console,
 };
 class SocketIO final {
 private:
    struct Event;
 public:
    enum class EventType {
    };
    // Singleton pattern
    static SocketIO& Get();
    void Emit(SocketIOEvent Event, const std::string& Data);
    ~SocketIO();
    void SetAuthenticated(bool auth) { mAuthenticated = auth; }
 private:
    SocketIO() noexcept;
    void ThreadMain();
    struct Event {
        std::string Name;
        std::string Data;
    };
    bool mAuthenticated { false };
    sio::client mClient;
    std::thread mThread;
    std::atomic_bool mCloseThread { false };
    std::mutex mQueueMutex;
    std::deque<Event> mQueue;
    friend std::unique_ptr<SocketIO> std::make_unique<SocketIO>();
 };
@@ -1,12 +0,0 @@
 #pragma once
 #include "Common.h"
 class TConfig {
 public:
    explicit TConfig(const std::string& ConfigFile);
 private:
    static std::string RemoveComments(const std::string& Line);
    static void SetValues(const std::string& Line, int Index);
 };
@@ -1,19 +0,0 @@
 #pragma once
 #include "commandline/commandline.h"
 #include "TLuaFile.h"
 #include <atomic>
 #include <fstream>
 class TConsole {
 public:
    TConsole();
    void Write(const std::string& str);
    void WriteRaw(const std::string& str);
    void InitializeLuaConsole(TLuaEngine& Engine);
 private:
    std::unique_ptr<TLuaFile> mLuaConsole { nullptr };
    Commandline mCommandline;
 };
@@ -1,21 +0,0 @@
 #pragma once
 #include "Common.h"
 #include "IThreaded.h"
 #include "TResourceManager.h"
 #include "TServer.h"
 class THeartbeatThread : public IThreaded {
 public:
    THeartbeatThread(TResourceManager& ResourceManager, TServer& Server);
    //~THeartbeatThread();
    void operator()() override;
 private:
    std::string GenerateCall();
    std::string GetPlayers();
    bool mShutdown = false;
    TResourceManager& mResourceManager;
    TServer& mServer;
 };
@@ -1,38 +0,0 @@
 #pragma once
 #include "Common.h"
 #include "IThreaded.h"
 #include "TLuaFile.h"
 #include "TServer.h"
 #include <lua.hpp>
 #include <memory>
 #include <optional>
 #include <set>
 class TLuaEngine : public IThreaded {
 public:
    explicit TLuaEngine(TServer& Server, TNetwork& Network);
    using TSetOfLuaFile = std::set<std::unique_ptr<TLuaFile>>;
    void operator()() override;
    [[nodiscard]] const TSetOfLuaFile& LuaFiles() const { return mLuaFiles; }
    [[nodiscard]] TServer& Server() { return mServer; }
    [[nodiscard]] const TServer& Server() const { return mServer; }
    [[nodiscard]] TNetwork& Network() { return mNetwork; }
    [[nodiscard]] const TNetwork& Network() const { return mNetwork; }
    std::optional<std::reference_wrapper<TLuaFile>> GetScript(lua_State* L);
 private:
    void FolderList(const std::string& Path, bool HotSwap);
    void RegisterFiles(const std::string& Path, bool HotSwap);
    bool NewFile(const std::string& Path);
    TNetwork& mNetwork;
    TServer& mServer;
    std::string mPath;
    bool mShutdown { false };
    TSetOfLuaFile mLuaFiles;
 };
@@ -1,61 +0,0 @@
 #ifndef TLUAFILE_H
 #define TLUAFILE_H
 #include <any>
 #include <filesystem>
 #include <lua.hpp>
 #include <mutex>
 #include <set>
 #include <string>
 #include <vector>
 namespace fs = std::filesystem;
 struct TLuaArg {
    std::vector<std::any> args;
    void PushArgs(lua_State* State);
 };
 class TLuaEngine;
 class TLuaFile {
 public:
    void RegisterEvent(const std::string& Event, const std::string& FunctionName);
    void UnRegisterEvent(const std::string& Event);
    void SetLastWrite(fs::file_time_type time);
    bool IsRegistered(const std::string& Event);
    void SetPluginName(const std::string& Name);
    void Execute(const std::string& Command);
    void SetFileName(const std::string& Name);
    fs::file_time_type GetLastWrite();
    lua_State* GetState();
    std::string GetOrigin();
    std::mutex Lock;
    void Reload();
    void Init(const std::string& PluginName, const std::string& FileName, fs::file_time_type LastWrote);
    explicit TLuaFile(TLuaEngine& Engine, bool Console = false);
    ~TLuaFile();
    void SetStopThread(bool StopThread) { mStopThread = StopThread; }
    TLuaEngine& Engine() { return mEngine; }
    [[nodiscard]] std::string GetPluginName() const;
    [[nodiscard]] std::string GetFileName() const;
    [[nodiscard]] const lua_State* GetState() const;
    [[nodiscard]] bool GetStopThread() const { return mStopThread; }
    [[nodiscard]] const TLuaEngine& Engine() const { return mEngine; }
    [[nodiscard]] std::string GetRegistered(const std::string& Event) const;
 private:
    TLuaEngine& mEngine;
    std::set<std::pair<std::string, std::string>> mRegisteredEvents;
    lua_State* mLuaState { nullptr };
    fs::file_time_type mLastWrote;
    std::string mPluginName {};
    std::string mFileName {};
    bool mStopThread = false;
    bool mConsole = false;
    void Load();
 };
 std::any TriggerLuaEvent(const std::string& Event, bool local, TLuaFile* Caller, std::shared_ptr<TLuaArg> arg, bool Wait);
 #endif // TLUAFILE_H
@@ -1,49 +0,0 @@
 #pragma once
 #include "Compat.h"
 #include "TResourceManager.h"
 #include "TServer.h"
 class TNetwork {
 public:
    TNetwork(TServer& Server, TPPSMonitor& PPSMonitor, TResourceManager& ResourceManager);
    [[nodiscard]] bool TCPSend(TClient& c, const std::string& Data, bool IsSync = false);
    [[nodiscard]] bool SendLarge(TClient& c, std::string Data, bool isSync = false);
    [[nodiscard]] bool Respond(TClient& c, const std::string& MSG, bool Rel, bool isSync = false);
    std::shared_ptr<TClient> CreateClient(SOCKET TCPSock);
    std::string TCPRcv(TClient& c);
    void ClientKick(TClient& c, const std::string& R);
    [[nodiscard]] bool SyncClient(const std::weak_ptr<TClient>& c);
    void Identify(SOCKET TCPSock);
    void Authentication(SOCKET TCPSock);
    [[nodiscard]] bool CheckBytes(TClient& c, int32_t BytesRcv);
    void SyncResources(TClient& c);
    [[nodiscard]] bool UDPSend(TClient& Client, std::string Data) const;
    void SendToAll(TClient* c, const std::string& Data, bool Self, bool Rel);
    void UpdatePlayer(TClient& Client);
 private:
    void UDPServerMain();
    void TCPServerMain();
    TServer& mServer;
    TPPSMonitor& mPPSMonitor;
    SOCKET mUDPSock {};
    bool mShutdown { false };
    TResourceManager& mResourceManager;
    std::thread mUDPThread;
    std::thread mTCPThread;
    std::string UDPRcvFromClient(sockaddr_in& client) const;
    void HandleDownload(SOCKET TCPSock);
    void OnConnect(const std::weak_ptr<TClient>& c);
    void TCPClient(const std::weak_ptr<TClient>& c);
    void Looper(const std::weak_ptr<TClient>& c);
    int OpenID();
    void OnDisconnect(const std::weak_ptr<TClient>& ClientPtr, bool kicked);
    void Parse(TClient& c, const std::string& Packet);
    void SendFile(TClient& c, const std::string& Name);
    static bool TCPSendRaw(SOCKET C, char* Data, int32_t Size);
    static void SplitLoad(TClient& c, size_t Sent, size_t Size, bool D, const std::string& Name);
 };
@@ -1,27 +0,0 @@
 #pragma once
 #include "Common.h"
 #include "TServer.h"
 #include <optional>
 class TNetwork;
 class TPPSMonitor : public IThreaded {
 public:
    explicit TPPSMonitor(TServer& Server);
    void operator()() override;
    void SetInternalPPS(int NewPPS) { mInternalPPS = NewPPS; }
    void IncrementInternalPPS() { ++mInternalPPS; }
    [[nodiscard]] int InternalPPS() const { return mInternalPPS; }
    void SetNetwork(TNetwork& Server) { mNetwork = std::ref(Server); }
 private:
    TNetwork& Network() { return mNetwork->get(); }
    TServer& mServer;
    std::optional<std::reference_wrapper<TNetwork>> mNetwork { std::nullopt };
    bool mShutdown { false };
    int mInternalPPS { 0 };
 };
@@ -1,21 +0,0 @@
 #pragma once
 #include "Common.h"
 class TResourceManager {
 public:
    TResourceManager();
    [[nodiscard]] size_t MaxModSize() const { return mMaxModSize; }
    [[nodiscard]] std::string FileList() const { return mFileList; }
    [[nodiscard]] std::string TrimmedList() const { return mTrimmedList; }
    [[nodiscard]] std::string FileSizes() const { return mFileSizes; }
    [[nodiscard]] int ModsLoaded() const { return mModsLoaded; }
 private:
    size_t mMaxModSize = 0;
    std::string mFileSizes;
    std::string mFileList;
    std::string mTrimmedList;
    int mModsLoaded = 0;
 };
@@ -1,35 +0,0 @@
 #pragma once
 #include "IThreaded.h"
 #include "RWMutex.h"
 #include <functional>
 #include <memory>
 #include <mutex>
 #include <unordered_set>
 class TClient;
 class TNetwork;
 class TPPSMonitor;
 class TServer final {
 public:
    using TClientSet = std::unordered_set<std::shared_ptr<TClient>>;
    TServer(int argc, char** argv);
    void InsertClient(const std::shared_ptr<TClient>& Ptr);
    std::weak_ptr<TClient> InsertNewClient();
    void RemoveClient(const std::weak_ptr<TClient>&);
    // in Fn, return true to continue, return false to break
    void ForEachClient(const std::function<bool(std::weak_ptr<TClient>)>& Fn);
    size_t ClientCount() const;
    static void GlobalParser(const std::weak_ptr<TClient>& Client, std::string Packet, TPPSMonitor& PPSMonitor, TNetwork& Network);
    static void HandleEvent(TClient& c, const std::string& Data);
    RWMutex& GetClientMutex() const { return mClientsMutex; }
 private:
    TClientSet mClients;
    mutable RWMutex mClientsMutex;
    static void ParseVehicle(TClient& c, const std::string& Pckt, TNetwork& Network);
    static void Apply(TClient& c, int VID, const std::string& pckt);
 };
@@ -1,30 +0,0 @@
 #pragma once
 #include <string>
 class TVehicleData final {
 public:
    TVehicleData(int ID, std::string Data);
    ~TVehicleData();
    [[nodiscard]] bool IsInvalid() const { return mID == -1; }
    [[nodiscard]] int ID() const { return mID; }
    [[nodiscard]] std::string Data() const { return mData; }
    void SetData(const std::string& Data) const { mData = Data; }
    bool operator==(const TVehicleData& v) const { return mID == v.mID; }
 private:
    int mID { -1 };
    mutable std::string mData;
 };
 namespace std {
 template <>
 struct hash<TVehicleData> {
    std::size_t operator()(const TVehicleData& s) const noexcept {
        return s.ID();
    }
 };
 }
@@ -0,0 +1,345 @@
 // Server Settings!
 var map = "";
 let _VERSION = "0.0.3"
 let UDPExpireTime = 30// In Seconds
 const net = require('net');
 const uuidv4 = require('uuid/v4');
 const args = require('minimist')(process.argv.slice(2));
 const chalk = require("chalk")
 //console.log(args.port)
 if (args.port) {
  var tcpport = args.port;
 } else {
  var tcpport = 30813;
 }
 var udpport = tcpport + 1;
 var wsport = tcpport + 2;
 const host = '0.0.0.0';
 //==========================================================
 //              WebSocket Server
 //==========================================================
 const WebSocket = require('ws');
 const wss = new WebSocket.Server({ port: wsport });
 wss.on('connection', function connection(ws) {
  ws.on('message', function incoming(message) {
    console.log('[WS] received: %s', message);
    wss.clients.forEach(function each(client) {
      if (client.readyState === WebSocket.OPEN) {
        client.send(message);
      }
    });
  });
  ws.send('Welcome!');
 });
 console.log(chalk.cyan('[WS]')+'  Server listening on 0.0.0.0:' + wsport);
 //==========================================================
 //              TCP Server
 //==========================================================
 const TCPserver = net.createServer();
 TCPserver.listen(tcpport, () => {
  console.log(chalk.green('[TCP]')+' Server listening on 0.0.0.0:' + tcpport);
 });
 let sockets = [];
 let players = [];
 let names = [];
 let vehicles = [];
 TCPserver.on('connection', function(sock) {
  console.log(chalk.green('[TCP]')+' CONNECTED: ' + sock.remoteAddress + ':' + sock.remotePort);
  sockets.push(sock);
  var player = {};
  player.remoteAddress = sock.remoteAddress;
  player.remotePort = sock.remotePort;
  player.nickname = "New User, Loading...";
  player.id = uuidv4();
  player.currentVehID = 0;
  players.push(player);
  sock.write('HOLA'+player.id+'\n');
  if (map == "") {
    sock.write("MAPS\n");
  } else {
    sock.write("MAPC"+map+'\n')
  }
  sock.write("VCHK"+_VERSION+'\n')
  sock.on('data', function(data) {
    // Write the data back to all the connected, the client will receive it as data from the server
    var str = data.toString();
    data = str.trim(); //replace(/\r?\n|\r/g, "");
    var code = data.substring(0, 4);
    var message = data.substr(4);
    if (code != "PING") {
      //console.log(code)
  	}
  	//if (data.length > 4) {
  	  //console.log(data.length)
  	//}
    switch (code) {
      case "PING":
        //console.log("Ping Received")
        sock.write('PONG\n');
        break;
      case "CHAT":
        sockets.forEach(function(socket, index, array) { // Send update to all clients
          socket.write(data+'\n');
        });
        break;
      case "MAPS":
        map = message;
        console.log("Setting map to: "+map);
        sock.write("MAPC"+map+'\n');
        break;
      case "USER":
        players.forEach(function(player, index, array) {
          if (player.remoteAddress == sock.remoteAddress && player.remotePort == sock.remotePort) {
            console.log("Player Found ("+player.id+"), setting nickname("+data.substr(4)+")");
            player.nickname = ""+data.substr(4)+"";
            sockets.forEach(function(socket, index, array) { // Send update to all clients
              socket.write('PLST'+JSON.stringify(players)+'\n');
              socket.write('SMSG'+data.substr(4)+' Just Joined the Session.\n');
            });
          }
        });
        break;
      case "QUIT":
      case "2001":
        let index = sockets.findIndex(function(o) {
          return o.remoteAddress === sock.remoteAddress && o.remotePort === sock.remotePort;
        })
        if (index !== -1) sockets.splice(index, 1);
        console.log('CLOSED: ' + sock.remoteAddress + ' ' + sock.remotePort);
        break;
      case "U-VI":
      case "U-VE":
      case "U-VN":
      case "U-VP":
      case "U-VL":
      case "U-VR":
      case "U-VV":
        //console.log(data)
        //players.forEach(function(player, index, array) {
        //if (player.remoteAddress != sock.remoteAddress) {
        //console.log(player.remoteAddress+' != '+sock.remoteAddress+' Is not the same so we should send?')
        //console.log("Got Update to send!")
        sockets.forEach(function(socket, index, array) { // Send update to all clients
          //console.log(socket.remotePort+' != '+sock.remotePort+' Is not the same so we should send?')
          if ((sock.remoteAddress != socket.remoteAddress && sock.remotePort != socket.remotePort) || (sock.remoteAddress == socket.remoteAddress && sock.remotePort != socket.remotePort)) {
            socket.write(data+'\n');
          }
        });
        //}
        //});
        break;
      case "U-VC":
        sockets.forEach(function(socket, index, array) { // Send update to all clients
          socket.write(data+'\n');
        });
        break;
      case "U-NV":
        console.log(message)
        var vid = uuidv4();
        break;
      case "C-VS": // Client has changed vehicle. lets update our records.
        console.log(message)
        players.forEach(function(player, index, array) {
          if (player.currentVehID != message && player.remoteAddress == sock.remoteAddress && player.remotePort == sock.remotePort) {
            console.log(chalk.green('[TCP]')+" Player Found ("+player.id+"), updating current vehile("+message+")");
            player.currentVehID = message;
          }
        });
        break;
      default:
        console.log(chalk.green('[TCP]')+' Unknown / unhandled data from:' + sock.remoteAddress);
        console.log(chalk.green('[TCP]')+' Data -> ' + data);
        sockets.forEach(function(socket, index, array) { // Send update to all clients
          //if ((sock.remoteAddress != socket.remoteAddress && sock.remotePort != socket.remotePort) || (sock.remoteAddress == socket.remoteAddress && sock.remotePort != socket.remotePort)) {
            socket.write(data+'\n');
          //}
        });
        break;
    }
    sockets.forEach(function(sock, index, array) {
      //sock.write(sock.remoteAddress + ':' + sock.remotePort + " said " + data + '\n');
    });
  });
  // Add a 'close' event handler to this instance of socket
  sock.on('close', function(data) {
    var index = players.findIndex(function(o) {
      return o.remoteAddress === sock.remoteAddress && o.remotePort === sock.remotePort;
    })
    if (index !== -1) sockets.splice(index, 1);
     index = sockets.findIndex(function(o) {
      return o.remoteAddress === sock.remoteAddress && o.remotePort === sock.remotePort;
    })
    if (index !== -1) sockets.splice(index, 1);
    console.log('CLOSED: ' + sock.remoteAddress + ' ' + sock.remotePort);
    players = removePlayer(players, sock.remoteAddress);
    console.log("Player list now holds: "+JSON.stringify(players));
    sockets.forEach(function(socket, index, array) { // Send update to all clients
      socket.write('PLST'+JSON.stringify(players)+'\n');
    });
  });
  sock.on('error', (err) => {
    // handle errors here
    if (err.code == "ECONNRESET") {
      console.error(chalk.red("ERROR ")+"Connection Reset for player: ");
      players.forEach(function(player, index, array) {
        if (player.remoteAddress == sock.remoteAddress && player.remotePort == sock.remotePort) {
          console.error(+player.nickname+" ("+player.id+")");
          console.error(chalk.red("ERROR ")+"End Error.");
        }
      });
    } else {
      console.error("Sock Error");
      console.error(err);
      throw err;
    }
  });
 });
 TCPserver.on('error', (err) => {
  // handle errors here
  console.error("TCPserver Error");
  console.error(err);
  throw err;
 });
 function removePlayer(array, ip) {
  return array.filter(player => player.remoteAddress != ip);
 }
 //==========================================================
 //              UDP Server
 //==========================================================
 var clients = {};
 var intervalTime = UDPExpireTime*2*1000;
 setInterval(function() {
  console.log(clients);
  for (var client in clients) {
    var lastupdate = clients[client];
    var millis = Date.now() - lastupdate;
    var t = Math.floor(millis/1000)
    if (t > UDPExpireTime) {
      console.warn("Found Old Client: "+client)
      delete clients[client];
    }
  }
 }, intervalTime);
 function updateClient (rinfo) {
  for (var client in clients) {
    client = JSON.parse(client);
    var address = client[0];
    var port = client[1];
    if (port == rinfo.port && address == rinfo.address) {
      client
    }
  }
 }
 var dgram = require('dgram');
 var UDPserver = dgram.createSocket('udp4');
 function UDPsend(message, info) {
  UDPserver.send(message, 0, message.length, info.port, info.address, function(error){
    if (error) {
      console.log("ERROR");
      console.log(error);
      client.close();
    };
  });
 }
 UDPserver.on('listening', function() {
  var address = UDPserver.address();
  console.log(chalk.rgb(123, 45, 67)('[UDP]')+' Server listening on ' + address.address + ':' + address.port);
 });
 UDPserver.on('message',function(msg,rinfo){
  clients[JSON.stringify([rinfo.address, rinfo.port])] = Date.now();
  //sending msg
  var str = msg.toString();
  data = str.trim(); //replace(/\r?\n|\r/g, "");
  var code = data.substring(0, 4);
  //if (code != "PING") {
    //console.log(msg.toString());
  //}
  switch (code) {
    case "PING":
      UDPsend("PONG", rinfo)
      break;
    case "U-VC":
      for (var client in clients) {
        client = JSON.parse(client);
        var port = client[1];
        var address = client[0];
        UDPserver.send(msg, 0, msg.length, port, address, function(error){
          if (error) {
            console.log("ERROR");
            console.log(error);
            client.close();
          };
        });
      }
      break;
    case "U-VR":
    case "U-VL":
    case "U-VP":
    case "U-VN":
    case "U-VE":
    case "U-VI":
      for (var client in clients) {
        client = JSON.parse(client);
        var port = client[1];
        var address = client[0];
        if (port != rinfo.port && address != rinfo.address) {
          UDPserver.send(msg, 0, msg.length, port, address, function(error){
            if (error) {
              console.log("ERROR");
              console.log(error);
              client.close();
            };
          });
        }
      }
      break;
    default:
      // Unhandled data, this at the moment includes the extra packets of vehicles so it needs to be here until it is handled correctly
      for (var client in clients) {
        client = JSON.parse(client);
        var port = client[1];
        var address = client[0];
        UDPserver.send(msg, 0, msg.length, port, address, function(error){
          if (error) {
            console.log("ERROR");
            console.log(error);
            client.close();
          };
        });
      }
      //console.log(chalk.rgb(123, 45, 67)('[UDP]')+' Data received from client : ' + msg.toString());
      //console.log(chalk.rgb(123, 45, 67)('[UDP]')+' Received %d bytes from %s:%d\n',msg.length, rinfo.address, rinfo.port);
  }
 });
 UDPserver.bind(Number(udpport));
@@ -0,0 +1,20 @@
 {
  "name": "beamng.drive-mp-server",
  "version": "1.0.0",
  "description": "",
  "main": "main.js",
  "scripts": {
    "start": "electron ."
  },
  "author": "Mitch Durso",
  "license": "ISC",
  "devDependencies": {
    "electron": "^6.0.7"
  },
  "dependencies": {
    "chalk": "^3.0.0",
    "minimist": "^1.2.0",
    "uuid": "^3.3.3",
    "ws": "^7.2.1"
  }
 }
@@ -1,91 +0,0 @@
 #include "Client.h"
 #include "CustomAssert.h"
 #include <memory>
 // FIXME: add debug prints
 void TClient::DeleteCar(int Ident) {
    for (auto& v : mVehicleData) {
        if (v.ID() == Ident) {
            mVehicleData.erase(v);
            break;
        }
    }
 }
 void TClient::ClearCars() {
    mVehicleData.clear();
 }
 int TClient::GetOpenCarID() const {
    int OpenID = 0;
    bool found;
    do {
        found = true;
        for (auto& v : mVehicleData) {
            if (v.ID() == OpenID) {
                OpenID++;
                found = false;
            }
        }
    } while (!found);
    return OpenID;
 }
 void TClient::AddNewCar(int Ident, const std::string& Data) {
    mVehicleData.emplace(Ident, Data);
 }
 TClient::TVehicleDataLockPair TClient::GetAllCars() {
    return { mVehicleData, std::unique_lock(mVehicleDataMutex) };
 }
 std::string TClient::GetCarData(int Ident) {
    for (auto& v : mVehicleData) {
        if (v.ID() == Ident) {
            return v.Data();
        }
    }
    DeleteCar(Ident);
    return "";
 }
 void TClient::SetCarData(int Ident, const std::string& Data) {
    for (auto& v : mVehicleData) {
        if (v.ID() == Ident) {
            v.SetData(Data);
            return;
        }
    }
    DeleteCar(Ident);
 }
 int TClient::GetCarCount() const {
    return int(mVehicleData.size());
 }
 TServer& TClient::Server() const {
    return mServer;
 }
 void TClient::EnqueuePacket(const std::string& Packet) {
    std::unique_lock Lock(mMissedPacketsMutex);
    mMissedPacketsDuringSyncing.push(Packet);
 }
 TClient::TClient(TServer& Server)
    : mServer(Server)
    , mLastPingTime(std::chrono::high_resolution_clock::now()) {
 }
 void TClient::UpdatePingTime() {
    mLastPingTime = std::chrono::high_resolution_clock::now();
    //debug(GetName() + ": " + std::string("ping time updated!: ") + ((SecondsSinceLastPing() == 0) ? "OK" : "ERR"));
 }
 int TClient::SecondsSinceLastPing() {
    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(
        std::chrono::high_resolution_clock::now() - mLastPingTime)
                       .count();
    return int(seconds);
 }
@@ -1,88 +0,0 @@
 #include "Common.h"
 #include "TConsole.h"
 #include <array>
 #include <iostream>
 #include <map>
 #include <thread>
 #include <zlib.h>
 std::unique_ptr<TConsole> Application::mConsole = std::make_unique<TConsole>();
 void Application::RegisterShutdownHandler(const TShutdownHandler& Handler) {
    std::unique_lock Lock(mShutdownHandlersMutex);
    if (Handler) {
        mShutdownHandlers.push_front(Handler);
    }
 }
 void Application::GracefullyShutdown() {
    info("please wait while all subsystems are shutting down...");
    std::unique_lock Lock(mShutdownHandlersMutex);
    for (auto& Handler : mShutdownHandlers) {
        Handler();
    }
 }
 std::string Comp(std::string Data) {
    std::array<char, Biggest> C {};
    // obsolete
    C.fill(0);
    z_stream defstream;
    defstream.zalloc = Z_NULL;
    defstream.zfree = Z_NULL;
    defstream.opaque = Z_NULL;
    defstream.avail_in = (uInt)Data.length();
    defstream.next_in = (Bytef*)&Data[0];
    defstream.avail_out = Biggest;
    defstream.next_out = reinterpret_cast<Bytef*>(C.data());
    deflateInit(&defstream, Z_BEST_COMPRESSION);
    deflate(&defstream, Z_SYNC_FLUSH);
    deflate(&defstream, Z_FINISH);
    deflateEnd(&defstream);
    size_t TO = defstream.total_out;
    std::string Ret(TO, 0);
    std::copy_n(C.begin(), TO, Ret.begin());
    return Ret;
 }
 std::string DeComp(std::string Compressed) {
    std::array<char, Biggest> C {};
    // not needed
    C.fill(0);
    z_stream infstream;
    infstream.zalloc = Z_NULL;
    infstream.zfree = Z_NULL;
    infstream.opaque = Z_NULL;
    infstream.avail_in = Biggest;
    infstream.next_in = (Bytef*)(&Compressed[0]);
    infstream.avail_out = Biggest;
    infstream.next_out = (Bytef*)(C.data());
    inflateInit(&infstream);
    inflate(&infstream, Z_SYNC_FLUSH);
    inflate(&infstream, Z_FINISH);
    inflateEnd(&infstream);
    size_t TO = infstream.total_out;
    std::string Ret(TO, 0);
    std::copy_n(C.begin(), TO, Ret.begin());
    return Ret;
 }
 // thread name stuff
 std::map<std::thread::id, std::string> threadNameMap;
 std::string ThreadName() {
    if (Application::Settings.DebugModeEnabled) {
        auto id = std::this_thread::get_id();
        if (threadNameMap.find(id) != threadNameMap.end()) {
            // found
            return threadNameMap.at(id) + " ";
        }
    }
    return "";
 }
 void RegisterThread(const std::string str) {
    threadNameMap[std::this_thread::get_id()] = str;
 }
@@ -1,35 +0,0 @@
 #include "Compat.h"
 #ifndef WIN32
 static struct termios old, current;
 void initTermios(int echo) {
    tcgetattr(0, &old); /* grab old terminal i/o settings */
    current = old; /* make new settings same as old settings */
    current.c_lflag &= ~ICANON; /* disable buffered i/o */
    if (echo) {
        current.c_lflag |= ECHO; /* set echo mode */
    } else {
        current.c_lflag &= ~ECHO; /* set no echo mode */
    }
    tcsetattr(0, TCSANOW, &current); /* use these new terminal i/o settings now */
 }
 void resetTermios(void) {
    tcsetattr(0, TCSANOW, &old);
 }
 char getch_(int echo) {
    char ch;
    initTermios(echo);
    read(STDIN_FILENO, &ch, 1);
    resetTermios();
    return ch;
 }
 char _getch(void) {
    return getch_(0);
 }
 #endif // !WIN32
@@ -1,145 +0,0 @@
 #include "Http.h"
 #include "Common.h"
 #undef error
 #include <boost/asio/connect.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/beast.hpp>
 #include <boost/beast/ssl.hpp>
 namespace beast = boost::beast; // from <boost/beast.hpp>
 namespace http = beast::http; // from <boost/beast/http.hpp>
 namespace net = boost::asio; // from <boost/asio.hpp>
 namespace ssl = net::ssl; // from <boost/asio/ssl.hpp>
 using tcp = net::ip::tcp; // from <boost/asio/ip/tcp.hpp>
 std::string Http::GET(const std::string& host, int port, const std::string& target) {
    // FIXME: doesn't support https
    // if it causes issues, yell at me and I'll fix it asap. - Lion
    try {
        net::io_context io;
        tcp::resolver resolver(io);
        beast::tcp_stream stream(io);
        auto const results = resolver.resolve(host, std::to_string(port));
        stream.connect(results);
        http::request<http::string_body> req { http::verb::get, target, 11 /* http 1.1 */ };
        req.set(http::field::host, host);
        // tell the server what we are (boost beast)
        req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);
        http::write(stream, req);
        // used for reading
        beast::flat_buffer buffer;
        http::response<http::string_body> response;
        http::read(stream, buffer, response);
        std::string result(response.body());
        beast::error_code ec;
        stream.socket().shutdown(tcp::socket::shutdown_both, ec);
        if (ec && ec != beast::errc::not_connected) {
            throw beast::system_error { ec }; // goes down to `return "-1"` anyways
        }
        return result;
    } catch (const std::exception& e) {
        Application::Console().Write(e.what());
        return "-1";
    }
 }
 std::string Http::POST(const std::string& host, const std::string& target, const std::unordered_map<std::string, std::string>& fields, const std::string& body, bool json) {
    try {
        net::io_context io;
        // The SSL context is required, and holds certificates
        ssl::context ctx(ssl::context::tlsv13);
        ctx.set_verify_mode(ssl::verify_none);
        tcp::resolver resolver(io);
        beast::ssl_stream<beast::tcp_stream> stream(io, ctx);
        decltype(resolver)::results_type results;
        auto try_connect_with_protocol = [&](tcp protocol) {
            try {
                results = resolver.resolve(protocol, host, std::to_string(443));
                if (!SSL_set_tlsext_host_name(stream.native_handle(), host.c_str())) {
                    boost::system::error_code ec { static_cast<int>(::ERR_get_error()), boost::asio::error::get_ssl_category() };
                    // FIXME: we could throw and crash, if we like
                    // throw boost::system::system_error { ec };
                    //debug("POST " + host + target + " failed.");
                    return false;
                }
                beast::get_lowest_layer(stream).connect(results);
            } catch (const boost::system::system_error&) {
                return false;
            }
            return true;
        };
        //bool ok = try_connect_with_protocol(tcp::v6());
        //if (!ok) {
        //debug("IPv6 connect failed, trying IPv4");
        bool ok = try_connect_with_protocol(tcp::v4());
        if (!ok) {
            //error("failed to resolve or connect in POST " + host + target);
            return "-1";
        }
        //}
        stream.handshake(ssl::stream_base::client);
        http::request<http::string_body> req { http::verb::post, target, 11 /* http 1.1 */ };
        req.set(http::field::host, host);
        if (!body.empty()) {
            if (json) {
                // FIXME: json is untested.
                req.set(http::field::content_type, "application/json");
            } else {
                req.set(http::field::content_type, "application/x-www-form-urlencoded");
            }
            req.set(http::field::content_length, std::to_string(body.size()));
            req.body() = body;
            // info("body is " + body + " (" + req.body() + ")");
            // info("content size is " + std::to_string(body.size()) + " (" + boost::lexical_cast<std::string>(body.size()) + ")");
        }
        for (const auto& pair : fields) {
            // info("setting " + pair.first + " to " + pair.second);
            req.set(pair.first, pair.second);
        }
        std::stringstream oss;
        oss << req;
        beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(5));
        http::write(stream, req);
        // used for reading
        beast::flat_buffer buffer;
        http::response<http::string_body> response;
        http::read(stream, buffer, response);
        std::stringstream result;
        result << response;
        beast::error_code ec;
        stream.shutdown(ec);
        // IGNORING ec
        // info(result.str());
        std::string debug_response_str;
        std::getline(result, debug_response_str);
        //debug("POST " + host + target + ": " + debug_response_str);
        return std::string(response.body());
    } catch (const std::exception& e) {
        Application::Console().Write(e.what());
        return "-1";
    }
 }
@@ -1,98 +0,0 @@
 #include "SocketIO.h"
 #include "Common.h"
 #include <iostream>
 //TODO Default disabled with config option
 static std::unique_ptr<SocketIO> SocketIOInstance = std::make_unique<SocketIO>();
 SocketIO& SocketIO::Get() {
    return *SocketIOInstance;
 }
 SocketIO::SocketIO() noexcept
    : mThread([this] { ThreadMain(); }) {
    mClient.socket()->on("network", [&](sio::event&e) {
        if(e.get_message()->get_string() == "Welcome"){
            info("SocketIO Authenticated!");
            mAuthenticated = true;
        }
    });
    mClient.socket()->on("welcome", [&](sio::event&) {
        info("Got welcome from backend! Authenticating SocketIO...");
        mClient.socket()->emit("onInitConnection", Application::Settings.Key);
    });
    mClient.set_logs_quiet();
    mClient.set_reconnect_delay(10000);
    mClient.connect(Application::GetBackendUrlForSocketIO());
 }
 SocketIO::~SocketIO() {
    mCloseThread.store(true);
    mThread.join();
 }
 static constexpr auto EventNameFromEnum(SocketIOEvent Event) {
    switch (Event) {
    case SocketIOEvent::CPUUsage:
        return "cpu usage";
    case SocketIOEvent::MemoryUsage:
        return "memory usage";
    case SocketIOEvent::ConsoleOut:
        return "console out";
    case SocketIOEvent::NetworkUsage:
        return "network usage";
    case SocketIOEvent::PlayerList:
        return "player list";
    default:
        error("unreachable code reached (developer error)");
        abort();
    }
 }
 void SocketIO::Emit(SocketIOEvent Event, const std::string& Data) {
    if (!mAuthenticated) {
        debug("trying to emit a socket.io event when not yet authenticated");
        return;
    }
    std::string EventName = EventNameFromEnum(Event);
    debug("emitting event \"" + EventName + "\" with data: \"" + Data);
    std::unique_lock Lock(mQueueMutex);
    mQueue.push_back({EventName, Data });
    debug("queue now has " + std::to_string(mQueue.size()) + " events");
 }
 void SocketIO::ThreadMain() {
    while (!mCloseThread.load()) {
        bool empty;
        { // queue lock scope
            std::unique_lock Lock(mQueueMutex);
            empty = mQueue.empty();
        } // end queue lock scope
        if (empty || !mClient.opened()) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            continue;
        } else {
            Event TheEvent;
            { // queue lock scope
                std::unique_lock Lock(mQueueMutex);
                TheEvent = mQueue.front();
                mQueue.pop_front();
            } // end queue lock scope
            debug("sending \"" + TheEvent.Name + "\" event");
            mClient.socket()->emit(TheEvent.Name, TheEvent.Data);
            debug("sent \"" + TheEvent.Name + "\" event");
        }
    }
    // using std::cout as this happens during static destruction and the logger might be dead already
    std::cout << "closing " + std::string(__func__) << std::endl;
    mClient.sync_close();
    mClient.clear_con_listeners();
    std::cout << "closed" << std::endl;
 }
@@ -1,126 +0,0 @@
 #include "../include/TConfig.h"
 #include <fstream>
 TConfig::TConfig(const std::string& ConfigFile) {
    std::ifstream File(ConfigFile);
    if (File.good()) {
        std::string line;
        int index = 1;
        while (getline(File, line)) {
            index++;
        }
        if (index - 1 < 11) {
            error(("Outdated/Incorrect config please remove it server will close in 5 secs"));
            std::this_thread::sleep_for(std::chrono::seconds(3));
            _Exit(0);
        }
        File.close();
        File.open(("Server.cfg"));
        info(("Config found updating values"));
        index = 1;
        while (std::getline(File, line)) {
            if (line.rfind('#', 0) != 0 && line.rfind(' ', 0) != 0) { //Checks if it starts as Comment
                std::string CleanLine = RemoveComments(line); //Cleans it from the Comments
                SetValues(CleanLine, index); //sets the values
                index++;
            }
        }
    } else {
        info(("Config not found generating default"));
        std::ofstream FileStream;
        FileStream.open(ConfigFile);
        // TODO REPLACE THIS SHIT OMG
        FileStream << ("# This is the BeamMP Server Configuration File v0.60\n"
                       "Debug = false # true or false to enable debug console output\n"
                       "Private = true # Private?\n"
                       "Port = 30814 # Port to run the server on UDP and TCP\n"
                       "Cars = 1 # Max cars for every player\n"
                       "MaxPlayers = 10 # Maximum Amount of Clients\n"
                       "Map = \"/levels/gridmap/info.json\" # Default Map\n"
                       "Name = \"BeamMP New Server\" # Server Name\n"
                       "Desc = \"BeamMP Default Description\" # Server Description\n"
                       "use = \"Resources\" # Resource file name\n"
                       "AuthKey = \"\" # Auth Key");
        FileStream.close();
        error(("You are required to input the AuthKey"));
        std::this_thread::sleep_for(std::chrono::seconds(3));
        _Exit(0);
    }
    debug("Debug      : " + std::string(Application::Settings.DebugModeEnabled ? "true" : "false"));
    debug("Private    : " + std::string(Application::Settings.Private ? "true" : "false"));
    debug("Port       : " + std::to_string(Application::Settings.Port));
    debug("Max Cars   : " + std::to_string(Application::Settings.MaxCars));
    debug("MaxPlayers : " + std::to_string(Application::Settings.MaxPlayers));
    debug("MapName    : \"" + Application::Settings.MapName + "\"");
    debug("ServerName : \"" + Application::Settings.ServerName + "\"");
    debug("ServerDesc : \"" + Application::Settings.ServerDesc + "\"");
    debug("File       : \"" + Application::Settings.Resource + "\"");
    debug("Key length : " + std::to_string(Application::Settings.Key.length()) + "");
 }
 std::string TConfig::RemoveComments(const std::string& Line) {
    std::string Return;
    for (char c : Line) {
        if (c == '#')
            break;
        Return += c;
    }
    return Return;
 }
 void TConfig::SetValues(const std::string& Line, int Index) {
    int state = 0;
    std::string Data;
    bool Switch = false;
    if (Index > 5)
        Switch = true;
    for (char c : Line) {
        if (Switch) {
            if (c == '\"')
                state++;
            if (state > 0 && state < 2)
                Data += c;
        } else {
            if (c == ' ')
                state++;
            if (state > 1)
                Data += c;
        }
    }
    Data = Data.substr(1);
    std::string::size_type sz;
    bool FoundTrue = std::string(Data).find("true") != std::string::npos; //searches for "true"
    switch (Index) {
    case 1:
        Application::Settings.DebugModeEnabled = FoundTrue; //checks and sets the Debug Value
        break;
    case 2:
        Application::Settings.Private = FoundTrue; //checks and sets the Private Value
        break;
    case 3:
        Application::Settings.Port = std::stoi(Data, &sz); //sets the Port
        break;
    case 4:
        Application::Settings.MaxCars = std::stoi(Data, &sz); //sets the Max Car amount
        break;
    case 5:
        Application::Settings.MaxPlayers = std::stoi(Data, &sz); //sets the Max Amount of player
        break;
    case 6:
        Application::Settings.MapName = Data; //Map
        break;
    case 7:
        Application::Settings.ServerName = Data; //Name
        break;
    case 8:
        Application::Settings.ServerDesc = Data; //desc
        break;
    case 9:
        Application::Settings.Resource = Data; //File name
        break;
    case 10:
        Application::Settings.Key = Data; //File name
    default:
        break;
    }
 }
@@ -1,78 +0,0 @@
 #include "TConsole.h"
 #include "Common.h"
 #include "Compat.h"
 #include <ctime>
 #include <sstream>
 std::string GetDate() {
    std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
    time_t tt = std::chrono::system_clock::to_time_t(now);
    tm local_tm {};
 #ifdef WIN32
    localtime_s(&local_tm, &tt);
 #else // unix
    localtime_r(&tt, &local_tm);
 #endif // WIN32
    std::stringstream date;
    int S = local_tm.tm_sec;
    int M = local_tm.tm_min;
    int H = local_tm.tm_hour;
    std::string Secs = (S > 9 ? std::to_string(S) : "0" + std::to_string(S));
    std::string Min = (M > 9 ? std::to_string(M) : "0" + std::to_string(M));
    std::string Hour = (H > 9 ? std::to_string(H) : "0" + std::to_string(H));
    date
        << "["
        << local_tm.tm_mday << "/"
        << local_tm.tm_mon + 1 << "/"
        << local_tm.tm_year + 1900 << " "
        << Hour << ":"
        << Min << ":"
        << Secs
        << "] ";
    /* TODO
    if (Debug) {
        date << ThreadName()
             << " ";
    }
    */
    return date.str();
 }
 TConsole::TConsole() {
    mCommandline.enable_history();
    mCommandline.set_history_limit(20);
    mCommandline.set_prompt("> ");
    bool success = mCommandline.enable_write_to_file("Server.log");
    if (!success) {
        error("unable to open file for writing: \"Server.log\"");
    }
    mCommandline.on_command = [this](Commandline& c) {
        auto cmd = c.get_command();
        mCommandline.write("> " + cmd);
        if (cmd == "exit") {
            info("gracefully shutting down");
            Application::GracefullyShutdown();
        } else if (cmd == "clear" || cmd == "cls") {
            // TODO: clear screen
        } else {
            if (mLuaConsole) {
                mLuaConsole->Execute(cmd);
            } else {
                error("Lua subsystem not yet initialized, please wait a few seconds and try again");
            }
        }
    };
 }
 void TConsole::Write(const std::string& str) {
    auto ToWrite = GetDate() + str;
    mCommandline.write(ToWrite);
    // TODO write to logfile, too
 }
 void TConsole::InitializeLuaConsole(TLuaEngine& Engine) {
    mLuaConsole = std::make_unique<TLuaFile>(Engine, true);
 }
 void TConsole::WriteRaw(const std::string& str) {
    mCommandline.write(str);
 }
@@ -1,111 +0,0 @@
 #include "THeartbeatThread.h"
 #include "Client.h"
 #include "Http.h"
 //#include "SocketIO.h"
 #include <sstream>
 void THeartbeatThread::operator()() {
    RegisterThread("Heartbeat");
    std::string Body;
    std::string T;
    // these are "hot-change" related variables
    static std::string Last;
    static std::chrono::high_resolution_clock::time_point LastNormalUpdateTime = std::chrono::high_resolution_clock::now();
    bool isAuth = false;
    while (!mShutdown) {
        Body = GenerateCall();
        // a hot-change occurs when a setting has changed, to update the backend of that change.
        auto Now = std::chrono::high_resolution_clock::now();
        bool Unchanged = Last == Body;
        auto TimePassed = (Now - LastNormalUpdateTime);
        auto Threshold = Unchanged ? 30 : 5;
        if (TimePassed < std::chrono::seconds(Threshold)) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            continue;
        }
 #ifdef DEBUG
        debug("heartbeat @ " + std::to_string(std::chrono::duration_cast<std::chrono::seconds>(TimePassed).count()));
 #endif // DEBUG
        Last = Body;
        LastNormalUpdateTime = Now;
        if (!Application::Settings.CustomIP.empty())
            Body += "&ip=" + Application::Settings.CustomIP;
        Body += "&pps=" + Application::PPS();
        T = Http::POST(Application::GetBackendHostname(), "/heartbeat", {}, Body, false);
        if (T.substr(0, 2) != "20") {
            //Backend system refused server startup!
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
            T = Http::POST(Application::GetBackendHostname(), "/heartbeat", {}, Body, false);
            // TODO backup2 + HTTP flag (no TSL)
            if (T.substr(0, 2) != "20") {
                warn("Backend system refused server! Server might not show in the public list");
                debug("server returned \"" + T + "\"");
                isAuth = false;
            }
        }
        if (!isAuth) {
            if (T == "2000") {
                info(("Authenticated!"));
                isAuth = true;
            } else if (T == "200") {
                info(("Resumed authenticated session!"));
                isAuth = true;
            }
        }
        //SocketIO::Get().SetAuthenticated(isAuth);
    }
 }
 std::string THeartbeatThread::GenerateCall() {
    std::stringstream Ret;
    Ret << "uuid=" << Application::Settings.Key
        << "&players=" << mServer.ClientCount()
        << "&maxplayers=" << Application::Settings.MaxPlayers
        << "&port=" << Application::Settings.Port
        << "&map=" << Application::Settings.MapName
        << "&private=" << (Application::Settings.Private ? "true" : "false")
        << "&version=" << Application::ServerVersion()
        << "&clientversion=" << Application::ClientVersion()
        << "&name=" << Application::Settings.ServerName
        << "&modlist=" << mResourceManager.TrimmedList()
        << "&modstotalsize=" << mResourceManager.MaxModSize()
        << "&modstotal=" << mResourceManager.ModsLoaded()
        << "&playerslist=" << GetPlayers()
        << "&desc=" << Application::Settings.ServerDesc;
    return Ret.str();
 }
 THeartbeatThread::THeartbeatThread(TResourceManager& ResourceManager, TServer& Server)
    : mResourceManager(ResourceManager)
    , mServer(Server) {
    Application::RegisterShutdownHandler([&] {
        if (mThread.joinable()) {
            debug("shutting down Heartbeat");
            mShutdown = true;
            mThread.join();
            debug("shut down Heartbeat");
        }
    });
    Start();
 }
 std::string THeartbeatThread::GetPlayers() {
    std::string Return;
    mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
        ReadLock Lock(mServer.GetClientMutex());
        if (!ClientPtr.expired()) {
            Return += ClientPtr.lock()->GetName() + ";";
        }
        return true;
    });
    return Return;
 }
 /*THeartbeatThread::~THeartbeatThread() {
 }*/
@@ -1,103 +0,0 @@
 #include "TLuaEngine.h"
 #include "TLuaFile.h"
 #include <filesystem>
 #include <sys/stat.h>
 namespace fs = std::filesystem;
 // necessary as lua relies on global state
 TLuaEngine* TheEngine;
 TLuaEngine::TLuaEngine(TServer& Server, TNetwork& Network)
    : mNetwork(Network)
    , mServer(Server) {
    TheEngine = this;
    if (!fs::exists(Application::Settings.Resource)) {
        fs::create_directory(Application::Settings.Resource);
    }
    std::string Path = Application::Settings.Resource + ("/Server");
    if (!fs::exists(Path)) {
        fs::create_directory(Path);
    }
    FolderList(Path, false);
    mPath = Path;
    Application::RegisterShutdownHandler([&] {if (mThread.joinable()) {
        debug("shutting down LuaEngine");
        mShutdown = true;
        mThread.join();
        debug("shut down LuaEngine");
    } });
    Start();
 }
 void TLuaEngine::operator()() {
    RegisterThread("LuaEngine");
    info("Lua system online");
    while (!mShutdown) {
        if (!mLuaFiles.empty()) {
            for (auto& Script : mLuaFiles) {
                struct stat Info { };
                if (stat(Script->GetFileName().c_str(), &Info) != 0) {
                    Script->SetStopThread(true);
                    mLuaFiles.erase(Script);
                    info(("[HOTSWAP] Removed removed script due to delete"));
                    break;
                }
                if (Script->GetLastWrite() != fs::last_write_time(Script->GetFileName())) {
                    Script->SetStopThread(true);
                    info(("[HOTSWAP] Updated Scripts due to edit"));
                    Script->SetLastWrite(fs::last_write_time(Script->GetFileName()));
                    Script->Reload();
                }
            }
        }
        FolderList(mPath, true);
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }
 }
 std::optional<std::reference_wrapper<TLuaFile>> TLuaEngine::GetScript(lua_State* L) {
    for (auto& Script : mLuaFiles) {
        if (Script->GetState() == L)
            return *Script;
    }
    return std::nullopt;
 }
 void TLuaEngine::FolderList(const std::string& Path, bool HotSwap) {
    for (const auto& entry : fs::directory_iterator(Path)) {
        auto pos = entry.path().filename().string().find('.');
        if (pos == std::string::npos) {
            RegisterFiles(entry.path().string(), HotSwap);
        }
    }
 }
 void TLuaEngine::RegisterFiles(const std::string& Path, bool HotSwap) {
    std::string Name = Path.substr(Path.find_last_of('\\') + 1);
    if (!HotSwap)
        info(("Loading plugin : ") + Name);
    for (const auto& entry : fs::directory_iterator(Path)) {
        auto pos = entry.path().string().find((".lua"));
        if (pos != std::string::npos && entry.path().string().length() - pos == 4) {
            if (!HotSwap || NewFile(entry.path().string())) {
                auto FileName = entry.path().string();
                std::unique_ptr<TLuaFile> ScriptToInsert(new TLuaFile(*this));
                auto& Script = *ScriptToInsert;
                mLuaFiles.insert(std::move(ScriptToInsert));
                Script.Init(Name, FileName, fs::last_write_time(FileName));
                if (HotSwap)
                    info(("[HOTSWAP] Added : ") + Script.GetFileName().substr(Script.GetFileName().find('\\')));
            }
        }
    }
 }
 bool TLuaEngine::NewFile(const std::string& Path) {
    for (auto& Script : mLuaFiles) {
        if (Path == Script->GetFileName())
            return false;
    }
    return true;
 }
@@ -1,790 +0,0 @@
 #include "TLuaFile.h"
 #include "Client.h"
 #include "Common.h"
 #include "CustomAssert.h"
 #include "TLuaEngine.h"
 #include "TNetwork.h"
 #include "TServer.h"
 #include <future>
 #include <thread>
 // TODO: REWRITE
 void SendError(TLuaEngine& Engine, lua_State* L, const std::string& msg);
 std::any CallFunction(TLuaFile* lua, const std::string& FuncName, std::shared_ptr<TLuaArg> Arg);
 std::any TriggerLuaEvent(TLuaEngine& Engine, const std::string& Event, bool local, TLuaFile* Caller, std::shared_ptr<TLuaArg> arg, bool Wait);
 extern TLuaEngine* TheEngine;
 static TLuaEngine& Engine() {
    Assert(TheEngine);
    return *TheEngine;
 }
 std::shared_ptr<TLuaArg> CreateArg(lua_State* L, int T, int S) {
    if (S > T)
        return nullptr;
    std::shared_ptr<TLuaArg> temp(new TLuaArg);
    for (int C = S; C <= T; C++) {
        if (lua_isstring(L, C)) {
            temp->args.emplace_back(std::string(lua_tostring(L, C)));
        } else if (lua_isinteger(L, C)) {
            temp->args.emplace_back(int(lua_tointeger(L, C)));
        } else if (lua_isboolean(L, C)) {
            temp->args.emplace_back(bool(lua_toboolean(L, C)));
        } else if (lua_isnumber(L, C)) {
            temp->args.emplace_back(float(lua_tonumber(L, C)));
        }
    }
    return temp;
 }
 void ClearStack(lua_State* L) {
    lua_settop(L, 0);
 }
 std::any Trigger(TLuaFile* lua, const std::string& R, std::shared_ptr<TLuaArg> arg) {
    RegisterThread(lua->GetFileName());
    std::lock_guard<std::mutex> lockGuard(lua->Lock);
    std::packaged_task<std::any(std::shared_ptr<TLuaArg>)> task([lua, R](std::shared_ptr<TLuaArg> arg) { return CallFunction(lua, R, arg); });
    std::future<std::any> f1 = task.get_future();
    std::thread t(std::move(task), arg);
    t.detach();
    auto status = f1.wait_for(std::chrono::seconds(5));
    if (status != std::future_status::timeout)
        return f1.get();
    SendError(lua->Engine(), lua->GetState(), R + " took too long to respond");
    return 0;
 }
 std::any FutureWait(TLuaFile* lua, const std::string& R, std::shared_ptr<TLuaArg> arg, bool Wait) {
    Assert(lua);
    std::packaged_task<std::any(std::shared_ptr<TLuaArg>)> task([lua, R](std::shared_ptr<TLuaArg> arg) { return Trigger(lua, R, arg); });
    std::future<std::any> f1 = task.get_future();
    std::thread t(std::move(task), arg);
    t.detach();
    int T = 0;
    if (Wait)
        T = 6;
    auto status = f1.wait_for(std::chrono::seconds(T));
    if (status != std::future_status::timeout)
        return f1.get();
    return 0;
 }
 std::any TriggerLuaEvent(const std::string& Event, bool local, TLuaFile* Caller, std::shared_ptr<TLuaArg> arg, bool Wait) {
    std::any R;
    std::string Type;
    int Ret = 0;
    for (auto& Script : Engine().LuaFiles()) {
        if (Script->IsRegistered(Event)) {
            if (local) {
                if (Script->GetPluginName() == Caller->GetPluginName()) {
                    R = FutureWait(Script.get(), Script->GetRegistered(Event), arg, Wait);
                    Type = R.type().name();
                    if (Type.find("int") != std::string::npos) {
                        if (std::any_cast<int>(R))
                            Ret++;
                    } else if (Event == "onPlayerAuth")
                        return R;
                }
            } else {
                R = FutureWait(Script.get(), Script->GetRegistered(Event), arg, Wait);
                Type = R.type().name();
                if (Type.find("int") != std::string::npos) {
                    if (std::any_cast<int>(R))
                        Ret++;
                } else if (Event == "onPlayerAuth")
                    return R;
            }
        }
    }
    return Ret;
 }
 bool ConsoleCheck(lua_State* L, int r) {
    if (r != LUA_OK) {
        std::string msg = lua_tostring(L, -1);
        warn(("_Console | ") + msg);
        return false;
    }
    return true;
 }
 bool CheckLua(lua_State* L, int r) {
    if (r != LUA_OK) {
        std::string msg = lua_tostring(L, -1);
        auto MaybeS = Engine().GetScript(L);
        if (MaybeS.has_value()) {
            TLuaFile& S = MaybeS.value();
            std::string a = fs::path(S.GetFileName()).filename().string();
            warn(a + " | " + msg);
            return false;
        }
        // What the fuck, what do we do?!
        AssertNotReachable();
    }
    return true;
 }
 int lua_RegisterEvent(lua_State* L) {
    int Args = lua_gettop(L);
    auto MaybeScript = Engine().GetScript(L);
    Assert(MaybeScript.has_value());
    TLuaFile& Script = MaybeScript.value();
    if (Args == 2 && lua_isstring(L, 1) && lua_isstring(L, 2)) {
        Script.RegisterEvent(lua_tostring(L, 1), lua_tostring(L, 2));
    } else
        SendError(Engine(), L, "RegisterEvent invalid argument count expected 2 got " + std::to_string(Args));
    return 0;
 }
 int lua_TriggerEventL(lua_State* L) {
    int Args = lua_gettop(L);
    auto MaybeScript = Engine().GetScript(L);
    Assert(MaybeScript.has_value());
    TLuaFile& Script = MaybeScript.value();
    if (Args > 0) {
        if (lua_isstring(L, 1)) {
            TriggerLuaEvent(lua_tostring(L, 1), true, &Script, CreateArg(L, Args, 2), false);
        } else
            SendError(Engine(), L, ("TriggerLocalEvent wrong argument [1] need string"));
    } else {
        SendError(Engine(), L, ("TriggerLocalEvent not enough arguments expected 1 got 0"));
    }
    return 0;
 }
 int lua_TriggerEventG(lua_State* L) {
    int Args = lua_gettop(L);
    auto MaybeScript = Engine().GetScript(L);
    Assert(MaybeScript.has_value());
    TLuaFile& Script = MaybeScript.value();
    if (Args > 0) {
        if (lua_isstring(L, 1)) {
            TriggerLuaEvent(lua_tostring(L, 1), false, &Script, CreateArg(L, Args, 2), false);
        } else
            SendError(Engine(), L, ("TriggerGlobalEvent wrong argument [1] need string"));
    } else
        SendError(Engine(), L, ("TriggerGlobalEvent not enough arguments"));
    return 0;
 }
 void SafeExecution(TLuaFile* lua, const std::string& FuncName) {
    lua_State* luaState = lua->GetState();
    lua_getglobal(luaState, FuncName.c_str());
    if (lua_isfunction(luaState, -1)) {
        int R = lua_pcall(luaState, 0, 0, 0);
        CheckLua(luaState, R);
    }
    ClearStack(luaState);
 }
 void ExecuteAsync(TLuaFile* lua, const std::string& FuncName) {
    std::lock_guard<std::mutex> lockGuard(lua->Lock);
    SafeExecution(lua, FuncName);
 }
 void CallAsync(TLuaFile* lua, const std::string& Func, int U) {
    RegisterThread(lua->GetFileName());
    lua->SetStopThread(false);
    int D = 1000 / U;
    while (!lua->GetStopThread()) {
        ExecuteAsync(lua, Func);
        std::this_thread::sleep_for(std::chrono::milliseconds(D));
    }
 }
 int lua_StopThread(lua_State* L) {
    auto MaybeScript = Engine().GetScript(L);
    Assert(MaybeScript.has_value());
    // ugly, but whatever, this is safe as fuck
    MaybeScript.value().get().SetStopThread(true);
    return 0;
 }
 int lua_CreateThread(lua_State* L) {
    int Args = lua_gettop(L);
    if (Args > 1) {
        if (lua_isstring(L, 1)) {
            std::string STR = lua_tostring(L, 1);
            if (lua_isinteger(L, 2) || lua_isnumber(L, 2)) {
                int U = int(lua_tointeger(L, 2));
                if (U > 0 && U < 501) {
                    auto MaybeScript = Engine().GetScript(L);
                    Assert(MaybeScript.has_value());
                    TLuaFile& Script = MaybeScript.value();
                    std::thread t1(CallAsync, &Script, STR, U);
                    t1.detach();
                } else
                    SendError(Engine(), L, ("CreateThread wrong argument [2] number must be between 1 and 500"));
            } else
                SendError(Engine(), L, ("CreateThread wrong argument [2] need number"));
        } else
            SendError(Engine(), L, ("CreateThread wrong argument [1] need string"));
    } else
        SendError(Engine(), L, ("CreateThread not enough arguments"));
    return 0;
 }
 int lua_Sleep(lua_State* L) {
    if (lua_isnumber(L, 1)) {
        int t = int(lua_tonumber(L, 1));
        std::this_thread::sleep_for(std::chrono::milliseconds(t));
    } else {
        SendError(Engine(), L, ("Sleep not enough arguments"));
        return 0;
    }
    return 1;
 }
 std::optional<std::weak_ptr<TClient>> GetClient(TServer& Server, int ID) {
    std::optional<std::weak_ptr<TClient>> MaybeClient { std::nullopt };
    Server.ForEachClient([&](std::weak_ptr<TClient> CPtr) -> bool {
        ReadLock Lock(Server.GetClientMutex());
        if (!CPtr.expired()) {
            auto C = CPtr.lock();
            if (C->GetID() == ID) {
                MaybeClient = CPtr;
                return false;
            }
        }
        return true;
    });
    return MaybeClient;
 }
 // CONTINUE
 int lua_isConnected(lua_State* L) {
    if (lua_isnumber(L, 1)) {
        int ID = int(lua_tonumber(L, 1));
        auto MaybeClient = GetClient(Engine().Server(), ID);
        if (MaybeClient && !MaybeClient.value().expired())
            lua_pushboolean(L, MaybeClient.value().lock()->IsConnected());
        else
            return 0;
    } else {
        SendError(Engine(), L, ("isConnected not enough arguments"));
        return 0;
    }
    return 1;
 }
 int lua_GetPlayerName(lua_State* L) {
    if (lua_isnumber(L, 1)) {
        int ID = int(lua_tonumber(L, 1));
        auto MaybeClient = GetClient(Engine().Server(), ID);
        if (MaybeClient && !MaybeClient.value().expired())
            lua_pushstring(L, MaybeClient.value().lock()->GetName().c_str());
        else
            return 0;
    } else {
        SendError(Engine(), L, ("GetPlayerName not enough arguments"));
        return 0;
    }
    return 1;
 }
 int lua_GetPlayerCount(lua_State* L) {
    lua_pushinteger(L, Engine().Server().ClientCount());
    return 1;
 }
 int lua_GetGuest(lua_State* L) {
    if (lua_isnumber(L, 1)) {
        int ID = int(lua_tonumber(L, 1));
        auto MaybeClient = GetClient(Engine().Server(), ID);
        if (MaybeClient && !MaybeClient.value().expired())
            lua_pushboolean(L, MaybeClient.value().lock()->IsGuest());
        else
            return 0;
    } else {
        SendError(Engine(), L, "GetGuest not enough arguments");
        return 0;
    }
    return 1;
 }
 int lua_GetAllPlayers(lua_State* L) {
    lua_newtable(L);
    Engine().Server().ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
        std::shared_ptr<TClient> Client;
        {
            ReadLock Lock(Engine().Server().GetClientMutex());
            if (ClientPtr.expired())
                return true;
            Client = ClientPtr.lock();
        }
        lua_pushinteger(L, Client->GetID());
        lua_pushstring(L, Client->GetName().c_str());
        lua_settable(L, -3);
        return true;
    });
    if (Engine().Server().ClientCount() == 0)
        return 0;
    return 1;
 }
 int lua_GetIdentifiers(lua_State* L) {
    if (lua_isnumber(L, 1)) {
        auto MaybeClient = GetClient(Engine().Server(), int(lua_tonumber(L, 1)));
        if (MaybeClient && !MaybeClient.value().expired()) {
            auto IDs = MaybeClient.value().lock()->GetIdentifiers();
            if (IDs.empty())
                return 0;
            lua_newtable(L);
            for (const std::string& ID : IDs) {
                lua_pushstring(L, ID.substr(0, ID.find(':')).c_str());
                lua_pushstring(L, ID.c_str());
                lua_settable(L, -3);
            }
        } else
            return 0;
    } else {
        SendError(Engine(), L, "lua_GetIdentifiers wrong arguments");
        return 0;
    }
    return 1;
 }
 int lua_GetCars(lua_State* L) {
    if (lua_isnumber(L, 1)) {
        int ID = int(lua_tonumber(L, 1));
        auto MaybeClient = GetClient(Engine().Server(), ID);
        if (MaybeClient && !MaybeClient.value().expired()) {
            auto Client = MaybeClient.value().lock();
            TClient::TSetOfVehicleData VehicleData;
            { // Vehicle Data Lock Scope
                auto LockedData = Client->GetAllCars();
                VehicleData = LockedData.VehicleData;
            } // End Vehicle Data Lock Scope
            if (VehicleData.empty())
                return 0;
            lua_newtable(L);
            for (const auto& v : VehicleData) {
                lua_pushinteger(L, v.ID());
                lua_pushstring(L, v.Data().substr(3).c_str());
                lua_settable(L, -3);
            }
        } else
            return 0;
    } else {
        SendError(Engine(), L, ("GetPlayerVehicles wrong arguments"));
        return 0;
    }
    return 1;
 }
 int lua_dropPlayer(lua_State* L) {
    int Args = lua_gettop(L);
    if (lua_isnumber(L, 1)) {
        int ID = int(lua_tonumber(L, 1));
        auto MaybeClient = GetClient(Engine().Server(), ID);
        if (!MaybeClient || MaybeClient.value().expired())
            return 0;
        std::string Reason;
        if (Args > 1 && lua_isstring(L, 2)) {
            Reason = std::string((" Reason : ")) + lua_tostring(L, 2);
        }
        auto c = MaybeClient.value().lock();
        Engine().Network().Respond(*c, "C:Server:You have been Kicked from the server! " + Reason, true);
        c->SetStatus(-2);
        info(("Closing socket due to kick"));
        CloseSocketProper(c->GetTCPSock());
    } else
        SendError(Engine(), L, ("DropPlayer not enough arguments"));
    return 0;
 }
 int lua_sendChat(lua_State* L) {
    if (lua_isinteger(L, 1) || lua_isnumber(L, 1)) {
        if (lua_isstring(L, 2)) {
            int ID = int(lua_tointeger(L, 1));
            if (ID == -1) {
                std::string Packet = "C:Server: " + std::string(lua_tostring(L, 2));
                Engine().Network().SendToAll(nullptr, Packet, true, true);
            } else {
                auto MaybeClient = GetClient(Engine().Server(), ID);
                if (MaybeClient && !MaybeClient.value().expired()) {
                    auto c = MaybeClient.value().lock();
                    if (!c->IsSynced())
                        return 0;
                    std::string Packet = "C:Server: " + std::string(lua_tostring(L, 2));
                    Engine().Network().Respond(*c, Packet, true);
                } else
                    SendError(Engine(), L, ("SendChatMessage invalid argument [1] invalid ID"));
            }
        } else
            SendError(Engine(), L, ("SendChatMessage invalid argument [2] expected string"));
    } else
        SendError(Engine(), L, ("SendChatMessage invalid argument [1] expected number"));
    return 0;
 }
 int lua_RemoveVehicle(lua_State* L) {
    int Args = lua_gettop(L);
    if (Args != 2) {
        SendError(Engine(), L, ("RemoveVehicle invalid argument count expected 2 got ") + std::to_string(Args));
        return 0;
    }
    if ((lua_isinteger(L, 1) || lua_isnumber(L, 1)) && (lua_isinteger(L, 2) || lua_isnumber(L, 2))) {
        int PID = int(lua_tointeger(L, 1));
        int VID = int(lua_tointeger(L, 2));
        auto MaybeClient = GetClient(Engine().Server(), PID);
        if (!MaybeClient || MaybeClient.value().expired()) {
            SendError(Engine(), L, ("RemoveVehicle invalid Player ID"));
            return 0;
        }
        auto c = MaybeClient.value().lock();
        if (!c->GetCarData(VID).empty()) {
            std::string Destroy = "Od:" + std::to_string(PID) + "-" + std::to_string(VID);
            Engine().Network().SendToAll(nullptr, Destroy, true, true);
            c->DeleteCar(VID);
        }
    } else
        SendError(Engine(), L, ("RemoveVehicle invalid argument expected number"));
    return 0;
 }
 int lua_HWID(lua_State* L) {
    lua_pushinteger(L, -1);
    return 1;
 }
 int lua_RemoteEvent(lua_State* L) {
    int Args = lua_gettop(L);
    if (Args != 3) {
        SendError(Engine(), L, ("TriggerClientEvent invalid argument count expected 3 got ") + std::to_string(Args));
        return 0;
    }
    if (!lua_isnumber(L, 1)) {
        SendError(Engine(), L, ("TriggerClientEvent invalid argument [1] expected number"));
        return 0;
    }
    if (!lua_isstring(L, 2)) {
        SendError(Engine(), L, ("TriggerClientEvent invalid argument [2] expected string"));
        return 0;
    }
    if (!lua_isstring(L, 3)) {
        SendError(Engine(), L, ("TriggerClientEvent invalid argument [3] expected string"));
        return 0;
    }
    int ID = int(lua_tointeger(L, 1));
    std::string Packet = "E:" + std::string(lua_tostring(L, 2)) + ":" + std::string(lua_tostring(L, 3));
    if (ID == -1)
        Engine().Network().SendToAll(nullptr, Packet, true, true);
    else {
        auto MaybeClient = GetClient(Engine().Server(), ID);
        if (!MaybeClient || MaybeClient.value().expired()) {
            SendError(Engine(), L, ("TriggerClientEvent invalid Player ID"));
            return 0;
        }
        auto c = MaybeClient.value().lock();
        Engine().Network().Respond(*c, Packet, true);
    }
    return 0;
 }
 int lua_ServerExit(lua_State* L) {
    if (lua_gettop(L) > 0) {
        if (lua_isnumber(L, 1)) {
            _Exit(int(lua_tointeger(L, 1)));
        }
    }
    _Exit(0);
 }
 int lua_Set(lua_State* L) {
    int Args = lua_gettop(L);
    if (Args != 2) {
        SendError(Engine(), L, ("set invalid argument count expected 2 got ") + std::to_string(Args));
        return 0;
    }
    if (!lua_isnumber(L, 1)) {
        SendError(Engine(), L, ("set invalid argument [1] expected number"));
        return 0;
    }
    auto MaybeSrc = Engine().GetScript(L);
    std::string Name;
    if (!MaybeSrc.has_value()) {
        Name = ("_Console");
    } else {
        Name = MaybeSrc.value().get().GetPluginName();
    }
    int C = int(lua_tointeger(L, 1));
    switch (C) {
    case 0: //debug
        if (lua_isboolean(L, 2)) {
            Application::Settings.DebugModeEnabled = lua_toboolean(L, 2);
            info(Name + (" | Debug -> ") + (Application::Settings.DebugModeEnabled ? "true" : "false"));
        } else
            SendError(Engine(), L, ("set invalid argument [2] expected boolean for ID : 0"));
        break;
    case 1: //private
        if (lua_isboolean(L, 2)) {
            Application::Settings.Private = lua_toboolean(L, 2);
            info(Name + (" | Private -> ") + (Application::Settings.Private ? "true" : "false"));
        } else
            SendError(Engine(), L, ("set invalid argument [2] expected boolean for ID : 1"));
        break;
    case 2: //max cars
        if (lua_isnumber(L, 2)) {
            Application::Settings.MaxCars = int(lua_tointeger(L, 2));
            info(Name + (" | MaxCars -> ") + std::to_string(Application::Settings.MaxCars));
        } else
            SendError(Engine(), L, ("set invalid argument [2] expected number for ID : 2"));
        break;
    case 3: //max players
        if (lua_isnumber(L, 2)) {
            Application::Settings.MaxPlayers = int(lua_tointeger(L, 2));
            info(Name + (" | MaxPlayers -> ") + std::to_string(Application::Settings.MaxPlayers));
        } else
            SendError(Engine(), L, ("set invalid argument [2] expected number for ID : 3"));
        break;
    case 4: //Map
        if (lua_isstring(L, 2)) {
            Application::Settings.MapName = lua_tostring(L, 2);
            info(Name + (" | MapName -> ") + Application::Settings.MapName);
        } else
            SendError(Engine(), L, ("set invalid argument [2] expected string for ID : 4"));
        break;
    case 5: //Name
        if (lua_isstring(L, 2)) {
            Application::Settings.ServerName = lua_tostring(L, 2);
            info(Name + (" | ServerName -> ") + Application::Settings.ServerName);
        } else
            SendError(Engine(), L, ("set invalid argument [2] expected string for ID : 5"));
        break;
    case 6: //Desc
        if (lua_isstring(L, 2)) {
            Application::Settings.ServerDesc = lua_tostring(L, 2);
            info(Name + (" | ServerDesc -> ") + Application::Settings.ServerDesc);
        } else
            SendError(Engine(), L, ("set invalid argument [2] expected string for ID : 6"));
        break;
    default:
        warn(("Invalid config ID : ") + std::to_string(C));
        break;
    }
    return 0;
 }
 extern "C" {
 int lua_Print(lua_State* L) {
    int Arg = lua_gettop(L);
    std::string to_print;
    for (int i = 1; i <= Arg; i++) {
        if (lua_isstring(L, i)) {
            to_print += lua_tostring(L, i);
        } else if (lua_isinteger(L, i)) {
            to_print += std::to_string(lua_tointeger(L, 1));
        } else if (lua_isnumber(L, i)) {
            to_print += std::to_string(lua_tonumber(L, 1));
        } else if (lua_isboolean(L, i)) {
            to_print += lua_toboolean(L, i) ? "true" : "false";
        } else if (lua_isfunction(L, i)) {
            std::stringstream ss;
            ss << std::hex << reinterpret_cast<const void*>(lua_tocfunction(L, i));
            to_print += "function: " + ss.str();
        } else if (lua_istable(L, i)) {
            std::stringstream ss;
            ss << std::hex << reinterpret_cast<const void*>(lua_topointer(L, i));
            to_print += "table: " + ss.str();
        } else if (lua_isnoneornil(L, i)) {
            to_print += "nil";
        } else if (lua_isthread(L, i)) {
            std::stringstream ss;
            ss << std::hex << reinterpret_cast<const void*>(lua_tothread(L, i));
            to_print += "thread: " + ss.str();
        } else {
            to_print += "(unknown)";
        }
        if (i + 1 <= Arg) {
            to_print += "\t";
        }
    }
    luaprint(to_print);
    return 0;
 }
 }
 int lua_TempFix(lua_State* L);
 void TLuaFile::Init(const std::string& PluginName, const std::string& FileName, fs::file_time_type LastWrote) {
    // set global engine for lua_* functions
    if (!TheEngine) {
        TheEngine = &mEngine;
    }
    Assert(mLuaState);
    if (!PluginName.empty()) {
        SetPluginName(PluginName);
    }
    if (!FileName.empty()) {
        SetFileName(FileName);
    }
    SetLastWrite(LastWrote);
    Load();
 }
 TLuaFile::TLuaFile(TLuaEngine& Engine, bool Console)
    : mEngine(Engine)
    , mLuaState(luaL_newstate()) {
    if (Console) {
        mConsole = Console;
        Load();
    }
 }
 void TLuaFile::Execute(const std::string& Command) {
    if (ConsoleCheck(mLuaState, luaL_dostring(mLuaState, Command.c_str()))) {
        lua_settop(mLuaState, 0);
    }
 }
 void TLuaFile::Reload() {
    if (CheckLua(mLuaState, luaL_dofile(mLuaState, mFileName.c_str()))) {
        CallFunction(this, ("onInit"), nullptr);
    }
 }
 std::string TLuaFile::GetOrigin() {
    return fs::path(GetFileName()).filename().string();
 }
 std::any CallFunction(TLuaFile* lua, const std::string& FuncName, std::shared_ptr<TLuaArg> Arg) {
    RegisterThread(lua->GetFileName());
    lua_State* luaState = lua->GetState();
    lua_getglobal(luaState, FuncName.c_str());
    if (lua_isfunction(luaState, -1)) {
        int Size = 0;
        if (Arg != nullptr) {
            Size = int(Arg->args.size());
            Arg->PushArgs(luaState);
        }
        int R = lua_pcall(luaState, Size, 1, 0);
        if (CheckLua(luaState, R)) {
            if (lua_isnumber(luaState, -1)) {
                return int(lua_tointeger(luaState, -1));
            } else if (lua_isstring(luaState, -1)) {
                return std::string(lua_tostring(luaState, -1));
            }
        }
    }
    ClearStack(luaState);
    return 0;
 }
 void TLuaFile::SetPluginName(const std::string& Name) {
    mPluginName = Name;
 }
 void TLuaFile::SetFileName(const std::string& Name) {
    mFileName = Name;
 }
 void TLuaFile::Load() {
    Assert(mLuaState);
    luaL_openlibs(mLuaState);
    lua_register(mLuaState, "GetPlayerIdentifiers", lua_GetIdentifiers);
    lua_register(mLuaState, "TriggerGlobalEvent", lua_TriggerEventG);
    lua_register(mLuaState, "TriggerLocalEvent", lua_TriggerEventL);
    lua_register(mLuaState, "TriggerClientEvent", lua_RemoteEvent);
    lua_register(mLuaState, "GetPlayerCount", lua_GetPlayerCount);
    lua_register(mLuaState, "isPlayerConnected", lua_isConnected);
    lua_register(mLuaState, "RegisterEvent", lua_RegisterEvent);
    lua_register(mLuaState, "GetPlayerName", lua_GetPlayerName);
    lua_register(mLuaState, "RemoveVehicle", lua_RemoveVehicle);
    lua_register(mLuaState, "GetPlayerDiscordID", lua_TempFix);
    lua_register(mLuaState, "CreateThread", lua_CreateThread);
    lua_register(mLuaState, "GetPlayerVehicles", lua_GetCars);
    lua_register(mLuaState, "SendChatMessage", lua_sendChat);
    lua_register(mLuaState, "GetPlayers", lua_GetAllPlayers);
    lua_register(mLuaState, "GetPlayerGuest", lua_GetGuest);
    lua_register(mLuaState, "StopThread", lua_StopThread);
    lua_register(mLuaState, "DropPlayer", lua_dropPlayer);
    lua_register(mLuaState, "GetPlayerHWID", lua_HWID);
    lua_register(mLuaState, "exit", lua_ServerExit);
    lua_register(mLuaState, "Sleep", lua_Sleep);
    lua_register(mLuaState, "print", lua_Print);
    lua_register(mLuaState, "Set", lua_Set);
    if (!mConsole)
        Reload();
 }
 void TLuaFile::RegisterEvent(const std::string& Event, const std::string& FunctionName) {
    mRegisteredEvents.insert(std::make_pair(Event, FunctionName));
 }
 void TLuaFile::UnRegisterEvent(const std::string& Event) {
    for (const std::pair<std::string, std::string>& a : mRegisteredEvents) {
        if (a.first == Event) {
            mRegisteredEvents.erase(a);
            break;
        }
    }
 }
 bool TLuaFile::IsRegistered(const std::string& Event) {
    for (const std::pair<std::string, std::string>& a : mRegisteredEvents) {
        if (a.first == Event)
            return true;
    }
    return false;
 }
 std::string TLuaFile::GetRegistered(const std::string& Event) const {
    for (const std::pair<std::string, std::string>& a : mRegisteredEvents) {
        if (a.first == Event)
            return a.second;
    }
    return "";
 }
 std::string TLuaFile::GetFileName() const {
    return mFileName;
 }
 std::string TLuaFile::GetPluginName() const {
    return mPluginName;
 }
 lua_State* TLuaFile::GetState() {
    return mLuaState;
 }
 const lua_State* TLuaFile::GetState() const {
    return mLuaState;
 }
 void TLuaFile::SetLastWrite(fs::file_time_type time) {
    mLastWrote = time;
 }
 fs::file_time_type TLuaFile::GetLastWrite() {
    return mLastWrote;
 }
 TLuaFile::~TLuaFile() {
    info("closing lua state");
    lua_close(mLuaState);
 }
 void SendError(TLuaEngine& Engine, lua_State* L, const std::string& msg) {
    Assert(L);
    auto MaybeS = Engine.GetScript(L);
    std::string a;
    if (!MaybeS.has_value()) {
        a = ("_Console");
    } else {
        TLuaFile& S = MaybeS.value();
        a = fs::path(S.GetFileName()).filename().string();
    }
    warn(a + (" | Incorrect Call of ") + msg);
 }
 int lua_TempFix(lua_State* L) {
    if (lua_isnumber(L, 1)) {
        int ID = int(lua_tonumber(L, 1));
        auto MaybeClient = GetClient(Engine().Server(), ID);
        if (!MaybeClient || MaybeClient.value().expired())
            return 0;
        std::string Ret;
        auto c = MaybeClient.value().lock();
        if (c->IsGuest()) {
            Ret = "Guest-" + c->GetName();
        } else
            Ret = c->GetName();
        lua_pushstring(L, Ret.c_str());
    } else
        SendError(Engine(), L, "GetDID not enough arguments");
    return 1;
 }
 void TLuaArg::PushArgs(lua_State* State) {
    for (std::any arg : args) {
        if (!arg.has_value())
            return;
        std::string Type = arg.type().name();
        if (Type.find("bool") != std::string::npos) {
            lua_pushboolean(State, std::any_cast<bool>(arg));
        }
        if (Type.find("basic_string") != std::string::npos || Type.find("char") != std::string::npos) {
            lua_pushstring(State, std::any_cast<std::string>(arg).c_str());
        }
        if (Type.find("int") != std::string::npos) {
            lua_pushinteger(State, std::any_cast<int>(arg));
        }
        if (Type.find("float") != std::string::npos) {
            lua_pushnumber(State, std::any_cast<float>(arg));
        }
    }
 }
@@ -1,979 +0,0 @@
 #include "TNetwork.h"
 #include "Client.h"
 #include <CustomAssert.h>
 #include <Http.h>
 #include <array>
 #include <cstring>
 TNetwork::TNetwork(TServer& Server, TPPSMonitor& PPSMonitor, TResourceManager& ResourceManager)
    : mServer(Server)
    , mPPSMonitor(PPSMonitor)
    , mResourceManager(ResourceManager) {
    Application::RegisterShutdownHandler([&] {
        if (mUDPThread.joinable()) {
            debug("shutting down TCPServer");
            mShutdown = true;
            mUDPThread.detach();
            debug("shut down TCPServer");
        }
    });
    Application::RegisterShutdownHandler([&] {
        if (mUDPThread.joinable()) {
            debug("shutting down TCPServer");
            mShutdown = true;
            mTCPThread.detach();
            debug("shut down TCPServer");
        }
    });
    mTCPThread = std::thread(&TNetwork::TCPServerMain, this);
    mUDPThread = std::thread(&TNetwork::UDPServerMain, this);
 }
 void TNetwork::UDPServerMain() {
    RegisterThread("UDPServer");
 #ifdef WIN32
    WSADATA data;
    if (WSAStartup(514, &data)) {
        error(("Can't start Winsock!"));
        //return;
    }
    mUDPSock = socket(AF_INET, SOCK_DGRAM, 0);
    // Create a server hint structure for the server
    sockaddr_in serverAddr {};
    serverAddr.sin_addr.S_un.S_addr = ADDR_ANY; //Any Local
    serverAddr.sin_family = AF_INET; // Address format is IPv4
    serverAddr.sin_port = htons(Application::Settings.Port); // Convert from little to big endian
    // Try and bind the socket to the IP and port
    if (bind(mUDPSock, (sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
        error(("Can't bind socket!") + std::to_string(WSAGetLastError()));
        std::this_thread::sleep_for(std::chrono::seconds(5));
        exit(-1);
        //return;
    }
 #else // unix
    mUDPSock = socket(AF_INET, SOCK_DGRAM, 0);
    // Create a server hint structure for the server
    sockaddr_in serverAddr {};
    serverAddr.sin_addr.s_addr = INADDR_ANY; //Any Local
    serverAddr.sin_family = AF_INET; // Address format is IPv4
    serverAddr.sin_port = htons(uint16_t(Application::Settings.Port)); // Convert from little to big endian
    // Try and bind the socket to the IP and port
    if (bind(mUDPSock, (sockaddr*)&serverAddr, sizeof(serverAddr)) != 0) {
        error(("Can't bind socket!") + std::string(strerror(errno)));
        std::this_thread::sleep_for(std::chrono::seconds(5));
        exit(-1);
        //return;
    }
 #endif
    info(("Vehicle data network online on port ") + std::to_string(Application::Settings.Port) + (" with a Max of ")
        + std::to_string(Application::Settings.MaxPlayers) + (" Clients"));
    while (!mShutdown) {
        try {
            sockaddr_in client {};
            std::string Data = UDPRcvFromClient(client); //Receives any data from Socket
            size_t Pos = Data.find(':');
            if (Data.empty() || Pos > 2)
                continue;
            /*char clientIp[256];
            ZeroMemory(clientIp, 256); ///Code to get IP we don't need that yet
            inet_ntop(AF_INET, &client.sin_addr, clientIp, 256);*/
            uint8_t ID = uint8_t(Data.at(0)) - 1;
            mServer.ForEachClient([&](std::weak_ptr<TClient> ClientPtr) -> bool {
                std::shared_ptr<TClient> Client;
                {
                    ReadLock Lock(mServer.GetClientMutex());
                    if (!ClientPtr.expired()) {
                        Client = ClientPtr.lock();
                    }else return true;
                }
                if (Client->GetID() == ID) {
                    Client->UpdatePingTime();
                    Client->SetUDPAddr(client);
                    Client->SetIsConnected(true);
                    TServer::GlobalParser(ClientPtr, Data.substr(2), mPPSMonitor, *this);
                }
                return true;
            });
        } catch (const std::exception& e) {
            error(("fatal: ") + std::string(e.what()));
        }
    }
 }
 void TNetwork::TCPServerMain() {
    RegisterThread("TCPServer");
 #ifdef WIN32
    WSADATA wsaData;
    if (WSAStartup(514, &wsaData)) {
        error("Can't start Winsock!");
        return;
    }
    SOCKET client, Listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    sockaddr_in addr {};
    addr.sin_addr.S_un.S_addr = ADDR_ANY;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(Application::Settings.Port);
    if (bind(Listener, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
        error("Can't bind socket! " + std::to_string(WSAGetLastError()));
        std::this_thread::sleep_for(std::chrono::seconds(5));
        exit(-1);
    }
    if (Listener == -1) {
        error("Invalid listening socket");
        return;
    }
    if (listen(Listener, SOMAXCONN)) {
        error("listener failed " + std::to_string(GetLastError()));
        //TODO Fix me leak for Listener socket
        return;
    }
    info("Vehicle event network online");
    do {
        try {
            client = accept(Listener, nullptr, nullptr);
            if (client == -1) {
                warn("Got an invalid client socket on connect! Skipping...");
                continue;
            }
            std::thread ID(&TNetwork::Identify, this, client);
            ID.detach();
        } catch (const std::exception& e) {
            error("fatal: " + std::string(e.what()));
        }
    } while (client);
    CloseSocketProper(client);
    WSACleanup();
 #else // unix
    // wondering why we need slightly different implementations of this?
    // ask ms.
    SOCKET client = -1;
    SOCKET Listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    int optval = 1;
    setsockopt(Listener, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));
    // TODO: check optval or return value idk
    sockaddr_in addr {};
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(uint16_t(Application::Settings.Port));
    if (bind(Listener, (sockaddr*)&addr, sizeof(addr)) != 0) {
        error(("Can't bind socket! ") + std::string(strerror(errno)));
        std::this_thread::sleep_for(std::chrono::seconds(5));
        exit(-1);
    }
    if (Listener == -1) {
        error(("Invalid listening socket"));
        return;
    }
    if (listen(Listener, SOMAXCONN)) {
        error(("listener failed ") + std::string(strerror(errno)));
        //TODO fix me leak Listener
        return;
    }
    info(("Vehicle event network online"));
    do {
        try {
            if (mShutdown) {
                debug("shutdown during TCP wait for accept loop");
                break;
            }
            client = accept(Listener, nullptr, nullptr);
            if (client == -1) {
                warn(("Got an invalid client socket on connect! Skipping..."));
                continue;
            }
            std::thread ID(&TNetwork::Identify, this, client);
            ID.detach(); // TODO: Add to a queue and attempt to join periodically
        } catch (const std::exception& e) {
            error(("fatal: ") + std::string(e.what()));
        }
    } while (client);
    debug("all ok, arrived at " + std::string(__func__) + ":" + std::to_string(__LINE__));
    CloseSocketProper(client);
 #endif
 }
 #undef GetObject //Fixes Windows
 #include "rapidjson/document.h"
 #include "rapidjson/stringbuffer.h"
 #include "rapidjson/writer.h"
 namespace json = rapidjson;
 void TNetwork::Identify(SOCKET TCPSock) {
    RegisterThreadAuto();
    char Code;
    if (recv(TCPSock, &Code, 1, 0) != 1) {
        CloseSocketProper(TCPSock);
        return;
    }
    if (Code == 'C') {
        Authentication(TCPSock);
    } else if (Code == 'D') {
        HandleDownload(TCPSock);
    } else {
        CloseSocketProper(TCPSock);
    }
 }
 void TNetwork::HandleDownload(SOCKET TCPSock) {
    char D;
    if (recv(TCPSock, &D, 1, 0) != 1) {
        CloseSocketProper(TCPSock);
        return;
    }
    auto ID = uint8_t(D);
    mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
        ReadLock Lock(mServer.GetClientMutex());
        if (!ClientPtr.expired()) {
            auto c = ClientPtr.lock();
            if (c->GetID() == ID) {
                c->SetDownSock(TCPSock);
            }
        }
        return true;
    });
 }
 void TNetwork::Authentication(SOCKET TCPSock) {
    auto Client = CreateClient(TCPSock);
    std::string Rc;
    info("Identifying new client...");
    Rc = TCPRcv(*Client);
    if (Rc.size() > 3 && Rc.substr(0, 2) == "VC") {
        Rc = Rc.substr(2);
        if (Rc.length() > 4 || Rc != Application::ClientVersion()) {
            ClientKick(*Client, "Outdated Version!");
            return;
        }
    } else {
        ClientKick(*Client, "Invalid version header!");
        return;
    }
    if (!TCPSend(*Client, "S")) {
        // TODO: handle
    }
    Rc = TCPRcv(*Client);
    if (Rc.size() > 50) {
        ClientKick(*Client, "Invalid Key!");
        return;
    }
    if (!Rc.empty()) {
        Rc = Http::POST(Application::GetBackendUrlForAuth(), "/pkToUser", {}, R"({"key":")" + Rc + "\"}", true);
    }
    json::Document AuthResponse;
    AuthResponse.Parse(Rc.c_str());
    if (Rc == "-1" || AuthResponse.HasParseError()) {
        ClientKick(*Client, "Invalid key! Please restart your game.");
        return;
    }
    if (!AuthResponse.IsObject()) {
        ClientKick(*Client, "Backend returned invalid auth response format.");
        error("Backend returned invalid auth response format. This should never happen.");
        return;
    }
    if (AuthResponse["username"].IsString() && AuthResponse["roles"].IsString()
        && AuthResponse["guest"].IsBool() && AuthResponse["identifiers"].IsArray()) {
        Client->SetName(AuthResponse["username"].GetString());
        Client->SetRoles(AuthResponse["roles"].GetString());
        Client->SetIsGuest(AuthResponse["guest"].GetBool());
        for (const auto& ID : AuthResponse["identifiers"].GetArray()) {
            Client->AddIdentifier(ID.GetString());
        }
    } else {
        ClientKick(*Client, "Invalid authentication data!");
        return;
    }
    debug("Name -> " + Client->GetName() + ", Guest -> " + std::to_string(Client->IsGuest()) + ", Roles -> " + Client->GetRoles());
    debug("There are " + std::to_string(mServer.ClientCount()) + " known clients");
    mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
        std::shared_ptr<TClient> Cl;
        {
            ReadLock Lock(mServer.GetClientMutex());
            if (!ClientPtr.expired()) {
                Cl = ClientPtr.lock();
            } else return true;
        }
        info("Client Iteration: Name -> " + Cl->GetName() + ", Guest -> " + std::to_string(Cl->IsGuest()) + ", Roles -> " + Cl->GetRoles());
        if (Cl->GetName() == Client->GetName() && Cl->IsGuest() == Client->IsGuest()) {
            info("New client matched with current iteration");
            info("Old client (" + Cl->GetName() + ") kicked: Reconnecting");
            CloseSocketProper(Cl->GetTCPSock());
            Cl->SetStatus(-2);
            return false;
        }
        return true;
    });
    auto arg = std::make_unique<TLuaArg>(TLuaArg { { Client->GetName(), Client->GetRoles(), Client->IsGuest() } });
    std::any Res = TriggerLuaEvent("onPlayerAuth", false, nullptr, std::move(arg), true);
    std::string Type = Res.type().name();
    if (Type.find("int") != std::string::npos && std::any_cast<int>(Res)) {
        ClientKick(*Client, "you are not allowed on the server!");
        return;
    } else if (Type.find("string") != std::string::npos) {
        ClientKick(*Client, std::any_cast<std::string>(Res));
        return;
    }
    if (mServer.ClientCount() < size_t(Application::Settings.MaxPlayers)) {
        info("Identification success");
        mServer.InsertClient(Client);
        TCPClient(Client);
    } else
        ClientKick(*Client, "Server full!");
 }
 std::shared_ptr<TClient> TNetwork::CreateClient(SOCKET TCPSock) {
    auto c = std::make_shared<TClient>(mServer);
    c->SetTCPSock(TCPSock);
    return c;
 }
 bool TNetwork::TCPSend(TClient& c, const std::string& Data, bool IsSync) {
    if (!IsSync) {
        if (c.IsSyncing()) {
            //std::unique_lock Lock(c.MissedPacketQueueMutex());
            if(!Data.empty()) {
                if (Data.at(0) == 'O' || Data.at(0) == 'A' || Data.at(0) == 'C' || Data.at(0) == 'E') {
                    c.EnqueuePacket(Data);
                }
            }
            return true;
        }
    }
    int32_t Size, Sent;
    std::string Send(4, 0);
    Size = int32_t(Data.size());
    memcpy(&Send[0], &Size, sizeof(Size));
    Send += Data;
    Sent = 0;
    Size += 4;
    do {
 #ifdef WIN32
        int32_t Temp = send(c.GetTCPSock(), &Send[Sent], Size - Sent, 0);
 #else //WIN32
        int32_t Temp = send(c.GetTCPSock(), &Send[Sent], Size - Sent, MSG_NOSIGNAL);
 #endif //WIN32
        if (Temp == 0) {
            debug("send() == 0: " + std::string(std::strerror(errno)));
            if (c.GetStatus() > -1)
                c.SetStatus(-1);
            return false;
        } else if (Temp < 0) {
            debug("send() < 0: " + std::string(std::strerror(errno))); //TODO fix it was spamming yet everyone stayed on the server
            if (c.GetStatus() > -1)
                c.SetStatus(-1);
            CloseSocketProper(c.GetTCPSock());
            return false;
        }
        Sent += Temp;
    } while (Sent < Size);
    return true;
 }
 bool TNetwork::CheckBytes(TClient& c, int32_t BytesRcv) {
    if (BytesRcv == 0) {
        debug("(TCP) Connection closing...");
        if (c.GetStatus() > -1)
            c.SetStatus(-1);
        return false;
    } else if (BytesRcv < 0) {
 #ifdef WIN32
        debug(("(TCP) recv failed with error: ") + std::to_string(WSAGetLastError()));
 #else // unix
        debug(("(TCP) recv failed with error: ") + std::string(strerror(errno)));
 #endif // WIN32
        if (c.GetStatus() > -1)
            c.SetStatus(-1);
        info(("Closing socket in CheckBytes, BytesRcv < 0"));
        CloseSocketProper(c.GetTCPSock());
        return false;
    }
    return true;
 }
 std::string TNetwork::TCPRcv(TClient& c) {
    int32_t Header, BytesRcv = 0, Temp;
    if (c.GetStatus() < 0)
        return "";
    std::vector<char> Data(sizeof(Header));
    do {
        Temp = recv(c.GetTCPSock(), &Data[BytesRcv], 4 - BytesRcv, 0);
        if (!CheckBytes(c, Temp)) {
 #ifdef DEBUG
            error(std::string(__func__) + (": failed on CheckBytes in while(BytesRcv < 4)"));
 #endif // DEBUG
            return "";
        }
        BytesRcv += Temp;
    } while (size_t(BytesRcv) < sizeof(Header));
    memcpy(&Header, &Data[0], sizeof(Header));
 #ifdef DEBUG
    //debug(std::string(__func__) + (": expecting ") + std::to_string(Header) + (" bytes."));
 #endif // DEBUG
    if (!CheckBytes(c, BytesRcv)) {
 #ifdef DEBUG
        error(std::string(__func__) + (": failed on CheckBytes"));
 #endif // DEBUG
        return "";
    }
    if (Header < 100 * MB) {
        Data.resize(Header);
    } else {
        ClientKick(c, "Header size limit exceeded");
        warn("Client " + c.GetName() + " (" + std::to_string(c.GetID()) + ") sent header of >100MB - assuming malicious intent and disconnecting the client.");
        return "";
    }
    BytesRcv = 0;
    do {
        Temp = recv(c.GetTCPSock(), &Data[BytesRcv], Header - BytesRcv, 0);
        if (!CheckBytes(c, Temp)) {
 #ifdef DEBUG
            error(std::string(__func__) + (": failed on CheckBytes in while(BytesRcv < Header)"));
 #endif // DEBUG
            return "";
        }
 #ifdef DEBUG
        //debug(std::string(__func__) + (": Temp: ") + std::to_string(Temp) + (", BytesRcv: ") + std::to_string(BytesRcv));
 #endif // DEBUG
        BytesRcv += Temp;
    } while (BytesRcv < Header);
 #ifdef DEBUG
    //debug(std::string(__func__) + (": finished recv with Temp: ") + std::to_string(Temp) + (", BytesRcv: ") + std::to_string(BytesRcv));
 #endif // DEBUG
    std::string Ret(Data.data(), Header);
    if (Ret.substr(0, 4) == "ABG:") {
        Ret = DeComp(Ret.substr(4));
    }
 #ifdef DEBUG
    //debug("Parsing from " + c->GetName() + " -> " +std::to_string(Ret.size()));
 #endif
    return Ret;
 }
 void TNetwork::ClientKick(TClient& c, const std::string& R) {
    info("Client kicked: " + R);
    if (!TCPSend(c, "E" + R)) {
        // TODO handle
    }
    c.SetStatus(-2);
    CloseSocketProper(c.GetTCPSock());
 }
 void TNetwork::Looper(const std::weak_ptr<TClient>& c){
    while(!c.expired()) {
        auto Client = c.lock();
        if (Client->GetStatus() < 0) {
            debug("client status < 0, breaking client loop");
            break;
        }
        if (!Client->IsSyncing() && Client->IsSynced() && Client->MissedPacketQueueSize() != 0) {
            //debug("sending " + std::to_string(Client->MissedPacketQueueSize()) + " queued packets");
            while (Client->MissedPacketQueueSize() > 0) {
                std::string QData {};
                { // locked context
                    std::unique_lock lock(Client->MissedPacketQueueMutex());
                    if (Client->MissedPacketQueueSize() <= 0) {
                        break;
                    }
                    QData = Client->MissedPacketQueue().front();
                    Client->MissedPacketQueue().pop();
                } // end locked context
                // debug("sending a missed packet: " + QData);
                if (!TCPSend(*Client, QData, true)) {
                    if (Client->GetStatus() > -1)
                        Client->SetStatus(-1);
                    {
                        std::unique_lock lock(Client->MissedPacketQueueMutex());
                        while (!Client->MissedPacketQueue().empty()) {
                            Client->MissedPacketQueue().pop();
                        }
                    }
                    CloseSocketProper(Client->GetTCPSock());
                    break;
                }
            }
        }else{
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
    }
 }
 void TNetwork::TCPClient(const std::weak_ptr<TClient>& c) {
    // TODO: the c.expired() might cause issues here, remove if you end up here with your debugger
    if (c.expired() || c.lock()->GetTCPSock() == -1) {
        mServer.RemoveClient(c);
        return;
    }
    OnConnect(c);
    RegisterThread("(" + std::to_string(c.lock()->GetID()) + ") \"" + c.lock()->GetName() + "\"");
    std::thread QueueSync(&TNetwork::Looper, this ,c);
    while (true) {
        if (c.expired())
            break;
        auto Client = c.lock();
        if (Client->GetStatus() < 0) {
            debug("client status < 0, breaking client loop");
            break;
        }
        auto res = TCPRcv(*Client);
        if (res == "") {
            debug("TCPRcv error, break client loop");
            break;
        }
        TServer::GlobalParser(c, res, mPPSMonitor, *this);
    }
    if(QueueSync.joinable())QueueSync.join();
    if (!c.expired()) {
        auto Client = c.lock();
        OnDisconnect(c, Client->GetStatus() == -2);
    } else {
        warn("client expired in TCPClient, should never happen");
    }
 }
 void TNetwork::UpdatePlayer(TClient& Client) {
    std::string Packet = ("Ss") + std::to_string(mServer.ClientCount()) + "/" + std::to_string(Application::Settings.MaxPlayers) + ":";
    mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
        ReadLock Lock(mServer.GetClientMutex());
        if (!ClientPtr.expired()) {
            auto c = ClientPtr.lock();
            Packet += c->GetName() + ",";
        }
        return true;
    });
    Packet = Packet.substr(0, Packet.length() - 1);
    (void)Respond(Client, Packet, true);
 }
 void TNetwork::OnDisconnect(const std::weak_ptr<TClient>& ClientPtr, bool kicked) {
    Assert(!ClientPtr.expired());
    auto LockedClientPtr = ClientPtr.lock();
    TClient& c = *LockedClientPtr;
    info(c.GetName() + (" Connection Terminated"));
    std::string Packet;
    TClient::TSetOfVehicleData VehicleData;
    { // Vehicle Data Lock Scope
        auto LockedData = c.GetAllCars();
        VehicleData = LockedData.VehicleData;
    } // End Vehicle Data Lock Scope
    for (auto& v : VehicleData) {
        Packet = "Od:" + std::to_string(c.GetID()) + "-" + std::to_string(v.ID());
        SendToAll(&c, Packet, false, true);
    }
    if (kicked)
        Packet = ("L") + c.GetName() + (" was kicked!");
    else
        Packet = ("L") + c.GetName() + (" left the server!");
    SendToAll(&c, Packet, false, true);
    Packet.clear();
    TriggerLuaEvent(("onPlayerDisconnect"), false, nullptr, std::make_unique<TLuaArg>(TLuaArg { { c.GetID() } }), false);
    if (c.GetTCPSock())
        CloseSocketProper(c.GetTCPSock());
    if (c.GetDownSock())
        CloseSocketProper(c.GetDownSock());
    mServer.RemoveClient(ClientPtr);
 }
 int TNetwork::OpenID() {
    int ID = 0;
    bool found;
    do {
        found = true;
        mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
            ReadLock Lock(mServer.GetClientMutex());
            if (!ClientPtr.expired()) {
                auto c = ClientPtr.lock();
                if (c->GetID() == ID) {
                    found = false;
                    ID++;
                }
            }
            return true;
        });
    } while (!found);
    return ID;
 }
 void TNetwork::OnConnect(const std::weak_ptr<TClient>& c) {
    Assert(!c.expired());
    info("Client connected");
    auto LockedClient = c.lock();
    LockedClient->SetID(OpenID());
    info("Assigned ID " + std::to_string(LockedClient->GetID()) + " to " + LockedClient->GetName());
    TriggerLuaEvent("onPlayerConnecting", false, nullptr, std::make_unique<TLuaArg>(TLuaArg { { LockedClient->GetID() } }), false);
    SyncResources(*LockedClient);
    if (LockedClient->GetStatus() < 0)
        return;
    (void)Respond(*LockedClient, "M" + Application::Settings.MapName, true); //Send the Map on connect
    info(LockedClient->GetName() + " : Connected");
    TriggerLuaEvent("onPlayerJoining", false, nullptr, std::make_unique<TLuaArg>(TLuaArg { { LockedClient->GetID() } }), false);
 }
 void TNetwork::SyncResources(TClient& c) {
 #ifndef DEBUG
    try {
 #endif
        if (!TCPSend(c, "P" + std::to_string(c.GetID()))) {
            // TODO handle
        }
        std::string Data;
        while (c.GetStatus() > -1) {
            Data = TCPRcv(c);
            if (Data == "Done")
                break;
            Parse(c, Data);
        }
 #ifndef DEBUG
    } catch (std::exception& e) {
        error("Exception! : " + std::string(e.what()));
        c.SetStatus(-1);
    }
 #endif
 }
 void TNetwork::Parse(TClient& c, const std::string& Packet) {
    if (Packet.empty())
        return;
    char Code = Packet.at(0), SubCode = 0;
    if (Packet.length() > 1)
        SubCode = Packet.at(1);
    switch (Code) {
    case 'f':
        SendFile(c, Packet.substr(1));
        return;
    case 'S':
        if (SubCode == 'R') {
            debug("Sending Mod Info");
            std::string ToSend = mResourceManager.FileList() + mResourceManager.FileSizes();
            if (ToSend.empty())
                ToSend = "-";
            if (!TCPSend(c, ToSend)) {
                // TODO: error
            }
        }
        return;
    default:
        return;
    }
 }
 void TNetwork::SendFile(TClient& c, const std::string& Name) {
    info(c.GetName() + " requesting : " + Name.substr(Name.find_last_of('/')));
    if (!std::filesystem::exists(Name)) {
        if (!TCPSend(c, "CO")) {
            // TODO: handle
        }
        warn("File " + Name + " could not be accessed!");
        return;
    } else {
        if (!TCPSend(c, "AG")) {
            // TODO: handle
        }
    }
    ///Wait for connections
    int T = 0;
    while (c.GetDownSock() < 1 && T < 50) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        T++;
    }
    if (c.GetDownSock() < 1) {
        error("Client doesn't have a download socket!");
        if (c.GetStatus() > -1)
            c.SetStatus(-1);
        return;
    }
    size_t Size = size_t(std::filesystem::file_size(Name)), MSize = Size / 2;
    std::thread SplitThreads[2] {
        std::thread([&] {
            SplitLoad(c, 0, MSize, false, Name);
        }),
        std::thread([&] {
            SplitLoad(c, MSize, Size, true, Name);
        })
    };
    for (auto& SplitThread : SplitThreads) {
        if (SplitThread.joinable()) {
            SplitThread.join();
        }
    }
 }
 void TNetwork::SplitLoad(TClient& c, size_t Sent, size_t Size, bool D, const std::string& Name) {
    std::ifstream f(Name.c_str(), std::ios::binary);
    uint32_t Split = 0x7735940; //125MB
    char* Data;
    if (Size > Split)
        Data = new char[Split];
    else
        Data = new char[Size];
    SOCKET TCPSock;
    if (D)
        TCPSock = c.GetDownSock();
    else
        TCPSock = c.GetTCPSock();
    info("Split load Socket " + std::to_string(TCPSock));
    while (c.GetStatus() > -1 && Sent < Size) {
        size_t Diff = Size - Sent;
        if (Diff > Split) {
            f.seekg(Sent, std::ios_base::beg);
            f.read(Data, Split);
            if (!TCPSendRaw(TCPSock, Data, Split)) {
                if (c.GetStatus() > -1)
                    c.SetStatus(-1);
                break;
            }
            Sent += Split;
        } else {
            f.seekg(Sent, std::ios_base::beg);
            f.read(Data, Diff);
            if (!TCPSendRaw(TCPSock, Data, int32_t(Diff))) {
                if (c.GetStatus() > -1)
                    c.SetStatus(-1);
                break;
            }
            Sent += Diff;
        }
    }
    delete[] Data;
    f.close();
 }
 bool TNetwork::TCPSendRaw(SOCKET C, char* Data, int32_t Size) {
    intmax_t Sent = 0;
    do {
        intmax_t Temp = send(C, &Data[Sent], int(Size - Sent), 0);
        if (Temp < 1) {
            info("Socket Closed! " + std::to_string(C));
            CloseSocketProper(C);
            return false;
        }
        Sent += Temp;
    } while (Sent < Size);
    return true;
 }
 bool TNetwork::SendLarge(TClient& c, std::string Data, bool isSync) {
    if (Data.length() > 400) {
        std::string CMP(Comp(Data));
        Data = "ABG:" + CMP;
    }
    return TCPSend(c, Data, isSync);
 }
 bool TNetwork::Respond(TClient& c, const std::string& MSG, bool Rel, bool isSync) {
    char C = MSG.at(0);
    if (Rel || C == 'W' || C == 'Y' || C == 'V' || C == 'E') {
        if (C == 'O' || C == 'T' || MSG.length() > 1000) {
            return SendLarge(c, MSG, isSync);
        } else {
            return TCPSend(c, MSG, isSync);
        }
    } else {
        return UDPSend(c, MSG);
    }
 }
 bool TNetwork::SyncClient(const std::weak_ptr<TClient>& c) {
    if (c.expired()) {
        return false;
    }
    auto LockedClient = c.lock();
    if (LockedClient->IsSynced())
        return true;
    // Syncing, later set isSynced
    // after syncing is done, we apply all packets they missed
    if (!Respond(*LockedClient, ("Sn") + LockedClient->GetName(), true)) {
        return false;
    }
    // ignore error
    (void)SendToAll(LockedClient.get(), ("JWelcome ") + LockedClient->GetName() + "!", false, true);
    TriggerLuaEvent(("onPlayerJoin"), false, nullptr, std::make_unique<TLuaArg>(TLuaArg { { LockedClient->GetID() } }), false);
    LockedClient->SetIsSyncing(true);
    bool Return = false;
    bool res = true;
    mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
        std::shared_ptr<TClient> client;
        {
            ReadLock Lock(mServer.GetClientMutex());
            if (!ClientPtr.expired()) {
                client = ClientPtr.lock();
            } else return true;
        }
        TClient::TSetOfVehicleData VehicleData;
        { // Vehicle Data Lock Scope
            auto LockedData = client->GetAllCars();
            VehicleData = LockedData.VehicleData;
        } // End Vehicle Data Lock Scope
        if (client != LockedClient) {
            for (auto& v : VehicleData) {
                if (LockedClient->GetStatus() < 0) {
                    Return = true;
                    res = false;
                    return false;
                }
                res = Respond(*LockedClient, v.Data(), true, true);
                std::this_thread::sleep_for(std::chrono::seconds(2));
            }
        }
        return true;
    });
    LockedClient->SetIsSyncing(false);
    if (Return) {
        return res;
    }
    LockedClient->SetIsSynced(true);
    info(LockedClient->GetName() + (" is now synced!"));
    return true;
 }
 void TNetwork::SendToAll(TClient* c, const std::string& Data, bool Self, bool Rel) {
    if (!Self)
        Assert(c);
    char C = Data.at(0);
    bool ret = true;
    mServer.ForEachClient([&](std::weak_ptr<TClient> ClientPtr) -> bool {
        std::shared_ptr<TClient> Client;
        {
            ReadLock Lock(mServer.GetClientMutex());
            if (!ClientPtr.expired()) {
                Client = ClientPtr.lock();
            }else return true;
        }
        if (Self || Client.get() != c) {
            if (Client->IsSynced() || Client->IsSyncing()) {
                if (Rel || C == 'W' || C == 'Y' || C == 'V' || C == 'E') {
                    if (C == 'O' || C == 'T' || Data.length() > 1000) {
                        if (Data.length() > 400) {
                            std::string CMP(Comp(Data));
                            Client->EnqueuePacket("ABG:" + CMP);
                        }else{
                            Client->EnqueuePacket(Data);
                        }
                        //ret = SendLarge(*Client, Data);
                    } else {
                        Client->EnqueuePacket(Data);
                        //ret = TCPSend(*Client, Data);
                    }
                } else {
                    ret = UDPSend(*Client, Data);
                }
            }
        }
        return true;
    });
    if (!ret) {
        // TODO: handle
    }
    return;
 }
 bool TNetwork::UDPSend(TClient& Client, std::string Data) const {
    if (!Client.IsConnected() || Client.GetStatus() < 0) {
        // this can happen if we try to send a packet to a client that is either
        // 1. not yet fully connected, or
        // 2. disconnected and not yet fully removed
        // this is fine can can be ignored :^)
        return true;
    }
    sockaddr_in Addr = Client.GetUDPAddr();
    auto AddrSize = sizeof(Client.GetUDPAddr());
    if (Data.length() > 400) {
        std::string CMP(Comp(Data));
        Data = "ABG:" + CMP;
    }
 #ifdef WIN32
    int sendOk;
    int len = static_cast<int>(Data.size());
 #else
    int64_t sendOk;
    size_t len = Data.size();
 #endif // WIN32
    sendOk = sendto(mUDPSock, Data.c_str(), len, 0, (sockaddr*)&Addr, int(AddrSize));
 #ifdef WIN32
    if (sendOk == -1) {
        debug(("(UDP) Send Failed Code : ") + std::to_string(WSAGetLastError()));
        if (Client.GetStatus() > -1)
            Client.SetStatus(-1);
        return false;
    } else if (sendOk == 0) {
        debug(("(UDP) sendto returned 0"));
        if (Client.GetStatus() > -1)
            Client.SetStatus(-1);
        return false;
    }
 #else // unix
    if (sendOk == -1) {
        debug(("(UDP) Send Failed Code : ") + std::string(strerror(errno)));
        if (Client.GetStatus() > -1)
            Client.SetStatus(-1);
        return false;
    } else if (sendOk == 0) {
        debug(("(UDP) sendto returned 0"));
        if (Client.GetStatus() > -1)
            Client.SetStatus(-1);
        return false;
    }
 #endif // WIN32
    return true;
 }
 std::string TNetwork::UDPRcvFromClient(sockaddr_in& client) const {
    size_t clientLength = sizeof(client);
    std::array<char, 1024> Ret {};
 #ifdef WIN32
    auto Rcv = recvfrom(mUDPSock, Ret.data(), int(Ret.size()), 0, (sockaddr*)&client, (int*)&clientLength);
 #else // unix
    int64_t Rcv = recvfrom(mUDPSock, Ret.data(), Ret.size(), 0, (sockaddr*)&client, (socklen_t*)&clientLength);
 #endif // WIN32
    if (Rcv == -1) {
 #ifdef WIN32
        error(("(UDP) Error receiving from Client! Code : ") + std::to_string(WSAGetLastError()));
 #else // unix
        error(("(UDP) Error receiving from Client! Code : ") + std::string(strerror(errno)));
 #endif // WIN32
        return "";
    }
    return std::string(Ret.begin(), Ret.begin() + Rcv);
 }
@@ -1,68 +0,0 @@
 #include "TPPSMonitor.h"
 #include "Client.h"
 #include "TNetwork.h"
 TPPSMonitor::TPPSMonitor(TServer& Server)
    : mServer(Server) {
    Application::SetPPS("-");
    Application::RegisterShutdownHandler([&] {
        if (mThread.joinable()) {
            debug("shutting down PPSMonitor");
            mShutdown = true;
            mThread.join();
            debug("shut down PPSMonitor");
        }
    });
    Start();
 }
 void TPPSMonitor::operator()() {
    RegisterThread("PPSMonitor");
    while (!mNetwork) {
        // hard spi
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
    info("PPSMonitor starting");
    std::vector<std::shared_ptr<TClient>> TimedOutClients;
    while (!mShutdown) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        int C = 0, V = 0;
        if (mServer.ClientCount() == 0) {
            Application::SetPPS("-");
            continue;
        }
        mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
            std::shared_ptr<TClient> c;
            {
                ReadLock Lock(mServer.GetClientMutex());
                if (!ClientPtr.expired()) {
                    c = ClientPtr.lock();
                } else return true;
            }
            if (c->GetCarCount() > 0) {
                C++;
                V += c->GetCarCount();
            }
            if (!c->IsSynced() || c->IsSyncing()) {
                c->UpdatePingTime();
            }
            // kick on "no ping"
            if (c->SecondsSinceLastPing() > 60 && c->IsSynced() && !c->IsSyncing()) {
                debug("client " + std::string("(") + std::to_string(c->GetID()) + ")" + c->GetName() + " timing out: " + std::to_string(c->SecondsSinceLastPing()) + ", pps: " + Application::PPS());
                TimedOutClients.push_back(c);
            }
            return true;
        });
        for (auto& ClientToKick : TimedOutClients) {
            Network().ClientKick(*ClientToKick, "Timeout (no ping for >60 seconds)");
        }
        TimedOutClients.clear();
        if (C == 0 || mInternalPPS == 0) {
            Application::SetPPS("-");
        } else {
            int R = (mInternalPPS / C) / V;
            Application::SetPPS(std::to_string(R));
        }
        mInternalPPS = 0;
    }
 }
@@ -1,32 +0,0 @@
 #include "TResourceManager.h"
 #include <algorithm>
 #include <filesystem>
 namespace fs = std::filesystem;
 TResourceManager::TResourceManager() {
    std::string Path = Application::Settings.Resource + "/Client";
    if (!fs::exists(Path))
        fs::create_directories(Path);
    for (const auto& entry : fs::directory_iterator(Path)) {
        std::string File(entry.path().string());
        if (auto pos = File.find(".zip"); pos != std::string::npos) {
            if (File.length() - pos == 4) {
                std::replace(File.begin(), File.end(),'\\','/');
                mFileList += File + ';';
                if(auto i = File.find_last_of('/'); i != std::string::npos){
                    ++i;
                    File = File.substr(i,pos-i);
                }
                mTrimmedList += File + ';';
                mFileSizes += std::to_string(size_t(fs::file_size(entry.path()))) + ';';
                mMaxModSize += size_t(fs::file_size(entry.path()));
                mModsLoaded++;
            }
        }
    }
    if (mModsLoaded)
        info("Loaded " + std::to_string(mModsLoaded) + " Mods");
 }
@@ -1,313 +0,0 @@
 #include "TServer.h"
 #include "Client.h"
 #include "Common.h"
 #include "TNetwork.h"
 #include "TPPSMonitor.h"
 #include <TLuaFile.h>
 #include <any>
 #include <sstream>
 #undef GetObject //Fixes Windows
 #include "rapidjson/document.h"
 #include "rapidjson/stringbuffer.h"
 #include "rapidjson/writer.h"
 namespace json = rapidjson;
 TServer::TServer(int argc, char** argv) {
    info("BeamMP Server v" + Application::ServerVersion());
    if (argc > 1) {
        Application::Settings.CustomIP = argv[1];
        size_t n = std::count(Application::Settings.CustomIP.begin(), Application::Settings.CustomIP.end(), '.');
        auto p = Application::Settings.CustomIP.find_first_not_of(".0123456789");
        if (p != std::string::npos || n != 3 || Application::Settings.CustomIP.substr(0, 3) == "127") {
            Application::Settings.CustomIP.clear();
            warn("IP Specified is invalid! Ignoring");
        } else {
            info("server started with custom IP");
        }
    }
 }
 void TServer::RemoveClient(const std::weak_ptr<TClient>& WeakClientPtr) {
    if (!WeakClientPtr.expired()) {
        TClient& Client = *WeakClientPtr.lock();
        debug("removing client " + Client.GetName() + " (" + std::to_string(ClientCount()) + ")");
        Client.ClearCars();
        WriteLock Lock(mClientsMutex);
        mClients.erase(WeakClientPtr.lock());
    }
 }
 std::weak_ptr<TClient> TServer::InsertNewClient() {
    debug("inserting new client (" + std::to_string(ClientCount()) + ")");
    WriteLock Lock(mClientsMutex);
    auto [Iter, Replaced] = mClients.insert(std::make_shared<TClient>(*this));
    return *Iter;
 }
 void TServer::ForEachClient(const std::function<bool(std::weak_ptr<TClient>)>& Fn) {
    decltype(mClients) Clients;
    {
        ReadLock lock(mClientsMutex);
        Clients = mClients;
    }
    for (auto& Client : Clients) {
        if (!Fn(Client)) {
            break;
        }
    }
 }
 size_t TServer::ClientCount() const {
    ReadLock Lock(mClientsMutex);
    return mClients.size();
 }
 void TServer::GlobalParser(const std::weak_ptr<TClient>& Client, std::string Packet, TPPSMonitor& PPSMonitor, TNetwork& Network) {
    if (Packet.find("Zp") != std::string::npos && Packet.size() > 500) {
        abort();
    }
    if (Packet.substr(0, 4) == "ABG:") {
        Packet = DeComp(Packet.substr(4));
    }
    if (Packet.empty()) {
        return;
    }
    if (Client.expired()) {
        return;
    }
    auto LockedClient = Client.lock();
    std::any Res;
    char Code = Packet.at(0);
    //V to Z
    if (Code <= 90 && Code >= 86) {
        PPSMonitor.IncrementInternalPPS();
        Network.SendToAll(LockedClient.get(), Packet, false, false);
        return;
    }
    switch (Code) {
    case 'H': // initial connection
 #ifdef DEBUG
        debug(std::string("got 'H' packet: '") + Packet + "' (" + std::to_string(Packet.size()) + ")");
 #endif
        if (!Network.SyncClient(Client)) {
            // TODO handle
        }
        return;
    case 'p':
        if (!Network.Respond(*LockedClient, ("p"), false)) {
            // failed to send
            if (LockedClient->GetStatus() > -1) {
                LockedClient->SetStatus(-1);
            }
        } else {
            Network.UpdatePlayer(*LockedClient);
        }
        LockedClient->UpdatePingTime();
        return;
    case 'O':
        if (Packet.length() > 1000) {
            debug(("Received data from: ") + LockedClient->GetName() + (" Size: ") + std::to_string(Packet.length()));
        }
        ParseVehicle(*LockedClient, Packet, Network);
        return;
    case 'J':
 #ifdef DEBUG
        debug(std::string(("got 'J' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
 #endif
        Network.SendToAll(LockedClient.get(), Packet, false, true);
        return;
    case 'C':
 #ifdef DEBUG
        debug(std::string(("got 'C' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
 #endif
        if (Packet.length() < 4 || Packet.find(':', 3) == std::string::npos)
            break;
        Res = TriggerLuaEvent("onChatMessage", false, nullptr, std::make_unique<TLuaArg>(TLuaArg { { LockedClient->GetID(), LockedClient->GetName(), Packet.substr(Packet.find(':', 3) + 1) } }), true);
        if (std::any_cast<int>(Res))
            break;
        Network.SendToAll(nullptr, Packet, true, true);
        return;
    case 'E':
 #ifdef DEBUG
        debug(std::string(("got 'E' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
 #endif
        HandleEvent(*LockedClient, Packet);
        return;
    default:
        return;
    }
 }
 void TServer::HandleEvent(TClient& c, const std::string& Data) {
    std::stringstream ss(Data);
    std::string t, Name;
    int a = 0;
    while (std::getline(ss, t, ':')) {
        switch (a) {
        case 1:
            Name = t;
            break;
        case 2:
            TriggerLuaEvent(Name, false, nullptr, std::make_unique<TLuaArg>(TLuaArg { { c.GetID(), t } }), false);
            break;
        default:
            break;
        }
        if (a == 2)
            break;
        a++;
    }
 }
 void TServer::ParseVehicle(TClient& c, const std::string& Pckt, TNetwork& Network) {
    if (Pckt.length() < 4)
        return;
    std::string Packet = Pckt;
    char Code = Packet.at(1);
    int PID = -1;
    int VID = -1, Pos;
    std::string Data = Packet.substr(3), pid, vid;
    switch (Code) { //Spawned Destroyed Switched/Moved NotFound Reset
    case 's':
 #ifdef DEBUG
        debug(std::string(("got 'Os' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
 #endif
        if (Data.at(0) == '0') {
            int CarID = c.GetOpenCarID();
            debug(c.GetName() + (" created a car with ID ") + std::to_string(CarID));
            Packet = "Os:" + c.GetRoles() + ":" + c.GetName() + ":" + std::to_string(c.GetID()) + "-" + std::to_string(CarID) + Packet.substr(4);
            auto Res = TriggerLuaEvent(("onVehicleSpawn"), false, nullptr, std::make_unique<TLuaArg>(TLuaArg { { c.GetID(), CarID, Packet.substr(3) } }), true);
            if (c.GetCarCount() >= Application::Settings.MaxCars || std::any_cast<int>(Res)) {
                if (!Network.Respond(c, Packet, true)) {
                    // TODO: handle
                }
                std::string Destroy = "Od:" + std::to_string(c.GetID()) + "-" + std::to_string(CarID);
                if (!Network.Respond(c, Destroy, true)) {
                    // TODO: handle
                }
                debug(c.GetName() + (" (force : car limit/lua) removed ID ") + std::to_string(CarID));
            } else {
                c.AddNewCar(CarID, Packet);
                Network.SendToAll(nullptr, Packet, true, true);
            }
        }
        return;
    case 'c':
 #ifdef DEBUG
        debug(std::string(("got 'Oc' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
 #endif
        pid = Data.substr(0, Data.find('-'));
        vid = Data.substr(Data.find('-') + 1, Data.find(':', 1) - Data.find('-') - 1);
        if (pid.find_first_not_of("0123456789") == std::string::npos && vid.find_first_not_of("0123456789") == std::string::npos) {
            PID = stoi(pid);
            VID = stoi(vid);
        }
        if (PID != -1 && VID != -1 && PID == c.GetID()) {
            auto Res = TriggerLuaEvent(("onVehicleEdited"), false, nullptr,
                std::make_unique<TLuaArg>(TLuaArg { { c.GetID(), VID, Packet.substr(3) } }),
                true);
            if (!std::any_cast<int>(Res)) {
                Network.SendToAll(&c, Packet, false, true);
                Apply(c, VID, Packet);
            } else {
                std::string Destroy = "Od:" + std::to_string(c.GetID()) + "-" + std::to_string(VID);
                if (!Network.Respond(c, Destroy, true)) {
                    // TODO: handle
                }
                c.DeleteCar(VID);
            }
        }
        return;
    case 'd':
 #ifdef DEBUG
        debug(std::string(("got 'Od' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
 #endif
        pid = Data.substr(0, Data.find('-'));
        vid = Data.substr(Data.find('-') + 1);
        if (pid.find_first_not_of("0123456789") == std::string::npos && vid.find_first_not_of("0123456789") == std::string::npos) {
            PID = stoi(pid);
            VID = stoi(vid);
        }
        if (PID != -1 && VID != -1 && PID == c.GetID()) {
            Network.SendToAll(nullptr, Packet, true, true);
            TriggerLuaEvent(("onVehicleDeleted"), false, nullptr,
                std::make_unique<TLuaArg>(TLuaArg { { c.GetID(), VID } }), false);
            c.DeleteCar(VID);
            debug(c.GetName() + (" deleted car with ID ") + std::to_string(VID));
        }
        return;
    case 'r':
 #ifdef DEBUG
        debug(std::string(("got 'Or' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
 #endif
        Pos = int(Data.find('-'));
        pid = Data.substr(0, Pos++);
        vid = Data.substr(Pos, Data.find(':') - Pos);
        if (pid.find_first_not_of("0123456789") == std::string::npos && vid.find_first_not_of("0123456789") == std::string::npos) {
            PID = stoi(pid);
            VID = stoi(vid);
        }
        if (PID != -1 && VID != -1 && PID == c.GetID()) {
            Data = Data.substr(Data.find('{'));
            TriggerLuaEvent("onVehicleReset", false, nullptr,
                std::make_unique<TLuaArg>(TLuaArg { { c.GetID(), VID, Data } }),
                false);
            Network.SendToAll(&c, Packet, false, true);
        }
        return;
    case 't':
 #ifdef DEBUG
        debug(std::string(("got 'Ot' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
 #endif
        Network.SendToAll(&c, Packet, false, true);
        return;
    default:
 #ifdef DEBUG
        warn(std::string(("possibly not implemented: '") + Packet + ("' (") + std::to_string(Packet.size()) + (")")));
 #endif // DEBUG
        return;
    }
 }
 void TServer::Apply(TClient& c, int VID, const std::string& pckt) {
    std::string Packet = pckt.substr(pckt.find('{')), VD = c.GetCarData(VID);
    std::string Header = VD.substr(0, VD.find('{'));
    VD = VD.substr(VD.find('{'));
    rapidjson::Document Veh, Pack;
    Veh.Parse(VD.c_str());
    if (Veh.HasParseError()) {
        error("Could not get vehicle config!");
        return;
    }
    Pack.Parse(Packet.c_str());
    if (Pack.HasParseError() || Pack.IsNull()) {
        error("Could not get active vehicle config!");
        return;
    }
    for (auto& M : Pack.GetObject()) {
        if (Veh[M.name].IsNull()) {
            Veh.AddMember(M.name, M.value, Veh.GetAllocator());
        } else {
            Veh[M.name] = Pack[M.name];
        }
    }
    rapidjson::StringBuffer Buffer;
    rapidjson::Writer<rapidjson::StringBuffer> writer(Buffer);
    Veh.Accept(writer);
    c.SetCarData(VID, Header + Buffer.GetString());
 }
 void TServer::InsertClient(const std::shared_ptr<TClient>& NewClient) {
    debug("inserting client (" + std::to_string(ClientCount()) + ")");
    WriteLock Lock(mClientsMutex); //TODO why is there 30+ threads locked here
    (void)mClients.insert(NewClient);
 }
@@ -1,18 +0,0 @@
 #include "VehicleData.h"
 #include <utility>
 #include "Common.h"
 TVehicleData::TVehicleData(int ID, std::string Data)
    : mID(ID)
    , mData(std::move(Data)) {
 #ifdef DEBUG
    debug("vehicle " + std::to_string(mID) + " constructed");
 #endif
 }
 TVehicleData::~TVehicleData() {
 #ifdef DEBUG
    debug("vehicle " + std::to_string(mID) + " destroyed");
 #endif
 }
@@ -1,67 +0,0 @@
 #include "Common.h"
 #include "Http.h"
 #include "TConfig.h"
 #include "THeartbeatThread.h"
 #include "TLuaEngine.h"
 #include "TNetwork.h"
 #include "TPPSMonitor.h"
 #include "TResourceManager.h"
 #include "TServer.h"
 #include <thread>
 #ifdef __unix
 #include <csignal>
 void UnixSignalHandler(int sig) {
    switch (sig) {
    case SIGPIPE:
        warn("ignoring SIGPIPE");
        break;
    case SIGTERM:
        info("gracefully shutting down via SIGTERM");
        Application::GracefullyShutdown();
        break;
    case SIGINT:
        info("gracefully shutting down via SIGINT");
        Application::GracefullyShutdown();
        break;
    default:
        debug("unhandled signal: " + std::to_string(sig));
        break;
    }
 }
 #endif // __unix
 int main(int argc, char** argv) {
 #ifdef __unix
 #if DEBUG
    info("registering handlers for SIGINT, SIGTERM, SIGPIPE");
 #endif // DEBUG
    signal(SIGPIPE, UnixSignalHandler);
    signal(SIGTERM, UnixSignalHandler);
 #ifndef DEBUG
    signal(SIGINT, UnixSignalHandler);
 #endif // DEBUG
 #endif // __unix
    setlocale(LC_ALL, "C");
    bool Shutdown = false;
    Application::RegisterShutdownHandler([&Shutdown] { Shutdown = true; });
    TServer Server(argc, argv);
    [[maybe_unused]] TConfig Config("Server.cfg");
    RegisterThread("Main");
    TResourceManager ResourceManager;
    TPPSMonitor PPSMonitor(Server);
    THeartbeatThread Heartbeat(ResourceManager, Server);
    TNetwork Network(Server, PPSMonitor, ResourceManager);
    TLuaEngine LuaEngine(Server, Network);
    PPSMonitor.SetNetwork(Network);
    Application::Console().InitializeLuaConsole(LuaEngine);
    // TODO: replace
    while (!Shutdown) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
 }
Author	SHA1	Message	Date
Starystars67	6247191a3e	Further Tidy of unused files	2020-01-28 23:16:33 +00:00
Starystars67	d752ac5acb	Creation of NodeJS Branch	2020-01-28 23:04:21 +00:00
		`@@ -1 +0,0 @@`
			`Copyright (c) 2019-present Anonymous275. BeamMP Server code is not in the public domain and is not free software. One must be granted explicit permission by the copyright holder in order to modify or distribute any part of the source or binaries, the only permission that has been granted is to use the software in its compiled form as distributed from the BeamMP.com website. Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.`