libicu-dev \

          liblzma-dev \

          liblzo2-dev \

          ${{ matrix.libraries }} \

          zlib1g-dev \

          # EOF

        echo "::endgroup::"

      env:

        DEBIAN_FRONTEND: noninteractive

    - name: Get OpenGFX

      run: |

    - name: Build

      run: |

        mkdir build

        cd build

        echo "::group::CMake"

        echo "::endgroup::"

        echo "::group::Build"

        echo "Running on $(nproc) cores"

        cmake --build . -j $(nproc)

        echo "::endgroup::"

        restore-keys: |

          ${{ steps.key.outputs.image }}-vcpkg-${{ matrix.arch }}

    - name: Prepare vcpkg

      run: |

        vcpkg install --triplet=${{ matrix.arch }}-osx \

          curl \

          liblzma \

          libpng \

          lzo \

          nlohmann-json \

          zlib \

          ${{ steps.key.outputs.image }}-vcpkg-${{ matrix.arch }}

    - name: Prepare vcpkg

      shell: bash

      run: |

        vcpkg install --triplet=${{ matrix.arch }}-windows-static \

          liblzma \

          libpng \

          lzo \

          nlohmann-json \

          zlib \

          # EOF

          # Make Python3 available for other packages.

          ./vcpkg install python3

          ln -sf $(pwd)/installed/x64-linux/tools/python3/python3.[0-9][0-9] /usr/bin/python3

          ./vcpkg install \

            curl[http2] \

            fontconfig \

            freetype \

            harfbuzz \

            icu \

            liblzma \

          ${{ steps.key.outputs.image }}-vcpkg-release

          ${{ steps.key.outputs.image }}-vcpkg-x64

    - name: Prepare vcpkg

      run: |

        vcpkg install \

          curl:x64-osx \

          curl:arm64-osx \

          liblzma:x64-osx \

          liblzma:arm64-osx \

          libpng:x64-osx \

          libpng:arm64-osx \

          ${{ steps.key.outputs.image }}-vcpkg-${{ matrix.arch }}

    - name: Prepare vcpkg

      shell: bash

      run: |

        vcpkg install --triplet=${{ matrix.arch }}-windows-static \

          liblzma \

          libpng \

          lzo \

          nlohmann-json \

          zlib \

          # EOF

    # Emscripten uses Javascript for HTTP requests.

else()

    # All other targets use libcurl.

    find_package(CURL)

endif()

if(NOT OPTION_DEDICATED)

    if(NOT WIN32)

        find_package(Allegro)

        if(NOT APPLE)

            find_package(Freetype)

            find_package(SDL2)

link_package(nlohmann_json ENCOURAGED)

if(NOT WIN32 AND NOT EMSCRIPTEN)

    link_package(CURL ENCOURAGED)

endif()

if(NOT OPTION_DEDICATED)

    link_package(Fluidsynth)

    link_package(SDL)

    link_package(SDL2 TARGET SDL2::SDL2)

    link_package(Allegro)

    link_package(FREETYPE TARGET Freetype::Freetype)

## Required/optional libraries

OpenTTD makes use of the following external libraries:

- (encouraged) nlohmann-json: JSON handling

- (encouraged) zlib: (de)compressing of old (0.3.0-1.0.5) savegames, content downloads,

   heightmaps

- (encouraged) liblzma: (de)compressing of savegames (1.1.0 and later)

- (encouraged) libpng: making screenshots and loading heightmaps

- (optional) liblzo2: (de)compressing of old (pre 0.3.0) savegames

by following the `Quick Start` instructions of their

[README](https://github.com/Microsoft/vcpkg/blob/master/README.md).

After this, you can install the dependencies OpenTTD needs. We advise to use

the `static` versions, and OpenTTD currently needs the following dependencies:

- liblzma

- libpng

- lzo

- nlohmann-json

- zlib

To install both the x64 (64bit) and x86 (32bit) variants (though only one is necessary), you can use:

```ps

```

You can open the folder (as a CMake project). CMake will be detected, and you can compile from there.

If libraries are installed but not found, you need to set VCPKG_TARGET_TRIPLET in CMake parameters.

For Visual Studio 2017 you also need to set CMAKE_TOOLCHAIN_FILE.

(Typical values are shown in the MSVC project file command line example)

# with Windows.

#

# NOTE: this is based on the assumption that the debug file has the same

# name as the optimized file. This is not always the case, but so far

# experiences has shown that in those case vcpkg CMake files do the right

# thing.

    if(LZO_LIBRARY MATCHES "/debug/")

        set(LZO_LIBRARY_DEBUG ${LZO_LIBRARY})

        string(REPLACE "/debug/lib/" "/lib/" LZO_LIBRARY_RELEASE ${LZO_LIBRARY})

    else()

        set(LZO_LIBRARY_RELEASE ${LZO_LIBRARY})

        string(REPLACE "/lib/" "/debug/lib/" LZO_LIBRARY_DEBUG ${LZO_LIBRARY})

function(link_package NAME)

    cmake_parse_arguments(LP "ENCOURAGED" "TARGET" "" ${ARGN})

    if(${NAME}_FOUND)

        string(TOUPPER "${NAME}" UCNAME)

        add_definitions(-DWITH_${UCNAME})

        # Some libraries' cmake packages (looking at you, SDL2) leave trailing whitespace in the link commands,

        # which (later) cmake considers to be an error. Work around this with by stripping the incoming string.

        if(LP_TARGET AND TARGET ${LP_TARGET})

            string(STRIP "${LP_TARGET}" LP_TARGET)

            target_link_libraries(openttd_lib ${LP_TARGET})

	size_t written = fwrite(this->crashlog.data(), 1, len, file);

	FioFCloseFile(file);

	return len == written;

}

