mirror of
https://github.com/Cockatrice/Cockatrice.git
synced 2026-11-05 09:33:25 -08:00
ecd955bc60
* [Installer] Abort instead of installing over leftover runtime files
The silent upgrade could leave a mix of old and new Qt DLLs next to the new
executables, which is what makes the next start fail with "The procedure entry
point X could not be located in the dynamic link library ...Qt6QuickWidgets.dll"
or "The code execution cannot proceed because Qt6Multimedia.dll was not found".
The check that was supposed to catch this probed only Qt6Core.dll and
Qt6Network.dll, so it was blind to the two files the reports name. It also only
warned and then installed anyway, so a caught problem was still compounded.
- Scan every file the purge targets with FindFirst, which takes the same
wildcards the Delete/RMDir calls use, instead of two hardcoded names
- Widen IsExistingCockatriceInstall from Qt6Core.dll to Qt6*.dll so a directory
left holding only some Qt modules is still recognised as an install
- Gate the scan on that, so a first-time install into a directory that happens to
hold unrelated Qt5 DLLs is not turned into an abort
- Abort with a non-zero exit code instead of warning, so the new payload is
never written next to files of the previous version
- Skip the message box on an unattended /S install, which would block on it
forever, matching the two existing abort sites
* [Installer] Cancel a silent upgrade when the running-instance guard fails
The running instance guard is what stands between a locked install directory
and the mixed Qt DLL set that breaks the next start, but it failed open in two
places and let the install carry on anyway:
- powershell.exe could not be started: the check warned and returned
- the process lookup answered "could not determine": WaitForAppToClose returned
on $R0 != 1, so "unknown" was treated exactly like "not running"
On a silent upgrade there is nobody at the keyboard to close the applications in
response to that warning, which is precisely the state in which the launcher was
still holding its Qt DLLs mapped.
- Treat "could not determine" as its own state rather than folding it into "not
running", in all three places WaitForAppToClose inspects the result
- Cancel a silent upgrade in both cases; keep an interactive install on the
existing warn-and-continue path, since refusing there would leave an installer
that can never complete and the stale-runtime check still applies
- Route every abort through one AbortInstall so the dialog-vs-silent decision
lives in a single place, and stop the two pre-existing warning dialogs that a
/S install without /R would have blocked on forever
* [Installer] Wait on the process that launched the update installer
The in-app updater starts the installer and only then quits itself, so the
installer has to decide whether the launching process is still alive while it is
running. It did that by polling powershell.exe for an image name under the
install directory, which is a proxy for the real question - is the process that
started me still holding its Qt DLLs mapped - and a proxy that can answer "not
running" or "could not determine" while the process is very much alive. Either
answer let the install carry on into the mixed Qt DLL set.
Take /PID= from the command line and wait on that process handle directly:
- OpenProcess with PROCESS_SYNCHRONIZE only, which is all that is needed to wait
and the least likely to be refused for an unrelated reason
- WaitForSingleObject for the same 60 s the name based check allows, so a client
slow to flush its card database is not squeezed
- Treat an unopenable handle as "already exited", which is what it means for a
dead process
- Cancel the upgrade if the launcher has not exited, rather than replacing files
it is still using
Run it before EnsureAppsNotRunning, not after: it needs no powershell.exe, so it
is the one check that still works on a machine where the process lookup cannot
run, and it is what lets that case keep upgrading instead of being cancelled by
what was only ever a proxy for it. Keep an older client, which passes no /PID=,
on the existing path.
An older installer ignores /PID=, and /D= stays the last parameter either way.
* [Client] Pass our process id to the update installer
The updater starts the installer and only then quits itself, so the installer
begins replacing files while this process still has every Qt runtime DLL mapped,
and a mapped DLL cannot be deleted. It has to work out that it must wait, and
until now all it had was its own image name to go on.
Pass /PID= so it can wait on this process directly instead of guessing, and
cancel the update rather than replace files this process is still using. /D=
stays the last parameter, which NSIS requires.
* [CI] Fail the build when the installer is missing a Qt runtime DLL
The Windows payload is assembled by globbing every *.dll out of the build output
directories, so nothing but luck decides whether a module the client links
statically - Qt6Multimedia.dll, Qt6QuickWidgets.dll - reaches the installer at
all. A module that is left out is invisible until a user installs an update and
the client then refuses to start, with "The code execution cannot proceed because
Qt6Multimedia.dll was not found" or a missing procedure entry point in a
Qt6QuickWidgets.dll carried over from the previous version.
Derive the required list from SERVATRICE_QT_MODULES, COCKATRICE_QT_MODULES and
ORACLE_QT_MODULES, the same module lists the targets are actually built against,
so it cannot drift from what the binaries need, and write it next to the CMake
cache as required-qt-runtime.txt. Add the platform plugin, without which the
client cannot start at all.
Assert it in the existing 7-Zip pass that already rejects build-tree artifacts,
comparing exact relative paths so a same-named file in the wrong directory does
not satisfy a requirement, and normalizing the archive's own separators so it
does not matter which one NSIS chose. Missing manifest, missing entry or missing
7-Zip-independent failures all stop the build rather than warn, which is the
whole point: the previous check already failed hard for artifacts, and a warning
here is what let a broken package ship.
* [Client] Point the Windows qt.conf translations path at the real one
The Windows qt.conf carried Translations = Resources/translations, copied from
the macOS bundle block, but the Windows install has no Resources directory: the
.qm files are installed to COCKATRICE_WIN32_QM_INSTALL_DIR, which is
translations, and main.cpp looks for them at applicationDirPath() +
"/translations". Leave the macOS value alone, which is correct for it.
* [Installer] Close the /? help string so the installer compiles again
The last line of the continued MessageBox string ended in $\n\" instead of $\n".
NSIS reads \" as an escaped quote, so the string never terminated and makensis
rejected the script, which took the CPack packaging step down with it. The
Windows build failed on "Problem running NSIS command" before ever reaching the
new required-runtime check.
* [Installer] Give FindFirst the two arguments it takes
FindFirst takes the pattern and the output variable and leaves the search
handle in $0. There is no handle argument, and FindNext taking only a variable
is the giveaway: the handle has to live somewhere implicit, and it is $0.
The call passed three arguments, so makensis rejected the script and the CPack
packaging step failed with "Problem running NSIS command" before ever reaching
the required-runtime check.
This was not only a compile error. The handle variable was never populated, so
the stale-runtime check that commit 844a1a9b added could never see a match: it
probed $StaleFindHandle, which stayed empty, and the widened wildcard scan over
the purge set was a no-op. Pass the pattern, test $0, and close $0. No FindNext
is needed, because $R0 is a yes/no flag rather than a list.
Drops the now unused StaleFindHandle Var.
* [CI] Dump the NSIS compile log when packaging fails
CPack reports a failed makensis run as "Problem running NSIS command" plus a
path to NSISOutput.log, and that log exists only on the runner, so the actual
compile error never reaches the workflow output. An installer script that does
not compile is therefore undiagnosable from CI alone, which is exactly how a
three-argument FindFirst cost two build cycles here.
* [CI] Run the NSIS log dump under bash
The dump step used the default pwsh shell, where `find` resolves to Windows'
text-search find.exe rather than a file finder, so it died with "FIND:
Parameter format not correct" instead of printing anything. Pin shell: bash.
* [Installer] Test the error flag with LogicLib's ${Errors} condition
makensis rejected the script with "macro _If requires 4 parameter(s), passed
2" at the ClearErrors/OpenProcess pair. A ${If} condition cannot be a bare
$Var: LogicLib needs either a comparison or one of its flag macros, and a lone
$Errors splits into too few arguments for _If. ${Errors} is the documented flag
condition and is the same mechanism as the ${Silent} test already used here.
The dump step earned its keep - this took one run to locate rather than another
round of guessing.
* [Installer] Give FindFirst its handle back and stop blocking silent aborts
makensis: "FindFirst expects 3 parameters, got 2. Usage: FindFirst
$(user_var: handle output) $(user_var: filename output) filespec".
The previous commit was wrong about this. FindFirst does take the handle
explicitly, and FindNext finds it in $0 as a side effect of the FindFirst that
set it, which is why FindNext takes only a variable. The three-argument form the
stale-runtime check was written with was correct all along, and the two-argument
form broke it. Restored, along with Var StaleFindHandle.
That same commit inverted the interactive check in both abort paths.
`${If} $ReinstallMode = 1` with `${OrIfNot} ${Silent}` shows the message box
exactly when the install is the silent /R upgrade - the one case the comment
says must never block, since nothing will dismiss it and the installer hangs
until it is killed. Replaced with `${IfNot} ${Silent}`, so the box appears only
for an interactive install and a silent abort goes straight to SetErrorLevel.
Audited every construct added by this branch against master, which compiles:
all 9 LogicLib condition shapes have a master precedent, FindFirst is the only
FindFirst and is back to 3 arguments, Function/Section and block depth balance,
and the 12 lines with an odd number of quotes are the same pre-existing string
continuations master has.
* [CI] Strip the CR 7-Zip leaves on its paths before comparing them
The installer check reported all 14 required files missing, including
Qt6Core-era basics an 82 MB package obviously contains, so the payload was fine
and the comparison was broken. 7-Zip writes CRLF on Windows, sed 's/^Path = //p'
kept the \r on every line, and grep -qxF matches whole lines - so every entry
carried a trailing \r and nothing matched. The build-tree artifact check next to
it uses an unanchored grep -E and was unaffected, which is what made the two
checks disagree.
Reproduced locally against a 7z archive with CRLF injected: the old pipeline
matches nothing, the new one finds the present files and reports only the
genuinely absent one.
Also match case-insensitively. That is how the installed tree behaves - the
uninstaller clears both $INSTDIR\plugins and $INSTDIR\Plugins - so a
Plugins vs plugins difference in the archive is not a missing file.
* [CI] Print both sides of the installer path comparison, and strip its prefixes
The check still reported all 14 files missing after the CR fix, so the CR was
not the cause and the real difference between 7-Zip's output and the manifest
is still unknown. Inferring it again is what produced two wrong fixes in a row,
so on failure the check now prints the required list and the first 40 paths
7-Zip lists. A bare "missing" line cannot distinguish a missing file from a
misread listing, and twice it was the latter.
Also strip $INSTDIR/, $OUTDIR/, $PLUGINSDIR/ and ./ prefixes from the listed
paths. Written as separate -e expressions rather than one alternation: with |
as the sed delimiter an escaped \| is a literal pipe, so the alternation
version silently matched nothing at all.
Verified against a 7z archive fed through seven path shapes - plain, Windows
backslashes with CRLF, each prefix, lowercase plugins, and all of them combined
- each reporting only the file genuinely absent from the archive.
* [CI] Strip CR from the manifest side of the installer path check
The dump added last run settled it: 7-Zip listed 209 paths including Qt6Gui.dll,
Qt6Multimedia.dll and Plugins/platforms/qwindows.dll verbatim, as plain relative
paths with no prefix - so the archive side was already clean and the previous
fix was right to strip CR there but not sufficient.
The trailing CR was on the other side. CMake writes required-qt-runtime.txt
with the platform line ending, so on Windows $entry arrived as
"Qt6Gui.dll\r", which cannot whole-line match a clean "Qt6Gui.dll". Every
entry then read as missing while the listing held it, which is precisely what
the two sides of the dump showed.
Reproduced locally with a CRLF manifest against a 7z archive: without the strip
every entry is reported missing, with it only the genuinely absent file is.
Checked across plain paths, Windows backslashes with CRLF, $INSTDIR, $OUTDIR,
$PLUGINSDIR, ./ and / prefixes.
The literal $INSTDIR-style prefixes are written as [$] bracket expressions so
shellcheck does not read them as unexpanded variables; that clears the SC2016
that failed the format job, without a disable directive.
* [CI] Reword the bracket-expression comment so the linter stops parsing it
A comment whose first word is shellcheck is read as a directive, so
"# shellcheck does not read these as unexpanded shell variables" was parsed as
a directive named "does" and failed with SC1073 and SC1072 - which cascaded into
the SC1009 on the else clause above it. The SC2016 it was meant to document is
already gone now that the prefixes are written as [$] bracket expressions, so
the note only had to stop looking like a directive.
* [CI] Indent the diagnostic path lists without sed, and undo comment drift
SC2001 asks for parameter expansion instead of sed 's/^/ /'. Echoing
${manifest//$'\n'/$'\n '} prepends the two spaces directly and keeps the
diagnostic block readable. Both occurrences are converted; only the one reading
from a here-string was reported, but the piped one has the same shape.
Also restore master's wording of the build-tree artifact comment. An earlier
edit inserted "in " ("not the install)" became "not in the install)"). It has no
functional effect, but it was an unintended change to a line this branch has no
reason to touch, and .ci/compile.sh now differs from master only by additions.
* [CI] Ship the Qt module runtimes the Windows package check requires
The installer check reports Qt6Concurrent.dll and Qt6ShaderTools.dll missing
from the Windows package. Both are genuinely absent, not another comparison
artifact - the manifest now matches 12 of 14 entries and the dual-list
diagnostic shows the other two are not in the archive at all.
Nothing deploys them. fixup_bundle copies only the DLLs it finds in
Cockatrice.exe's import table, and the *.dll glob only sees what was already
copied next to the executable. Qt6::Concurrent is linked but never imported,
because QtConcurrent::run and QFutureWatcher are header-only in Qt 6, so the
linker drops the import; Qt6::ShaderTools is skipped the same way. The package
has shipped without them and the client still starts, but that is luck rather
than intent, and required-qt-runtime.txt asks for both.
Install the runtime of every linked module explicitly so the installer contains
what the check demands. An unused DLL costs a few hundred kilobytes; a missing
one is what stops the client starting after an update, and stays invisible until
then.
Derive both the manifest and the install list from the imported target's TYPE,
so a statically linked Qt module - which ships no runtime at all - is skipped by
each and the two can never disagree. Scope the manifest to the client rather
than the union across server, client and Oracle: only the client is packaged on
Windows, and the other two module lists are subsets of the client's, so this
changes nothing today.
---------
Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>
411 lines
15 KiB
CMake
411 lines
15 KiB
CMake
# Cockatrice's main CMakeLists.txt
|
|
#
|
|
# This is basically a wrapper to enable/disable the compilation
|
|
# of the different projects: servatrice, cockatrice, test
|
|
# This file sets all the variables shared between the projects
|
|
# like the installation path, compilation flags etc..
|
|
|
|
# 3.16 required for Qt6 and target_precompile_headers()
|
|
cmake_minimum_required(VERSION 3.16)
|
|
|
|
# Use compiler cache (ccache)
|
|
option(USE_CCACHE "Cache the build results with ccache" ON)
|
|
# Treat warnings as errors (Debug builds only)
|
|
option(WARNING_AS_ERROR "Treat warnings as errors in debug builds" ON)
|
|
# Check for translation updates
|
|
option(UPDATE_TRANSLATIONS "Update translations on compile" OFF)
|
|
# Compile Cockatrice
|
|
option(WITH_CLIENT "Build Cockatrice client" ON)
|
|
# Compile Oracle
|
|
option(WITH_ORACLE "Build Cockatrice card database tool (Oracle)" ON)
|
|
# Compile Servatrice
|
|
option(WITH_SERVER "Build Cockatrice server (Servatrice)" OFF)
|
|
# Compile tests
|
|
option(TEST "Build tests" OFF)
|
|
# Use vcpkg regardless of OS
|
|
option(USE_VCPKG "Use vcpkg regardless of OS" OFF)
|
|
|
|
# Default to "Release" build type
|
|
# User-provided value for CMAKE_BUILD_TYPE must be checked before the PROJECT() call
|
|
if(DEFINED CMAKE_BUILD_TYPE)
|
|
set(CMAKE_BUILD_TYPE
|
|
${CMAKE_BUILD_TYPE}
|
|
CACHE STRING "Type of build"
|
|
)
|
|
else()
|
|
set(CMAKE_BUILD_TYPE
|
|
Release
|
|
CACHE STRING "Type of build"
|
|
)
|
|
endif()
|
|
|
|
# ccache does not support MSVC and must not auto-engage on Windows
|
|
# (it is installed unintentionally on the Windows CI runner).
|
|
# NOTE: this keys off the target OS, so a mingw/Ninja configuration on Windows
|
|
# also opts out of ccache even though the GNUCXX branch below supports it.
|
|
if(USE_CCACHE AND NOT WIN32)
|
|
find_program(CCACHE_PROGRAM ccache)
|
|
if(CCACHE_PROGRAM)
|
|
# Support Unix Makefiles and Ninja
|
|
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
|
|
# PCH-aware caching, matching .ci/compile.sh: without this ccache refuses
|
|
# to cache any TU that consumes a precompiled header, so every PCH-backed
|
|
# target recompiles from scratch on each build.
|
|
execute_process(COMMAND ${CCACHE_PROGRAM} --set-config sloppiness=pch_defines,time_macros)
|
|
message(STATUS "Found CCache ${CCACHE_PROGRAM}")
|
|
endif()
|
|
elseif(USE_CCACHE AND WIN32)
|
|
# An explicit opt-in must not disappear silently on Windows.
|
|
message(STATUS "ccache disabled: not supported for the MSVC toolchain on Windows")
|
|
endif()
|
|
|
|
if(WIN32 OR USE_VCPKG)
|
|
# Use vcpkg toolchain on Windows (and on macOS in CI)
|
|
set(CMAKE_TOOLCHAIN_FILE
|
|
${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake
|
|
CACHE STRING "Vcpkg toolchain file"
|
|
)
|
|
# Qt path set by user or env var
|
|
if(QTDIR
|
|
OR DEFINED ENV{QTDIR}
|
|
OR DEFINED ENV{QTDIR32}
|
|
OR DEFINED ENV{QTDIR64}
|
|
)
|
|
|
|
else()
|
|
set(QTDIR
|
|
""
|
|
CACHE PATH "Path to Qt (e.g. C:/Qt/6.4.2/msvc2019_64)"
|
|
)
|
|
message(
|
|
WARNING
|
|
"QTDIR variable is missing. Please set this variable to specify path to Qt (e.g. C:/Qt/6.4.2/msvc2019_64)"
|
|
)
|
|
endif()
|
|
endif()
|
|
|
|
# A project name is needed for CPack
|
|
# Version can be overriden by git tags, see cmake/getversion.cmake
|
|
project("Cockatrice" VERSION 3.1.0)
|
|
|
|
# Set release name if not provided via env/cmake var
|
|
if(NOT DEFINED GIT_TAG_RELEASENAME)
|
|
set(GIT_TAG_RELEASENAME "Graduation Day")
|
|
endif()
|
|
|
|
# Use c++20 for all targets
|
|
set(CMAKE_CXX_STANDARD
|
|
20
|
|
CACHE STRING "C++ ISO Standard"
|
|
)
|
|
set(CMAKE_CXX_STANDARD_REQUIRED True)
|
|
|
|
# Set conventional loops
|
|
set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
|
|
|
|
# Search path for cmake modules
|
|
set(COCKATRICE_CMAKE_PATH "${PROJECT_SOURCE_DIR}/cmake")
|
|
list(INSERT CMAKE_MODULE_PATH 0 "${COCKATRICE_CMAKE_PATH}")
|
|
|
|
include(getversion)
|
|
|
|
# Create a header and a cpp file containing the version hash
|
|
include(createversionfile)
|
|
|
|
# Define a proper install path
|
|
if(UNIX)
|
|
if(APPLE)
|
|
# macOS
|
|
# Due to the special bundle structure ignore
|
|
# the prefix eventually set by the user.
|
|
set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/release)
|
|
|
|
# Force ccache usage if available
|
|
get_property(RULE_LAUNCH_COMPILE GLOBAL PROPERTY RULE_LAUNCH_COMPILE)
|
|
if(RULE_LAUNCH_COMPILE)
|
|
message(STATUS "Force enabling CCache usage under macOS")
|
|
# Set up wrapper scripts
|
|
configure_file("${COCKATRICE_CMAKE_PATH}/launch-c.in" launch-c)
|
|
configure_file("${COCKATRICE_CMAKE_PATH}/launch-cxx.in" launch-cxx)
|
|
execute_process(COMMAND chmod a+rx "${CMAKE_BINARY_DIR}/launch-c" "${CMAKE_BINARY_DIR}/launch-cxx")
|
|
|
|
# Set Xcode project attributes to route compilation through our scripts
|
|
set(CMAKE_XCODE_ATTRIBUTE_CC "${CMAKE_BINARY_DIR}/launch-c")
|
|
set(CMAKE_XCODE_ATTRIBUTE_CXX "${CMAKE_BINARY_DIR}/launch-cxx")
|
|
set(CMAKE_XCODE_ATTRIBUTE_LD "${CMAKE_BINARY_DIR}/launch-c")
|
|
set(CMAKE_XCODE_ATTRIBUTE_LDPLUSPLUS "${CMAKE_BINARY_DIR}/launch-cxx")
|
|
endif()
|
|
else()
|
|
# Linux / BSD
|
|
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
|
|
#fix package build
|
|
if(PREFIX)
|
|
set(CMAKE_INSTALL_PREFIX ${PREFIX})
|
|
else()
|
|
set(CMAKE_INSTALL_PREFIX /usr/local)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
elseif(WIN32)
|
|
set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/rundir/${CMAKE_BUILD_TYPE})
|
|
endif()
|
|
|
|
# Define proper compilation flags
|
|
if(MSVC)
|
|
# Disable Warning C4251, C++20 compatibility, Multi-threaded Builds, Warn Detection, Unwind Semantics, Debug Symbols
|
|
set(CMAKE_CXX_FLAGS "/wd4251 /Zc:__cplusplus /std:c++20 /permissive- /W4 /MP /EHsc /Zi")
|
|
# Visual Studio: Maximum Optimization, Multi-threaded DLL
|
|
set(CMAKE_CXX_FLAGS_RELEASE "/Ox /MD")
|
|
# Visual Studio: No Optimization, Multi-threaded Debug DLL
|
|
set(CMAKE_CXX_FLAGS_DEBUG "/Od /MDd")
|
|
|
|
# Generate PDB, even when in release (So developers can better analyze crash logs)
|
|
set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
|
|
|
|
add_compile_definitions(_SILENCE_STDEXT_ARR_ITERS_DEPRECATION_WARNING)
|
|
elseif(CMAKE_COMPILER_IS_GNUCXX)
|
|
# linux/gcc, bsd/gcc, windows/mingw
|
|
include(CheckCXXCompilerFlag)
|
|
|
|
set(CMAKE_CXX_FLAGS_RELEASE "-s -O2")
|
|
if(WARNING_AS_ERROR)
|
|
set(CMAKE_CXX_FLAGS_DEBUG "-ggdb -O0 -Wall -Wextra -Werror")
|
|
else()
|
|
set(CMAKE_CXX_FLAGS_DEBUG "-ggdb -O0 -Wall -Wextra")
|
|
endif()
|
|
|
|
if(APPLE)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++20")
|
|
endif()
|
|
|
|
set(ADDITIONAL_DEBUG_FLAGS
|
|
-Wcast-align
|
|
-Wmissing-declarations
|
|
-Wno-long-long
|
|
-Wno-error=extra
|
|
-Wno-error=delete-non-virtual-dtor
|
|
-Wno-error=sign-compare
|
|
-Wno-error=missing-declarations
|
|
-Wno-error=sfinae-incomplete # GCC 16+: Qt MOC + protobuf forward decls trigger this
|
|
)
|
|
|
|
foreach(FLAG ${ADDITIONAL_DEBUG_FLAGS})
|
|
check_cxx_compiler_flag("${FLAG}" CXX_HAS_WARNING_${FLAG})
|
|
if(CXX_HAS_WARNING_${FLAG})
|
|
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${FLAG}")
|
|
endif()
|
|
endforeach()
|
|
|
|
# Reduce compiler I/O by using pipes between stages instead of temp files
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pipe")
|
|
else()
|
|
# other: osx/llvm, bsd/llvm
|
|
set(CMAKE_CXX_FLAGS_RELEASE "-O2")
|
|
if(WARNING_AS_ERROR)
|
|
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -Wall -Wextra -Werror -Wno-unused-parameter")
|
|
else()
|
|
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -Wall -Wextra")
|
|
endif()
|
|
|
|
# Reduce compiler I/O by using pipes between stages instead of temp files
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pipe")
|
|
endif()
|
|
|
|
# GNU systems need to define the Mersenne exponent for the RNG to compile w/o warning
|
|
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
|
|
add_definitions("-DSFMT_MEXP=19937")
|
|
endif()
|
|
|
|
find_package(Threads REQUIRED)
|
|
|
|
# Determine 32 or 64 bit build
|
|
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
|
|
set(_lib_suffix 64)
|
|
else()
|
|
set(_lib_suffix 32)
|
|
endif()
|
|
|
|
if(DEFINED QTDIR${_lib_suffix})
|
|
list(APPEND CMAKE_PREFIX_PATH "${QTDIR${_lib_suffix}}")
|
|
elseif(DEFINED QTDIR)
|
|
list(APPEND CMAKE_PREFIX_PATH "${QTDIR}")
|
|
elseif(DEFINED ENV{QTDIR${_lib_suffix}})
|
|
list(APPEND CMAKE_PREFIX_PATH "$ENV{QTDIR${_lib_suffix}}")
|
|
elseif(DEFINED ENV{QTDIR})
|
|
list(APPEND CMAKE_PREFIX_PATH "$ENV{QTDIR}")
|
|
endif()
|
|
|
|
message(STATUS "Update Translations: ${UPDATE_TRANSLATIONS}")
|
|
|
|
include(FindQtRuntime)
|
|
|
|
set(CMAKE_AUTOMOC TRUE)
|
|
|
|
# Find other needed libraries
|
|
find_package(Protobuf CONFIG)
|
|
if(NOT Protobuf_FOUND)
|
|
find_package(Protobuf REQUIRED)
|
|
endif()
|
|
|
|
if(${Protobuf_VERSION} VERSION_LESS "3.21.0.0" AND NOT EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
|
|
message(FATAL_ERROR "No protoc command found!")
|
|
endif()
|
|
|
|
#Find OpenSSL
|
|
if(WIN32)
|
|
find_package(OpenSSL REQUIRED)
|
|
if(OPENSSL_FOUND)
|
|
include_directories(${OPENSSL_INCLUDE_DIRS})
|
|
endif()
|
|
endif()
|
|
|
|
#Find VCredist
|
|
if(MSVC)
|
|
find_package(VCredistRuntime)
|
|
endif()
|
|
|
|
# Package builder
|
|
set(CPACK_PACKAGE_CONTACT "Zach Halpern <zach@cockatrice.us>")
|
|
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${PROJECT_NAME}")
|
|
set(CPACK_PACKAGE_VENDOR "Cockatrice Development Team")
|
|
set(CPACK_PACKAGE_DESCRIPTION
|
|
"Cockatrice is an open-source, multiplatform application for playing tabletop card games over a network. The program's server design prevents users from manipulating the game for unfair advantage. The client also provides a single-player mode, which allows users to brew while offline."
|
|
)
|
|
set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")
|
|
set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
|
|
set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
|
|
set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
|
|
set(CPACK_PACKAGE_FILE_NAME "${PROJECT_VERSION_FILENAME}")
|
|
|
|
if(UNIX)
|
|
if(APPLE)
|
|
set(CPACK_GENERATOR DragNDrop ${CPACK_GENERATOR})
|
|
set(CPACK_GENERATOR "DragNDrop")
|
|
set(CPACK_DMG_FORMAT "UDBZ")
|
|
set(CPACK_DMG_VOLUME_NAME "${PROJECT_NAME}")
|
|
set(CPACK_SYSTEM_NAME "OSX")
|
|
set(CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}/cockatrice/resources/appicon.icns")
|
|
set(CPACK_DMG_DS_STORE_SETUP_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/cmake/CMakeDMGSetup.script")
|
|
set(CPACK_DMG_BACKGROUND_IMAGE "${CMAKE_CURRENT_SOURCE_DIR}/cmake/dmgBackground.tif")
|
|
set(CPACK_PRE_BUILD_SCRIPTS "${CMAKE_CURRENT_SOURCE_DIR}/cmake/SignMacApplications.cmake")
|
|
else()
|
|
# linux
|
|
if(CPACK_GENERATOR STREQUAL "RPM")
|
|
set(CPACK_RPM_PACKAGE_LICENSE "GPLv2")
|
|
set(CPACK_RPM_MAIN_COMPONENT "cockatrice")
|
|
set(CPACK_RPM_PACKAGE_REQUIRES "protobuf, qt6-qtimageformats, qt6-qtmultimedia, qt6-qtsvg, qt6-qttools")
|
|
set(CPACK_RPM_PACKAGE_GROUP "Amusements/Games")
|
|
set(CPACK_RPM_PACKAGE_URL "http://github.com/Cockatrice/Cockatrice")
|
|
# stop directories from making package conflicts
|
|
set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
|
|
/usr/share/applications
|
|
/usr/share/icons
|
|
/usr/share/icons/hicolor
|
|
/usr/share/icons/hicolor/48x48
|
|
/usr/share/icons/hicolor/48x48/apps
|
|
/usr/share/icons/hicolor/scalable
|
|
/usr/share/icons/hicolor/scalable/apps
|
|
)
|
|
else()
|
|
set(CPACK_GENERATOR DEB)
|
|
set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
|
|
set(CPACK_DEBIAN_PACKAGE_SECTION "games")
|
|
set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "http://github.com/Cockatrice/Cockatrice")
|
|
set(CPACK_DEBIAN_PACKAGE_DEPENDS "libqt6multimedia6, libqt6svg6, qt6-image-formats-plugins, qt6-qpa-plugins")
|
|
set(CPACK_DEBIAN_PACKAGE_RECOMMENDS "libqt6sql6-mysql") # for connecting servatrice to a mysql db
|
|
endif()
|
|
endif()
|
|
elseif(WIN32)
|
|
set(CPACK_GENERATOR NSIS ${CPACK_GENERATOR})
|
|
if("${CMAKE_GENERATOR_PLATFORM}" MATCHES "(x64)")
|
|
set(TRICE_IS_64_BIT 1)
|
|
else()
|
|
set(TRICE_IS_64_BIT 0)
|
|
endif()
|
|
|
|
# Configure file with custom definitions for NSIS.
|
|
configure_file("${COCKATRICE_CMAKE_PATH}/NSIS.definitions.nsh.in" "${PROJECT_BINARY_DIR}/NSIS.definitions.nsh")
|
|
|
|
# Every Qt module the client links against, as the DLL names a Windows install
|
|
# has to contain, plus the platform plugin without which the client cannot
|
|
# start. .ci/compile.sh reads this and fails the build when the packaged
|
|
# installer is missing one of them.
|
|
#
|
|
# Only the client is packaged on Windows, so this is the client's module list
|
|
# rather than the union across server, client and Oracle: demanding Oracle's or
|
|
# Servatrice's modules of the client installer checks nothing about the client.
|
|
#
|
|
# A statically linked Qt module ships no runtime DLL, so requiring one would
|
|
# fail the package check on a static build for no reason. cockatrice/CMakeLists.txt
|
|
# installs the runtime of every module listed here, and skips static ones the
|
|
# same way, so the two can never disagree.
|
|
#
|
|
# A DLL missing from the package only surfaces on a user's machine, after an
|
|
# update has already replaced their install, as "The code execution cannot
|
|
# proceed because Qt6Multimedia.dll was not found" or as a missing procedure
|
|
# entry point in a Qt6QuickWidgets.dll left over from the previous version.
|
|
# Assert it while the installer is still being built instead.
|
|
set(_required_qt_runtime "")
|
|
foreach(_qt_module IN LISTS COCKATRICE_QT_MODULES)
|
|
get_target_property(_qt_module_type ${_qt_module} TYPE)
|
|
if(_qt_module_type STREQUAL "SHARED_LIBRARY")
|
|
string(REGEX REPLACE "^Qt6::" "" _qt_component "${_qt_module}")
|
|
list(APPEND _required_qt_runtime "Qt6${_qt_component}.dll")
|
|
endif()
|
|
endforeach()
|
|
list(APPEND _required_qt_runtime "Plugins/platforms/qwindows.dll")
|
|
list(REMOVE_DUPLICATES _required_qt_runtime)
|
|
list(SORT _required_qt_runtime)
|
|
string(REPLACE ";" "\n" _required_qt_runtime "${_required_qt_runtime}")
|
|
file(WRITE "${PROJECT_BINARY_DIR}/required-qt-runtime.txt" "${_required_qt_runtime}\n")
|
|
|
|
# include vcredist into the package; NSIS will take care of running it
|
|
if(VCREDISTRUNTIME_FOUND)
|
|
install(FILES "${VCREDISTRUNTIME_FILE}" DESTINATION ./)
|
|
endif()
|
|
endif()
|
|
|
|
include(CPack)
|
|
|
|
add_subdirectory(${CMAKE_SOURCE_DIR}/libcockatrice_interfaces ${CMAKE_BINARY_DIR}/libcockatrice_interfaces)
|
|
add_subdirectory(${CMAKE_SOURCE_DIR}/libcockatrice_protocol ${CMAKE_BINARY_DIR}/libcockatrice_protocol)
|
|
if(WITH_CLIENT
|
|
OR WITH_SERVER
|
|
OR WITH_ORACLE
|
|
)
|
|
add_subdirectory(${CMAKE_SOURCE_DIR}/libcockatrice_network ${CMAKE_BINARY_DIR}/libcockatrice_network)
|
|
endif()
|
|
add_subdirectory(${CMAKE_SOURCE_DIR}/libcockatrice_deck_list ${CMAKE_BINARY_DIR}/libcockatrice_deck_list)
|
|
add_subdirectory(${CMAKE_SOURCE_DIR}/libcockatrice_rng ${CMAKE_BINARY_DIR}/libcockatrice_rng)
|
|
add_subdirectory(${CMAKE_SOURCE_DIR}/libcockatrice_card ${CMAKE_BINARY_DIR}/libcockatrice_card)
|
|
add_subdirectory(${CMAKE_SOURCE_DIR}/libcockatrice_utility ${CMAKE_BINARY_DIR}/libcockatrice_utility)
|
|
if(WITH_ORACLE OR WITH_CLIENT)
|
|
add_subdirectory(${CMAKE_SOURCE_DIR}/libcockatrice_settings ${CMAKE_BINARY_DIR}/libcockatrice_settings)
|
|
add_subdirectory(${CMAKE_SOURCE_DIR}/libcockatrice_models ${CMAKE_BINARY_DIR}/libcockatrice_models)
|
|
add_subdirectory(${CMAKE_SOURCE_DIR}/libcockatrice_filters ${CMAKE_BINARY_DIR}/libcockatrice_filters)
|
|
endif()
|
|
|
|
if(WITH_SERVER)
|
|
add_subdirectory(servatrice)
|
|
set(CPACK_INSTALL_CMAKE_PROJECTS "Servatrice;Servatrice;ALL;/" ${CPACK_INSTALL_CMAKE_PROJECTS})
|
|
endif()
|
|
|
|
if(WITH_CLIENT)
|
|
add_subdirectory(cockatrice)
|
|
set(CPACK_INSTALL_CMAKE_PROJECTS "Cockatrice;Cockatrice;ALL;/" ${CPACK_INSTALL_CMAKE_PROJECTS})
|
|
endif()
|
|
|
|
if(WITH_ORACLE)
|
|
add_subdirectory(oracle)
|
|
set(CPACK_INSTALL_CMAKE_PROJECTS "Oracle;Oracle;ALL;/" ${CPACK_INSTALL_CMAKE_PROJECTS})
|
|
endif()
|
|
|
|
if(TEST)
|
|
include(CTest)
|
|
add_subdirectory(tests)
|
|
endif()
|
|
|
|
if(Qt6_FOUND AND Qt6_VERSION_MINOR GREATER_EQUAL 3)
|
|
# Qt6.3+ requires project finalization to support translations
|
|
qt6_finalize_project()
|
|
endif()
|