Projects sharing features with Duelyst

This project provides a containerized environment for deploying and managing Minecraft game servers. It functions as an infrastructure manager that automates the setup and maintenance of server instances, ensuring consistent execution across different host systems through standardized container images. The platform distinguishes itself by using environment variables to handle configuration and version control, allowing users to define server types and operational parameters without manual file editing. It automates the retrieval of software artifacts, dependencies, and plugins during the init

Eloquent-JavaScript is a comprehensive JavaScript programming textbook and interactive coding tutorial designed for web development education. It serves as both a language reference and a practical guide, combining theoretical lessons with an environment where learners can execute and modify code examples. The project focuses on the fundamental principles of the JavaScript language, including lexical scoping, prototype-based inheritance, and asynchronous patterns. It provides detailed instruction on object-oriented programming, functional programming, and the use of the browser DOM to create

Veloren is an open-source multiplayer RPG featuring a voxel-based action adventure in a procedurally generated fantasy world. It is built upon a voxel game engine that supports 3D rendering via Vulkan and Metal, utilizing a procedural world generator to create geography and ecosystems based on erosion algorithms and temperature maps. The project is distinguished by a sandboxed plugin system using WebAssembly, which allows for the addition of new game logic and equipment without recompiling the core engine. It also features a dedicated game server architecture designed to synchronize state, ma

This project is a cross-platform mobile project template and TypeScript boilerplate designed for bootstrapping React Native applications using the Expo ecosystem. It provides a pre-configured architecture with a standardized folder structure to accelerate initial development. The template distinguishes itself through a feature-based project architecture and a comprehensive automation suite. It integrates file-based routing for navigation, a utility-first mobile UI kit for styling, and a server state management layer for fetching and caching remote API data. The setup includes a mobile CI/CD p

Unciv is an open-source, cross-platform turn-based strategy game and a community-driven remake of a commercial strategy title. It simulates empire building, city management, and technological research for players on Android and desktop platforms. The project is designed as a moddable game engine, allowing users to override gameplay rules, modify units and buildings via external definition files, and replace audiovisual assets. It supports the distribution of custom maps and the ability to import mod archives from remote web addresses. The application includes a dedicated server for multiplay

This repository is a comprehensive collection of functional 2D and 3D demo projects and implementation samples for the Godot Game Engine. It serves as an interactive tutorial and reference library, providing a working codebase to demonstrate how to apply engine features in real-world scenarios. The collection focuses on practical implementation guides, covering a wide array of technical capabilities from basic engine fundamentals to advanced rendering and scripting techniques. It allows users to study the application of node-based composition, asset pipelines, and game logic through direct ex

Ambient is a cross-platform multiplayer game engine and runtime environment developed in Rust. It provides a system for building and deploying high-performance games that run across web browsers and desktop platforms using WebAssembly and WebGPU. The project features a networked database that automatically replicates real-time state and components between servers and players. It utilizes WebAssembly sandboxes to isolate game logic, which prevents individual script crashes and allows for the secure execution of untrusted code. The framework includes a graphics system for high-fidelity 3D visu

RLcard is an open-source framework for developing and evaluating reinforcement learning agents across multiple card game environments. It functions as a card game environment simulator, a multi-agent RL platform, and a benchmarking toolkit for algorithms like DQN, NFSP, and CFR. The framework provides a game-agnostic environment interface that decouples agent logic from game mechanics, allowing any policy to interact through a common API. It supports pluggable reinforcement learning algorithms that operate on this interface without modifying game logic, and includes a self-play training loop

Phaser is a comprehensive 2D game engine designed for building high-performance, interactive content that runs directly in web browsers. At its core, the engine utilizes a fixed-timestep simulation loop that decouples game logic from variable browser frame rates, ensuring consistent behavior across diverse hardware. It provides a robust framework for managing asset loading, physics, input, and audio, enabling the creation of complex, responsive visual experiences for both desktop and mobile devices. The engine distinguishes itself through a high-performance graphics pipeline that automaticall