/* virtual */ int CrashLog::WriteCrashDump()

{

	return 0;

}

/**

 * Write the (crash) savegame to a file.

 * @note The filename will be written to \c savegame_filename.

		fmt::print("Crash log written to {}. Please add this file to any bug reports.\n\n", this->crashlog_filename);

	} else {

		fmt::print("Writing crash log failed. Please attach the output above to any bug reports.\n\n");

		ret = false;

	}

	int dret = this->WriteCrashDump();

	if (dret < 0) {

		fmt::print("Writing crash dump failed.\n\n");

		ret = false;

	} else if (dret > 0) {

		fmt::print("Crash dump written to {}. Please add this file to any bug reports.\n\n", this->crashdump_filename);

	}

	fmt::print("Writing crash savegame...\n");

	bret = this->WriteSavegame();

	if (bret) {

		fmt::print("Crash savegame written to {}. Please add this file and the last (auto)save to any bug reports.\n\n", this->savegame_filename);

	std::string savegame_filename;

	std::string screenshot_filename;

	void FillCrashLog(std::back_insert_iterator<std::string> &output_iterator) const;

	bool WriteCrashLog();

	virtual int WriteCrashDump();

	bool WriteSavegame();

	bool WriteScreenshot();

	void SendSurvey() const;

 */

/** @file crashlog_osx.cpp OS X crash log handler */

#include "../../stdafx.h"

#include "../../crashlog.h"

#include "../../string_func.h"

#include "../../gamelog.h"

#include "../../saveload/saveload.h"

#include "../../video/video_driver.hpp"

#include "macos.h"

#include <signal.h>

#include <mach-o/arch.h>

#include <dlfcn.h>

#include <cxxabi.h>

#include "../../safeguards.h"

/* Macro testing a stack address for valid alignment. */

#if defined(__i386__)

#define IS_ALIGNED(addr) (((uintptr_t)(addr) & 0xf) == 8)

			frame = next;

		}

		fmt::format_to(output_iterator, "\n");

	}

public:

	/**

	 * A crash log is always generated by signal.

	 * @param signum the signal that was caused by the crash.

	 */

	CrashLogOSX(int signum) : signum(signum) {}

		static const char crash_title[] =

			"A serious fault condition occurred in the game. The game will shut down.";

		std::string message = fmt::format(

				 "Please send the generated crash information and the last (auto)save to the developers. "

				 "This will greatly help debugging. The correct place to do this is https://github.com/OpenTTD/OpenTTD/issues.\n\n"

		ShowMacDialog(crash_title, message.c_str(), "Quit");

	}

};

/** The signals we want our crash handler to handle. */

 */

/** @file crashlog_unix.cpp Unix crash log handler */

#include "../../stdafx.h"

#include "../../crashlog.h"

#include "../../string_func.h"

#include "../../gamelog.h"

#include "../../saveload/saveload.h"

#include <signal.h>

#include <sys/utsname.h>

#endif

#if defined(__NetBSD__)

#include <unistd.h>

#endif

#include "../../safeguards.h"

/**

 * Unix implementation for the crash logger.

 */

class CrashLogUnix : public CrashLog {

		free(messages);

#else

		fmt::format_to(output_iterator, " Not supported.\n");

#endif

		fmt::format_to(output_iterator, "\n");

	}

public:

	/**

	 * A crash log is always generated by signal.

	 * @param signum the signal that was caused by the crash.

	 */

	CrashLogUnix(int signum) :

#include <windows.h>

#include <mmsystem.h>

#include <signal.h>

#include <psapi.h>

#include "../../safeguards.h"

/**

 * Windows implementation for the crash logger.

 */

class CrashLogWindows : public CrashLog {

	void LogOSVersion(std::back_insert_iterator<std::string> &output_iterator) const override;

	void LogError(std::back_insert_iterator<std::string> &output_iterator, const std::string_view message) const override;

	void LogStacktrace(std::back_insert_iterator<std::string> &output_iterator) const override;

	void LogModules(std::back_insert_iterator<std::string> &output_iterator) const override;

public:

#if defined(_MSC_VER)

	void AppendDecodedStacktrace(std::back_insert_iterator<std::string> &output_iterator) const;

#else

	void AppendDecodedStacktrace(std::back_insert_iterator<std::string> &output_iterator) const {}

#endif /* _MSC_VER */

	/**

}

#if defined(_MSC_VER)

static const uint MAX_SYMBOL_LEN = 512;

static const uint MAX_FRAMES     = 64;

void CrashLogWindows::AppendDecodedStacktrace(std::back_insert_iterator<std::string> &output_iterator) const

{

	DllLoader dbghelp(L"dbghelp.dll");

	struct ProcPtrs {

		BOOL (WINAPI * pSymInitialize)(HANDLE, PCSTR, BOOL);

		BOOL (WINAPI * pSymSetOptions)(DWORD);

		proc.pSymCleanup(hCur);

	}

	fmt::format_to(output_iterator, "\n*** End of additional info ***\n");

}

#endif /* _MSC_VER */

extern bool CloseConsoleLogIfActive();

static void ShowCrashlogWindow();

/**