vcmi/vcmi

Features

• Cross-Platform Game Runtimes - Provides a cross-platform runtime supporting Windows, Linux, macOS, Android, and iOS with scalable resolutions.
• Strategy Game Simulations - Recreates the gameplay, logic, and rendering of a classic turn-based strategy game as a cross-platform runtime.
• Moddable Engines - Ships an engine designed specifically for modification of rules and assets via external files.
• Binary Serialization - Translates in-memory objects into binary streams for efficient network transmission and disk storage.
• Game State Persistence - Writes binary game data to files and reads it back to restore session state.
• Data-Driven Entity Configurations - Implements a data-driven system to define game objects and factions using external files validated by schemas.
• Data-Driven Entity Definitions - Creates new entities using data definitions and associated media resources like images and sounds.
• Engine Recreations - Building an open-source version of a classic strategy game to enable modern platform support and extended functionality.
• Game Content Extension - Provides frameworks for injecting custom configurations for characters and spells via external files.
• Gameplay Mechanics Implementation - Runs the specific mechanics and rules that simulate combat, economy, and unit movement.
• Strategic Simulation Execution - Simulates strategic and tactical gameplay mechanics including combat, resource management, and city growth.
• Gameplay Scripting Systems - Provides a sandboxed scripting environment allowing custom gameplay behaviors and spell effects without core engine recompilation.
• Data-Driven Configuration - Implements a data-driven system for adding factions and characters through external configuration files and schema validation.
• Multiplayer Networking - Supports network play with simultaneous turns and lobby management.
• Simultaneous Turn Synchronization - Coordinates multiplayer state updates between clients using serializable network packets and a coordinated turn-based queue.
• Sandboxed Scripting Environments - Executes custom gameplay logic and spell effects in a restricted environment to avoid recompiling the core engine.
• Turn-Based Grid Engines - Simulates a discrete tile grid with turn-based timing for strategic movements and tactical combat.
• World Map Navigation - Handles character movement across terrain layers, including pathfinding and fog of war.
• Tactical Combat Simulations - Implements tactical combat simulation with a turn-based queue and specific unit abilities.
• Combat Rendering - Processes and displays grid-based combat encounters and strategic map movements across multiple operating systems.
• Modding Frameworks - Provides a comprehensive framework for creating and distributing custom game modifications and world maps.
• Graphics Rendering Engines - Implements a graphics rendering engine to display visuals and interface components by managing framerates and surfaces.
• Game State Synchronization - Coordinates state updates between server and clients using serializable network packets.
• Embedded Lua Scripting - Integrates Lua scripting to provide programmable automation and extension of gameplay mechanics.
• Lua-Based Extensibility - Extends gameplay and defines new spell effects using the Lua scripting language.
• Lua Game - Embeds a sandboxed Lua interpreter to handle custom gameplay logic and spell effects at runtime.
• Gameplay Simulations - Executes the core gameplay mechanics and logic to control tactical battle behaviors and unit movements.
• Game State Serialization - Transforms complex game objects into a persistable format to support saved games.
• Core Capability Extensions - Extends fundamental operational logic via a scripting system and a custom bonus format.
• Gameplay State Synchronization - Synchronizes gameplay attributes and state across clients in a networked turn-based environment.
• Agent Goal Definitions - Manages agent-based goals and character movements across the world map to achieve objectives.
• AI Difficulty Frameworks - Integrates multiple artificial intelligence libraries to create varying levels of opponent difficulty and behavior.
• Inter-Mod Dependency Management - Defines required and conflicting extensions to control loading order and prevent crashes.
• Random Map Generators - Creates playable maps based on templates with configurable zones and distribution.
• Game Campaign Creators - Imports and executes external campaign data to play specific structured narratives and scenarios.
• Mod Metadata Definitions - Specifies identity, version, and compatibility requirements for mod extensions.
• Polymorphic Type Serializers - Translates in-memory objects to binary streams while preserving pointer relationships and reinstantiating derived class types.
• Schema Validators - Validates game entity property files against formal schemas during the loading process.
• Script Context Management - Manages script loading and execution contexts across different game sessions and map loads.
• Game Content Packaging - Bundles new logic, assets, and configuration files into packages for distribution.
• Adventure AI Simulations - Directs computer-controlled characters to autonomously explore maps, gather resources, and engage enemies.
• AI Control Systems - Provides mechanisms to toggle between manual player control, automated AI control, or observation mode.
• Asset Overriding - Implements a system to override original graphical, audio, and video assets by placing custom files in specific directories.
• Cross-Platform Game Compilation - Builds native binaries for multiple platforms from a single codebase, including support for localization and video.
• Custom Gameplay Modifiers - Creates custom modifiers that alter logic through configurable values and durations.
• Engine Constraint Expansions - Removes hardcoded constraints on map size, object counts, and character statistics.
• Entity Attribute Overrides - Overrides specific attributes of existing entities to rebalance gameplay or ensure compatibility.
• Game Content Modification Tools - Customizes behavior, map layouts, and campaign structures using external editor tools.
• Gameplay Modifier Constraints - Filters which entities inherit a bonus based on criteria such as unit type.
• Gameplay Stat Modifiers - Distributes attribute modifiers across entities using propagation graphs to determine active buffs.
• Map and Scenario Editors - Designing and generating playable world maps and scenarios using a dedicated visual editor and configuration tools.
• Map File Managers - Opens and saves map data using both standard and project-specific file formats.
• Mod Asset Layouts - Provides a structured directory and file layout for mod assets to alter game aesthetics and gameplay.
• Mod Management Interfaces - Provides a launcher to install, update, and resolve conflicts between modifications.
• Playable Hero Character Systems - Manages character leveling, skill acquisition, and equipment assignment for playable heroes.
• Procedural World Generation - Generates a world map with configurable dimensions and underground layers.
• Quest Systems - Provides a framework for tracking quest progress, objective locations, and mission details via logs and map markers.
• Automated Combat Logic - Employs automated modules to handle unit positioning and spellcasting during tactical battles.
• Town and Settlement Management - Handles urban construction, creature recruitment, and the assignment of characters to city garrisons.
• Resolution Scaling - Supports various screen resolutions and aspect ratios with scalable user interfaces.
• Android APK Compilation - Compiles the project into an Android APK using a pre-configured container to manage dependencies.
• Object Reference Transmission - Optimizes network bandwidth by transmitting unique object identifiers instead of full object data.
• Cross-Language Data Exchange - Implements bidirectional data exchange between the C++ host and the Lua script runtime.
• Language Bridge Proxies - Exposes internal C++ classes to Lua via wrapper tables to enable external logic to call internal methods.
• Shortest Path Algorithms - Implements pathfinding algorithms to find the optimal route on a map based on various traversal methods.
• Attribute Propagation Graphs - Uses propagation graphs to distribute attribute modifiers and calculate active buffs based on inheritance rules.
• Engine Behavior Configuration - Provides interfaces for overriding default configuration values to change internal engine behavior.
• Multi-Platform Build Pipelines - Implements automated toolchains to compile the engine across multiple target operating systems and architectures.
• Parallel Task Execution - Distributes demanding computations across multiple CPU threads to prevent application freezes.
• Responsive Interface Threading - Offloads computationally heavy simulations to background threads to ensure the user interface remains responsive.
• Touch-to-Desktop Input Mappers - Translates taps and long-presses into click events for touch-screen devices.
• External Layout Configurations - Provides flexible UI layout management using external configuration files to define interface arrangements.
• Strategy Game Engines - Engine for a classic fantasy turn-based strategy game.
• Turn Based Strategy - Open-source engine for a classic fantasy strategy sequel.

Star history