Flame is a 2D game engine for Flutter and Dart. It provides a component-based game framework for managing entities and their lifecycles through a hierarchical architecture, alongside a dedicated system for game asset management and input handling. The engine distinguishes itself through a specialized integration layer for external physics engines to handle rigid body dynamics and collision detection. It also features a high-performance task model that uses isolates to offload heavy computations and prevent main thread blocking. The framework covers a broad range of capabilities including vis

This is a game engine library for building interactive games using React and React Native components. It provides a centralized game loop and state management system to coordinate logic and updates on every game tick. The framework includes a coordinate system for cross-platform scaling that distributes factors across a component tree to maintain consistent positioning across different screen sizes. It also features a sprite animation system for rendering sequential frames from sprite sheets and a tile map renderer that constructs multi-layered terrain using a tile atlas and grid-based indexe

Flame is a 2D game engine and framework for Flutter. It provides a component-based architecture to organize scene entities and manage their lifecycles through a structured hierarchy of game objects, coordinated by a consistent game loop. The engine includes a graphics library for rendering animated sprites, particle effects, and external textures. It features a 2D physics integration layer that supports rigid body dynamics and collision detection between entities. The framework covers additional capabilities for game engineering, including user input capture for gestures and gamepads, audio

Matter-js is a 2D rigid body physics engine written in JavaScript for simulating realistic physical interactions, collisions, and dynamics in web browsers. It functions as a web physics simulation library that calculates motion, gravity, and constraints for objects rendered on a web canvas. The library includes a built-in canvas physics visualizer to draw physical bodies, joints, and constraints for debugging and gameplay. It distinguishes itself through a plugin system that supports recursive dependency resolution and internal method patching to inject custom logic into the engine's executio

React Native Game Engine is a framework for building 2D interactive experiences and simulations within mobile applications. It provides a dedicated controller for managing a fixed-step game loop, ensuring that game logic, user inputs, and state updates occur at a consistent frame rate. The engine utilizes an entity-component-system architecture to decouple game object data from behavior. By structuring objects as independent entities processed by reusable logic functions, it allows for the management of complex scenes through a centralized, data-driven approach. The framework supports the cr

FlappySwift is a side-scrolling arcade game implementation built for Apple platforms. Developed using the Swift programming language, this 2D game project features a physics-based environment where a player controls a character to avoid obstacles. The project utilizes the SpriteKit framework to handle rigid body dynamics, gravitational forces, and sprite-based rendering. Game flow is managed through a state machine that controls transitions between the start menu, active gameplay, and game over screens. The implementation covers 2D physics simulation, including bounding-box collision detecti

MonoGame is a cross-platform game engine and framework built for the C# language and .NET ecosystem. It provides a development environment for creating 2D and 3D games that run across multiple operating systems and hardware platforms. The project serves as an open-source implementation of the XNA game studio API. It includes a dedicated game asset pipeline to convert raw art and sound files into optimized formats for efficient engine loading. The framework provides a hardware-abstraction layer to maintain a consistent interface for graphics and input across different devices. Its capabilitie

ShareJS is a collaborative document database and synchronization engine designed for real-time shared state management. It provides an operational transform sync engine to enable simultaneous editing of plain-text and JSON data, and a RESTful synchronization API for managing document states via HTTP. The system features an offline-first data sync layer that queues local modifications while disconnected and automatically pushes edits upon reconnection. It also includes a middleware access control layer that intercepts database requests to enforce security policies and perform request rewriting

OpenSC2K is an open-source JavaScript city builder engine designed as a recreation of SimCity 2000. It functions as a web-based simulation that uses the Phaser 3 framework to implement game loops and entity management. The project utilizes WebGL and Canvas rendering to visualize large-scale urban environments. It includes a coordinate-based camera system that enables panning and zooming across the reconstructed game world. The engine incorporates a data pipeline to parse legacy city files and graphics assets, allowing it to reconstruct and display urban layouts within a modern web browser.

