|
|
@@ -0,0 +1,499 @@
|
|
|
+#!/usr/bin/env python3
|
|
|
+"""
|
|
|
+Standard-of-Iron — Windows Build Script
|
|
|
+Verifies dependencies, sets up MSVC environment, and builds the project.
|
|
|
+
|
|
|
+This script automates the Windows build process by:
|
|
|
+1. Checking for required tools (CMake, Ninja, MSVC, Qt)
|
|
|
+2. Guiding installation of missing dependencies
|
|
|
+3. Configuring and building the project with proper MSVC setup
|
|
|
+4. Deploying Qt dependencies
|
|
|
+5. Copying assets and creating a distributable package
|
|
|
+
|
|
|
+Usage:
|
|
|
+ python scripts/build-windows.py # Full build with checks
|
|
|
+ python scripts/build-windows.py --skip-checks # Skip dependency checks
|
|
|
+ python scripts/build-windows.py --build-type Debug # Build in Debug mode
|
|
|
+ python scripts/build-windows.py --clean # Clean build directory first
|
|
|
+ python scripts/build-windows.py --deploy-only # Only deploy Qt (assumes built)
|
|
|
+ python scripts/build-windows.py --help # Show this help
|
|
|
+
|
|
|
+Requirements:
|
|
|
+ - Python 3.7+
|
|
|
+ - CMake 3.21+
|
|
|
+ - Ninja build system
|
|
|
+ - Visual Studio 2019/2022 with C++ tools
|
|
|
+ - Qt 6.6.3 or compatible (with msvc2019_64 or msvc2022_64)
|
|
|
+"""
|
|
|
+
|
|
|
+import argparse
|
|
|
+import os
|
|
|
+import platform
|
|
|
+import re
|
|
|
+import shutil
|
|
|
+import subprocess
|
|
|
+import sys
|
|
|
+from pathlib import Path
|
|
|
+from typing import Optional, Tuple
|
|
|
+
|
|
|
+# ANSI color codes for better output
|
|
|
+class Color:
|
|
|
+ BLUE = '\033[1;34m'
|
|
|
+ GREEN = '\033[1;32m'
|
|
|
+ YELLOW = '\033[1;33m'
|
|
|
+ RED = '\033[1;31m'
|
|
|
+ RESET = '\033[0m'
|
|
|
+ BOLD = '\033[1m'
|
|
|
+
|
|
|
+def info(msg: str) -> None:
|
|
|
+ """Print info message."""
|
|
|
+ print(f"{Color.BLUE}[i]{Color.RESET} {msg}")
|
|
|
+
|
|
|
+def success(msg: str) -> None:
|
|
|
+ """Print success message."""
|
|
|
+ print(f"{Color.GREEN}[✓]{Color.RESET} {msg}")
|
|
|
+
|
|
|
+def warning(msg: str) -> None:
|
|
|
+ """Print warning message."""
|
|
|
+ print(f"{Color.YELLOW}[!]{Color.RESET} {msg}")
|
|
|
+
|
|
|
+def error(msg: str) -> None:
|
|
|
+ """Print error message."""
|
|
|
+ print(f"{Color.RED}[✗]{Color.RESET} {msg}")
|
|
|
+
|
|
|
+def run_command(cmd: list, capture_output: bool = False, check: bool = True,
|
|
|
+ env: Optional[dict] = None) -> subprocess.CompletedProcess:
|
|
|
+ """Run a command and optionally capture output."""
|
|
|
+ try:
|
|
|
+ result = subprocess.run(
|
|
|
+ cmd,
|
|
|
+ capture_output=capture_output,
|
|
|
+ text=True,
|
|
|
+ check=check,
|
|
|
+ env=env or os.environ.copy()
|
|
|
+ )
|
|
|
+ return result
|
|
|
+ except subprocess.CalledProcessError as e:
|
|
|
+ if check:
|
|
|
+ error(f"Command failed: {' '.join(cmd)}")
|
|
|
+ if e.stdout:
|
|
|
+ print(e.stdout)
|
|
|
+ if e.stderr:
|
|
|
+ print(e.stderr, file=sys.stderr)
|
|
|
+ raise
|
|
|
+ return e
|
|
|
+
|
|
|
+def check_windows() -> None:
|
|
|
+ """Verify we're running on Windows."""
|
|
|
+ if platform.system() != 'Windows':
|
|
|
+ error("This script is designed for Windows only.")
|
|
|
+ error(f"Detected OS: {platform.system()}")
|
|
|
+ sys.exit(1)
|
|
|
+ success("Running on Windows")
|
|
|
+
|
|
|
+def check_cmake() -> Tuple[bool, Optional[str]]:
|
|
|
+ """Check if CMake is installed and get version."""
|
|
|
+ try:
|
|
|
+ result = run_command(['cmake', '--version'], capture_output=True)
|
|
|
+ version_match = re.search(r'cmake version (\d+\.\d+\.\d+)', result.stdout)
|
|
|
+ if version_match:
|
|
|
+ version = version_match.group(1)
|
|
|
+ major, minor, _ = map(int, version.split('.'))
|
|
|
+ if major > 3 or (major == 3 and minor >= 21):
|
|
|
+ success(f"CMake {version} found")
|
|
|
+ return True, version
|
|
|
+ else:
|
|
|
+ warning(f"CMake {version} found but version 3.21+ required")
|
|
|
+ return False, version
|
|
|
+ except (subprocess.CalledProcessError, FileNotFoundError):
|
|
|
+ pass
|
|
|
+ return False, None
|
|
|
+
|
|
|
+def check_ninja() -> bool:
|
|
|
+ """Check if Ninja is installed."""
|
|
|
+ try:
|
|
|
+ result = run_command(['ninja', '--version'], capture_output=True)
|
|
|
+ version = result.stdout.strip()
|
|
|
+ success(f"Ninja {version} found")
|
|
|
+ return True
|
|
|
+ except (subprocess.CalledProcessError, FileNotFoundError):
|
|
|
+ return False
|
|
|
+
|
|
|
+def find_vswhere() -> Optional[Path]:
|
|
|
+ """Find vswhere.exe to locate Visual Studio."""
|
|
|
+ vswhere_path = Path(r"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe")
|
|
|
+ if vswhere_path.exists():
|
|
|
+ return vswhere_path
|
|
|
+ return None
|
|
|
+
|
|
|
+def check_msvc() -> Tuple[bool, Optional[str]]:
|
|
|
+ """Check if MSVC is installed."""
|
|
|
+ vswhere = find_vswhere()
|
|
|
+ if not vswhere:
|
|
|
+ return False, None
|
|
|
+
|
|
|
+ try:
|
|
|
+ result = run_command([
|
|
|
+ str(vswhere),
|
|
|
+ '-latest',
|
|
|
+ '-requires', 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
|
|
|
+ '-property', 'installationVersion'
|
|
|
+ ], capture_output=True)
|
|
|
+
|
|
|
+ version = result.stdout.strip()
|
|
|
+ if version:
|
|
|
+ success(f"Visual Studio {version} with C++ tools found")
|
|
|
+ return True, version
|
|
|
+ except (subprocess.CalledProcessError, FileNotFoundError):
|
|
|
+ pass
|
|
|
+
|
|
|
+ return False, None
|
|
|
+
|
|
|
+def find_qt() -> Optional[Path]:
|
|
|
+ """Try to find Qt installation."""
|
|
|
+ # Common Qt installation locations
|
|
|
+ possible_paths = [
|
|
|
+ Path(r"C:\Qt"),
|
|
|
+ Path.home() / "Qt",
|
|
|
+ Path(os.environ.get('QT_ROOT', '')) if os.environ.get('QT_ROOT') else None,
|
|
|
+ ]
|
|
|
+
|
|
|
+ for base_path in possible_paths:
|
|
|
+ if base_path and base_path.exists():
|
|
|
+ # Look for Qt 6.x with msvc2019_64 or msvc2022_64
|
|
|
+ for qt_version_dir in base_path.glob("6.*"):
|
|
|
+ for arch_dir in qt_version_dir.glob("msvc*_64"):
|
|
|
+ qmake = arch_dir / "bin" / "qmake.exe"
|
|
|
+ if qmake.exists():
|
|
|
+ return arch_dir
|
|
|
+
|
|
|
+ return None
|
|
|
+
|
|
|
+def check_qt() -> Tuple[bool, Optional[Path], Optional[str]]:
|
|
|
+ """Check if Qt is installed."""
|
|
|
+ qt_path = find_qt()
|
|
|
+ if qt_path:
|
|
|
+ qmake = qt_path / "bin" / "qmake.exe"
|
|
|
+ try:
|
|
|
+ result = run_command([str(qmake), '-query', 'QT_VERSION'], capture_output=True)
|
|
|
+ version = result.stdout.strip()
|
|
|
+ success(f"Qt {version} found at {qt_path}")
|
|
|
+ return True, qt_path, version
|
|
|
+ except (subprocess.CalledProcessError, FileNotFoundError):
|
|
|
+ pass
|
|
|
+
|
|
|
+ return False, None, None
|
|
|
+
|
|
|
+def setup_msvc_environment() -> dict:
|
|
|
+ """Set up MSVC environment variables."""
|
|
|
+ info("Setting up MSVC environment...")
|
|
|
+
|
|
|
+ vswhere = find_vswhere()
|
|
|
+ if not vswhere:
|
|
|
+ error("Cannot find vswhere.exe")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+ # Find Visual Studio installation path
|
|
|
+ result = run_command([
|
|
|
+ str(vswhere),
|
|
|
+ '-latest',
|
|
|
+ '-requires', 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
|
|
|
+ '-property', 'installationPath'
|
|
|
+ ], capture_output=True)
|
|
|
+
|
|
|
+ vs_path = Path(result.stdout.strip())
|
|
|
+ if not vs_path.exists():
|
|
|
+ error("Cannot find Visual Studio installation")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+ # Find vcvarsall.bat
|
|
|
+ vcvarsall = vs_path / "VC" / "Auxiliary" / "Build" / "vcvarsall.bat"
|
|
|
+ if not vcvarsall.exists():
|
|
|
+ error(f"Cannot find vcvarsall.bat at {vcvarsall}")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+ # Run vcvarsall and capture environment
|
|
|
+ info(f"Running vcvarsall.bat from {vs_path}")
|
|
|
+ cmd = f'"{vcvarsall}" x64 && set'
|
|
|
+
|
|
|
+ result = subprocess.run(
|
|
|
+ cmd,
|
|
|
+ shell=True,
|
|
|
+ capture_output=True,
|
|
|
+ text=True
|
|
|
+ )
|
|
|
+
|
|
|
+ # Parse environment variables
|
|
|
+ env = os.environ.copy()
|
|
|
+ for line in result.stdout.split('\n'):
|
|
|
+ if '=' in line:
|
|
|
+ key, _, value = line.partition('=')
|
|
|
+ env[key] = value.strip()
|
|
|
+
|
|
|
+ success("MSVC environment configured")
|
|
|
+ return env
|
|
|
+
|
|
|
+def print_installation_guide() -> None:
|
|
|
+ """Print guide for installing missing dependencies."""
|
|
|
+ print(f"\n{Color.BOLD}Installation Guide:{Color.RESET}\n")
|
|
|
+
|
|
|
+ print(f"{Color.BOLD}1. CMake:{Color.RESET}")
|
|
|
+ print(" Download from: https://cmake.org/download/")
|
|
|
+ print(" Or use: winget install Kitware.CMake\n")
|
|
|
+
|
|
|
+ print(f"{Color.BOLD}2. Ninja:{Color.RESET}")
|
|
|
+ print(" Download from: https://github.com/ninja-build/ninja/releases")
|
|
|
+ print(" Or use: winget install Ninja-build.Ninja")
|
|
|
+ print(" Or use: choco install ninja\n")
|
|
|
+
|
|
|
+ print(f"{Color.BOLD}3. Visual Studio:{Color.RESET}")
|
|
|
+ print(" Download: https://visualstudio.microsoft.com/downloads/")
|
|
|
+ print(" Install 'Desktop development with C++' workload")
|
|
|
+ print(" Or use: winget install Microsoft.VisualStudio.2022.Community")
|
|
|
+ print(" --override '--add Microsoft.VisualStudio.Workload.NativeDesktop'\n")
|
|
|
+
|
|
|
+ print(f"{Color.BOLD}4. Qt 6.6.3:{Color.RESET}")
|
|
|
+ print(" Download: https://www.qt.io/download-open-source")
|
|
|
+ print(" Install Qt 6.6.3 with MSVC 2019 64-bit component")
|
|
|
+ print(" Required modules: qt5compat, qtmultimedia")
|
|
|
+ print(" Or set QT_ROOT environment variable to your Qt installation\n")
|
|
|
+
|
|
|
+def check_dependencies() -> Tuple[bool, Optional[Path]]:
|
|
|
+ """Check all required dependencies."""
|
|
|
+ info("Checking dependencies...")
|
|
|
+ print()
|
|
|
+
|
|
|
+ all_ok = True
|
|
|
+ qt_path = None
|
|
|
+
|
|
|
+ cmake_ok, _ = check_cmake()
|
|
|
+ if not cmake_ok:
|
|
|
+ error("CMake 3.21+ not found")
|
|
|
+ all_ok = False
|
|
|
+
|
|
|
+ ninja_ok = check_ninja()
|
|
|
+ if not ninja_ok:
|
|
|
+ error("Ninja not found")
|
|
|
+ all_ok = False
|
|
|
+
|
|
|
+ msvc_ok, _ = check_msvc()
|
|
|
+ if not msvc_ok:
|
|
|
+ error("Visual Studio with C++ tools not found")
|
|
|
+ all_ok = False
|
|
|
+
|
|
|
+ qt_ok, qt_path, _ = check_qt()
|
|
|
+ if not qt_ok:
|
|
|
+ error("Qt 6.x with MSVC not found")
|
|
|
+ all_ok = False
|
|
|
+
|
|
|
+ print()
|
|
|
+
|
|
|
+ if not all_ok:
|
|
|
+ error("Some dependencies are missing!")
|
|
|
+ print_installation_guide()
|
|
|
+ return False, None
|
|
|
+
|
|
|
+ success("All dependencies found!")
|
|
|
+ return True, qt_path
|
|
|
+
|
|
|
+def configure_project(build_dir: Path, build_type: str, qt_path: Optional[Path],
|
|
|
+ msvc_env: dict) -> None:
|
|
|
+ """Configure the project with CMake."""
|
|
|
+ info(f"Configuring project (Build type: {build_type})...")
|
|
|
+
|
|
|
+ cmake_args = [
|
|
|
+ 'cmake',
|
|
|
+ '-S', '.',
|
|
|
+ '-B', str(build_dir),
|
|
|
+ '-G', 'Ninja',
|
|
|
+ f'-DCMAKE_BUILD_TYPE={build_type}',
|
|
|
+ '-DDEFAULT_LANG=en'
|
|
|
+ ]
|
|
|
+
|
|
|
+ if qt_path:
|
|
|
+ cmake_args.append(f'-DCMAKE_PREFIX_PATH={qt_path}')
|
|
|
+
|
|
|
+ run_command(cmake_args, env=msvc_env)
|
|
|
+ success("Project configured")
|
|
|
+
|
|
|
+def build_project(build_dir: Path, msvc_env: dict) -> None:
|
|
|
+ """Build the project."""
|
|
|
+ info("Building project...")
|
|
|
+
|
|
|
+ run_command(['cmake', '--build', str(build_dir)], env=msvc_env)
|
|
|
+ success("Project built successfully")
|
|
|
+
|
|
|
+def deploy_qt(build_dir: Path, qt_path: Path, app_name: str, build_type: str) -> None:
|
|
|
+ """Deploy Qt dependencies."""
|
|
|
+ info("Deploying Qt dependencies...")
|
|
|
+
|
|
|
+ app_dir = build_dir / "bin"
|
|
|
+ exe_path = app_dir / f"{app_name}.exe"
|
|
|
+
|
|
|
+ if not exe_path.exists():
|
|
|
+ error(f"Executable not found: {exe_path}")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+ windeployqt = qt_path / "bin" / "windeployqt.exe"
|
|
|
+ if not windeployqt.exists():
|
|
|
+ error(f"windeployqt not found at {windeployqt}")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+ qml_dir = Path("ui/qml")
|
|
|
+
|
|
|
+ # Map build type to windeployqt mode flag
|
|
|
+ mode_flag = {
|
|
|
+ "Debug": "--debug",
|
|
|
+ "Release": "--release",
|
|
|
+ "RelWithDebInfo": "--release", # release DLLs + PDBs
|
|
|
+ }[build_type]
|
|
|
+
|
|
|
+ run_command([
|
|
|
+ str(windeployqt),
|
|
|
+ mode_flag,
|
|
|
+ '--compiler-runtime', # ship VC++ runtime DLLs
|
|
|
+ '--qmldir', str(qml_dir),
|
|
|
+ str(exe_path)
|
|
|
+ ])
|
|
|
+
|
|
|
+ success("Qt dependencies deployed")
|
|
|
+
|
|
|
+def copy_assets(build_dir: Path) -> None:
|
|
|
+ """Copy assets to build directory."""
|
|
|
+ info("Copying assets...")
|
|
|
+
|
|
|
+ app_dir = build_dir / "bin"
|
|
|
+ assets_src = Path("assets")
|
|
|
+ assets_dst = app_dir / "assets"
|
|
|
+
|
|
|
+ if assets_dst.exists():
|
|
|
+ shutil.rmtree(assets_dst)
|
|
|
+
|
|
|
+ shutil.copytree(assets_src, assets_dst)
|
|
|
+ success("Assets copied")
|
|
|
+
|
|
|
+def create_package(build_dir: Path, build_type: str) -> Path:
|
|
|
+ """Create distributable package."""
|
|
|
+ info("Creating distributable package...")
|
|
|
+
|
|
|
+ app_dir = build_dir / "bin"
|
|
|
+ package_name = f"standard_of_iron-win-x64-{build_type}.zip"
|
|
|
+ package_path = Path(package_name)
|
|
|
+
|
|
|
+ if package_path.exists():
|
|
|
+ package_path.unlink()
|
|
|
+
|
|
|
+ shutil.make_archive(
|
|
|
+ package_path.stem,
|
|
|
+ 'zip',
|
|
|
+ app_dir
|
|
|
+ )
|
|
|
+
|
|
|
+ success(f"Package created: {package_path}")
|
|
|
+ return package_path
|
|
|
+
|
|
|
+def main() -> int:
|
|
|
+ """Main entry point."""
|
|
|
+ parser = argparse.ArgumentParser(
|
|
|
+ description="Build Standard-of-Iron on Windows",
|
|
|
+ formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
|
+ epilog=__doc__
|
|
|
+ )
|
|
|
+ parser.add_argument(
|
|
|
+ '--skip-checks',
|
|
|
+ action='store_true',
|
|
|
+ help='Skip dependency checks'
|
|
|
+ )
|
|
|
+ parser.add_argument(
|
|
|
+ '--build-type',
|
|
|
+ choices=['Debug', 'Release', 'RelWithDebInfo'],
|
|
|
+ default='Release',
|
|
|
+ help='CMake build type (default: Release)'
|
|
|
+ )
|
|
|
+ parser.add_argument(
|
|
|
+ '--clean',
|
|
|
+ action='store_true',
|
|
|
+ help='Clean build directory before building'
|
|
|
+ )
|
|
|
+ parser.add_argument(
|
|
|
+ '--deploy-only',
|
|
|
+ action='store_true',
|
|
|
+ help='Only deploy Qt dependencies (skip build)'
|
|
|
+ )
|
|
|
+ parser.add_argument(
|
|
|
+ '--no-package',
|
|
|
+ action='store_true',
|
|
|
+ help='Skip creating distributable package'
|
|
|
+ )
|
|
|
+
|
|
|
+ args = parser.parse_args()
|
|
|
+
|
|
|
+ # Check we're on Windows
|
|
|
+ check_windows()
|
|
|
+
|
|
|
+ # Repository root
|
|
|
+ repo_root = Path(__file__).parent.parent
|
|
|
+ os.chdir(repo_root)
|
|
|
+
|
|
|
+ build_dir = Path("build")
|
|
|
+ qt_path = None
|
|
|
+
|
|
|
+ # Check dependencies unless skipped
|
|
|
+ if not args.skip_checks and not args.deploy_only:
|
|
|
+ deps_ok, qt_path = check_dependencies()
|
|
|
+ if not deps_ok:
|
|
|
+ return 1
|
|
|
+ else:
|
|
|
+ # Try to find Qt even if checks are skipped
|
|
|
+ _, qt_path, _ = check_qt()
|
|
|
+
|
|
|
+ # Clean build directory if requested
|
|
|
+ if args.clean and build_dir.exists():
|
|
|
+ info("Cleaning build directory...")
|
|
|
+ shutil.rmtree(build_dir)
|
|
|
+ success("Build directory cleaned")
|
|
|
+
|
|
|
+ # Set up MSVC environment
|
|
|
+ if not args.deploy_only:
|
|
|
+ msvc_env = setup_msvc_environment()
|
|
|
+
|
|
|
+ # Configure
|
|
|
+ configure_project(build_dir, args.build_type, qt_path, msvc_env)
|
|
|
+
|
|
|
+ # Build
|
|
|
+ build_project(build_dir, msvc_env)
|
|
|
+
|
|
|
+ # Deploy Qt
|
|
|
+ if qt_path:
|
|
|
+ deploy_qt(build_dir, qt_path, "standard_of_iron", args.build_type)
|
|
|
+ else:
|
|
|
+ warning("Qt path not found, skipping windeployqt")
|
|
|
+
|
|
|
+ # Copy assets
|
|
|
+ copy_assets(build_dir)
|
|
|
+
|
|
|
+ # Create package
|
|
|
+ if not args.no_package:
|
|
|
+ package_path = create_package(build_dir, args.build_type)
|
|
|
+ print()
|
|
|
+ info(f"Build complete! Package available at: {package_path}")
|
|
|
+ info(f"Executable location: {build_dir / 'bin' / 'standard_of_iron.exe'}")
|
|
|
+ else:
|
|
|
+ print()
|
|
|
+ info(f"Build complete!")
|
|
|
+ info(f"Executable location: {build_dir / 'bin' / 'standard_of_iron.exe'}")
|
|
|
+
|
|
|
+ return 0
|
|
|
+
|
|
|
+if __name__ == '__main__':
|
|
|
+ try:
|
|
|
+ sys.exit(main())
|
|
|
+ except KeyboardInterrupt:
|
|
|
+ print()
|
|
|
+ warning("Build interrupted by user")
|
|
|
+ sys.exit(130)
|
|
|
+ except Exception as e:
|
|
|
+ error(f"Unexpected error: {e}")
|
|
|
+ import traceback
|
|
|
+ traceback.print_exc()
|
|
|
+ sys.exit(1)
|
Adam Djellouli