Quake III Arena is a first-person shooter game engine and arena combat simulator. It consists of the original C++ game source code for a cross-platform 3D game designed to run on Windows, Linux, and Mac. The project provides the source code necessary to render a first-person shooter experience, focusing on player-versus-player battles in closed 3D environments. It serves as a resource for legacy game preservation and the study of early 3D game engine construction. The engine incorporates spatial partitioning, client-side prediction, and state synchronization to manage multiplayer networking

SpaceCadetPinball is a reverse-engineered, cross-platform port of the classic 3D Pinball - Space Cadet game, rebuilt from the original binary without access to its source code. It functions as an asset-driven pinball emulator that loads the original game data files to recreate the authentic visual and audio experience on modern hardware, preserving the legacy title through binary-to-source porting and reverse engineering. The project distinguishes itself by reconstructing the game's logic through runtime analysis of the original compiled instructions, translating them back into readable C++ c

CorsixTH is an open-source game clone and hospital management simulation game. It functions as a reproduction of a classic management title where players coordinate staff and treat patients to manage a medical facility. The project includes a level editor tool for designing original maps and campaigns. It also features a customizable input system that allows users to map game hotkeys and personalize control schemes. The simulation supports game localization to translate interface text and dialogue into multiple languages.

This project is an interactive learning resource and tutorial for implementing the Apollo GraphQL client. It provides a guided instructional experience to teach frontend data management, specifically focusing on how to connect web applications to GraphQL data sources. The platform uses a sequenced path of hands-on lessons and interactive code walkthroughs. These modules combine instructional text with executable code blocks to demonstrate real-time API behavior and the integration of GraphQL into frontend frameworks. The curriculum covers the use of declarative queries and schema-driven data

learningPixi is an educational resource and instructional guide focused on 2D web graphics and interactive media development. It provides a structured curriculum and tutorials for building 2D games and visual applications using the Pixi.js rendering engine and WebGL for hardware-accelerated graphics. The project covers specialized workflows for sprite animation, including the use of texture atlases and spritesheet frame extraction. It also provides guidance on implementing game state management for scene transitions and rectangular collision detection systems to trigger interactive events. T

Fabric API is a modular framework designed for Minecraft mod development, providing a standardized set of hooks and libraries that enable the integration of custom content into the game. It serves as a foundational toolkit for injecting custom logic, assets, and networked data into the game environment during both startup and runtime phases. The framework distinguishes itself by facilitating interoperability between independent modifications through shared events and interface-based contracts, which allow different mods to interact without requiring direct dependencies. It manages the complex

This repository contains the original source code for a classic real-time strategy game, serving as a legacy game engine implementation for managing units, maps, and combat mechanics in a military strategy setting. It functions as a real-time strategy game source code archive intended for preservation and technical study. The codebase acts as a game modification base, allowing developers to create custom content and modifications using the original source. It provides a foundation for retro game modding and software archeology to analyze how historical game mechanics were programmed. The pro

Tower Game is a browser-based JavaScript engine designed for building physics-driven stacking simulations. It provides a framework for developing interactive arcade-style challenges where players align blocks to build structures, with core systems that manage collision logic, health tracking, and precision-based scoring. The engine distinguishes itself through a modular architecture that allows for deep customization of gameplay mechanics. Developers can inject custom functions to override default movement speeds, oscillation angles, and scoring triggers at runtime. Additionally, the system s

This project is a single-player tower defense game and 2D grid-based strategy application built with Python and the Pygame library. It focuses on resource management and tactical unit placement to prevent waves of enemies from reaching a goal. The gameplay centers on constructing defensive lines using units with specialized combat abilities. Players manage a limited currency by collecting energy resources via a pointer interface and select specific equipment sets to configure their available units before starting a level. The system supports level-based progression by loading environmental c