This article explores the fundamental physics and mathematics behind game development, covering object motion models, scrolling techniques, collision detection, ray casting, screen transition effects, and provides Python code examples to illustrate how these concepts are implemented in practice.
The Fast Inverse Square Root algorithm, invented by John Carmack for Quake III Arena, uses a clever magic constant and Newton‑Raphson iteration to compute 1/√x far faster than traditional methods, dramatically reducing floating‑point workload in real‑time graphics.
This article presents a comprehensive guide to automating audio testing in first‑person shooter games, covering common audio bugs, a step‑by‑step recording workflow, feature extraction techniques, similarity metrics, and practical toolchains such as Soundcard, fmedia, VBCable, and librosa.
The article describes how Bilibili created OneSDK and a macOS packaging tool that automatically selects and inserts the appropriate regional game SDKs, unifying APIs, eliminating manual configuration, and cutting integration effort by roughly 60% through Ruby‑based project manipulation and a Flutter UI.
This article reviews the OpenKruiseGame project and its dashboard, showing how cloud‑native containerization, multi‑cloud support, and automated CI/CD pipelines transform game server deployment, scaling, and management for both PvP and PvE titles.
This article explains how 1980s game developers squeezed full‑screen scrolling, rich music, and extensive gameplay into just 128 KB by using tile‑based graphics, specialized audio chips, and ultra‑compact code, revealing the technical tricks behind classic titles like Contra.
The iconic 1990s real‑time strategy game Red Alert has had its original C++ source code released on GitHub, offering modders a rare glimpse into Westwood’s legacy code while explaining the historical context, the limited scope of the release, and why Red Alert 2 remains unavailable.
Rising to the top of the 2023 TIOBE rankings, C#—born in the early 2000s to simplify complex software—combines type safety, cross‑platform .NET support, and modern tooling, enabling developers to build AI, cloud‑native, game, full‑stack web, desktop, mobile, and IoT applications with increasing popularity worldwide.
This tutorial walks you through installing Pygame, setting up the game window, loading assets, defining tank and bullet sprites, implementing the main loop, and running a complete Python‑based 2D tank battle game with full source code.
A senior architect discusses the challenges of applying microservice architecture to real‑time game servers, highlighting latency, stateful processing, and network overhead, and shares multiple expert opinions on when microservices are appropriate versus when monolithic designs are preferable for high‑performance gaming.
Guanying Interactive leveraged the OpenKruiseGame project to migrate its 2D MMO engine Thousand to a cloud‑native Kubernetes stack, overcoming isolation, management, and hot‑update challenges while dramatically improving server launch speed, update efficiency, cost savings, and fault‑diagnosis capabilities.
This tutorial walks through building an AI-controlled Snake game in Python using the curses library, covering environment setup, core algorithms such as BFS/DFS for pathfinding, detailed code explanations, common pitfalls, and extensions for human‑vs‑AI play.
This article explains the rules of the popular Chinese card game Zha Jin Hua, demonstrates how to generate a standard deck, deal cards to multiple players, evaluate hand types, calculate scores with multipliers, run large‑scale simulations for frequency analysis, and provides the complete Python source code for the entire workflow.
Japanese game developer KMS migrated from Azure to Tencent Cloud, adopting a cloud‑native architecture with Tencent’s Elastic Microservice platform that provides timed and metric‑based scaling, CI/CD pipelines, and batch upgrades, resulting in roughly 50% cost savings, 15% performance gains and 50% latency reduction.
This tutorial walks through the fundamentals of Cocos Creator 3.x, explaining core concepts such as scenes, nodes, prefabs, components, and assets, then demonstrates how to build a 2D plane‑shooting game with background scrolling, player control, bullet firing, enemy spawning, collision detection, death animations, and final build steps.
The article explores how early 1980s game programmers managed extremely limited memory for graphics, audio, and code by using techniques such as tile-based rendering, simple audio synthesis, and data size estimation, highlighting the stark contrast with modern development resources.
This article details the end‑to‑end design, technical selection, and implementation of a lightweight map solution for the mobile game King of Glory, covering cross‑platform UI framework, Unity‑native view integration, data transmission via JCE, handling of Android/iOS click events, immersive mode, and nine‑patch image support.
The classic real‑time strategy game Red Alert, originally released by Westwood Studios and later acquired by EA, has had parts of its 1996 source code for both Tiberian Dawn and Red Alert released on GitHub, offering C++ developers insight into the well‑structured game logic while excluding assets and the engine.
This article walks through how to replicate Genshin Impact's login interface using three.js, custom GLSL shaders, instanced meshes, and post‑processing effects, providing detailed code snippets and explanations for background gradients, cloud layers, pillars, light beams, stars, fog, and rendering optimizations.
This article outlines a practical workflow for increasing load‑testing coverage of game features, covering requirement clarification, test‑point identification, script development, execution strategies, and time‑saving techniques to ensure reliable performance under limited resources.
This tutorial explains how to create an interactive Mid‑Autumn Festival dice‑game using Three.js for 3D rendering, cannon‑es for physics simulation, glTF/glb model loading, heightfield collision handling, and JavaScript logic to determine game results.
Unity introduced a new installation‑based pricing model that charges developers $0.20 per install after $200,000 revenue or 200,000 downloads, prompting widespread developer backlash, concerns over tracking and impact on mobile titles, and prompting some to consider switching to alternatives like Godot.
This article reviews the evolution of game AI agents, examines how large language models (LLMs) can drive new AI behaviors in games, and discusses practical case studies across genres such as Werewolf‑style, war‑SLG, and MOBA games, concluding with challenges and future research directions.
This tutorial walks through creating a classic‑style 2D airplane shooting game in Python using Pygame, covering environment setup, player and enemy plane implementation, keyboard controls, bullet collision detection, and includes full source code and visual results.
This article describes the design and implementation of a Mid‑Autumn Festival themed HTML5 canvas game, detailing the gameplay requirements, JavaScript code for the ship, food objects, image management, and the Nginx configuration needed to deploy the game online.
This article presents a plug‑in‑based, WebWorker‑enabled resource manager for web games and live‑stream activities, detailing its background, research of existing solutions, overall design, core modules, external APIs, and practical usage examples such as preloading, modular bundles, and image conversion.
This article provides a complete, step‑by‑step Python tutorial that builds a Pong game using the turtle library, including an AI‑controlled paddle, user paddle controls, collision detection, and game‑over logic, with all source code ready to copy and run.
This tutorial walks through building a simple Naruto-inspired 3D scene using three.js, covering model acquisition, character creation, keyboard controls, rotation handling, animation state management, camera integration, octree-based collision detection, and troubleshooting common issues such as camera‑character alignment and jump physics.
This article explores the rise of procedural materials in computer graphics, explaining how algorithm-driven textures in Unreal Engine can generate infinite variations, save time, enhance performance, and integrate with AI, while also discussing workflow, node systems, challenges, and future trends for game developers.
The article shares practical experiences and techniques for game testing automation, covering fake player usage, script modularization, report generation, IDE template utilization, custom log tools, and developer habits to improve efficiency and code quality across testing workflows.
This article explains how Tencent leverages A/B testing across its overseas games, detailing the current market situation, experimental capabilities, multi‑cloud platform architecture, and case studies that illustrate how data‑driven experiments improve user retention, engagement, and overall business growth.
This tutorial shows how to build a simple 2D platformer using the Alice.js H5 engine combined with React, covering scene construction with JSX components, camera scrolling, UI layering, PixiJS element types, animation formats, flex layout, keyframe hooks, event scripting, and debugging tools.
This article introduces ten widely used Python libraries—NumPy, Pandas, Matplotlib, Scikit‑learn, Requests, Beautiful Soup, Selenium, Pygame, Flask, and PyTorch—each accompanied by a concise real‑world project and complete code examples to help readers understand and apply them effectively.
This article introduces Vizard, a C/C++‑based virtual‑reality development platform with Python support, and provides step‑by‑step code examples for loading avatars, creating random pigeon walks, implementing character dialogue, handling movement and mouse input, and showcasing typical VR scene effects.
Explore the fundamentals of cloud gaming and discover how WebRTC's real-time audio‑video, NAT traversal, and data channel technologies enable low‑latency game streaming across devices, with detailed architecture, protocols, and code examples for developers.
This article introduces ten essential Python libraries and frameworks, providing practical examples and code implementations for each to help readers understand and master their applications in various domains.
The article presents a cloud‑music social live‑streaming game solution that selects PixiJS over DOM for superior performance, identifies inefficiencies in React‑DOM coupling, and introduces the custom Alice.js framework—bridging React DSL with PixiJS, extending game components, and managing resources—to streamline front‑end game scene development.
The article introduces SpaceTraders, an old Palm‑OS strategy game now exposed as a RESTful API, shows curl examples for registration, ship purchase, refueling and trading, and explains how building client applications with this API can serve as an engaging way to learn programming concepts.
This article analyzes the growing need for a unified Unity framework at AutoHome, evaluates existing open‑source Unity architectures, proposes a four‑layer design (logic, middle, base, data), demonstrates a native‑message example, and quantifies quality, efficiency, performance, and reuse gains.
This article analyzes the challenges of automating test coverage for a large‑scale MMORPG by classifying representative functional modules, outlining targeted testing strategies for different module characteristics, and proposing framework and script‑library optimizations to efficiently increase coverage and maintainability.
The article explains why early 1980s games such as Contra could deliver rich graphics, music, and scrolling effects within just 128 KB of ROM by using tile‑based graphics, minimal audio data, efficient code, and hardware‑specific tricks, and it reflects on how modern developers perceive data size differently.
This article explains how early 1980s games like Contra fit extensive storylines, graphics, and music into just 128KB by using tile‑based graphics, minimal audio data, and highly optimized code, illustrating the dramatic shift in data expectations as technology advances.
At GDC, Tencent AI Lab demonstrated an AIGC‑driven pipeline that automatically creates massive, realistic 3D city environments—including road networks, diverse building facades, and interior mappings—in weeks instead of years, dramatically accelerating AAA game development.
This article details NetEase Zhiji and Dianhun Network's use of reinforcement learning, a distributed training framework, and middleware to create, train, deploy, and iterate AI robots for the game "Barbarian Battle 2", highlighting technical challenges, solutions, and the impact on player experience.
This tutorial demonstrates how to build a classic "code rain" screen using Python's pygame library, guiding readers through imports, window setup, character rendering, and a concise main loop that produces the animated effect in roughly thirty lines of code.
The article details how Taobao Life’s “Life Cabin” feature was built using the in‑house Hilo3D WebGL engine, describing a pipeline that converts Maya‑exported USD models to GLTF, sets up cameras and controls, manages avatar movement, implements interactive furniture logic, and applies shadow‑map and baked‑light optimizations for smooth performance.
This article introduces Vizard, a C/C++‑based virtual‑reality development platform with Python support, and demonstrates how to load avatars and objects, create random‑walk behavior, implement dialogue actions, control character movement via keyboard, capture mouse input, and combine these techniques into a complete interactive 3D scene.
This article presents a systematic method for evaluating and prioritizing stress‑test coverage in game projects, combining comprehensive “addition” techniques—such as QA requirement gathering, case‑library reference, test‑case review, and server‑architecture analysis—with precise “subtraction” methods to refine the final test set.
This article details how the Oasis Engine team tackled the technical and artistic challenges of building a large‑scale, multiplayer, third‑person virtual park for the Alipay Fortune event, covering architecture, scene splitting, asset loading, custom materials, digital human integration, networking, behavior management, and extensive performance optimizations.
This article presents a series of Python mini-game tutorials, including code for coin-collecting, ping-pong, skiing, space shooter, whack-a-mole, dinosaur runner, match-3, Tetris, snake, 24-point puzzle, alien invasion, tic-tac-toe, and more, offering complete source files and gameplay explanations.
This article details how to recreate the Flash programming game 'Manufactoria' as a web-based puzzle by implementing its UI with HTML and CSS and its logic with JavaScript, covering component definitions, grid layout, robot movement, state handling, level loading, and local storage persistence.
This article examines PlayMaker, the popular Unity visual state‑machine tool, explaining its core concepts, editor features, extensibility, collaboration benefits, limitations, and how it differs from other visual‑scripting solutions, while highlighting real‑world game examples and technical insights.
For Taobao’s 2022 Double 11 interactive games, a comprehensive QA approach combined online stress testing, reinforcement‑learning‑driven case generation, and systematic fault injection—addressing high‑concurrency, data‑consistency, and client‑performance risks through traffic shaping, data and middleware isolation, and automated tools (Wali, DaBai) that delivered over 60 smoke cases, 76 % coverage and 82.6 % fault detection.
This article outlines the various types of game storylines and provides a comprehensive checklist of testing points—including text, dialogue, subtitles, tasks, voice‑over, music, character actions, special effects, animation, camera work, map resources, NPC placement, items, mini‑games, and sharing features—to help QA teams ensure a smooth and immersive player experience.
The article reflects on developing mobile 3D games, advising developers to choose between lightweight libraries like Three.js and full‑featured engines such as Babylon.js, weigh web, native, or hybrid deployment, adopt appropriate technical trade‑offs, and build a well‑structured 3D team with clear roles to balance performance and visual quality.
This article describes how a game development team designed, implemented, and continuously improved a static checking framework for Unity assets and code, covering pre‑submission hooks, post‑submission scripts, daily checks, CI/CD integration, UI enhancements, and lessons learned for better quality assurance.
This article compiles real-world examples and practical guidance for identifying, assessing, and mitigating risks throughout the game development lifecycle, offering QA teams concrete strategies for risk definition, early estimation, and handling of demand, quality, process, testing, and operational challenges to improve overall risk management.
This article chronicles Tim Sweeney's journey from a teenage programmer to Epic Games founder, outlines the history and technical milestones of the Unreal Engine series, and explores its wide-ranging applications across gaming, 3D modeling, film, and the metaverse.
This article shares Taobao Life's journey into the Metaverse, detailing how to evaluate and select mobile 3D engines, compare Web, Native and Hybrid approaches, build professional 3D art workflows, balance visual quality with performance, and cultivate a battle‑ready 3D team.
Game server developers often avoid microservice architectures because real‑time performance, low latency, and stateful in‑memory processing are critical, and the added network overhead, stateless constraints, and complexity of service meshes can degrade gameplay, making monolithic or tightly‑coupled designs more suitable for fast-paced multiplayer games.
This guide details practical performance‑optimization techniques for Cocos‑based WeChat mini‑games, covering scene and prefab optimizations, asset compression, code size reduction, garbage‑collection handling, mask usage, plugin assistance, code‑level improvements, and a suite of testing tools to measure and verify the gains.
This article describes how OCR technology is used in a game marketplace to automatically extract skin parameters from user‑uploaded images, outlines methods for separating owned skin regions from background using color analysis, and presents a tolerant matching solution based on Rabin‑Karp hashing to handle OCR errors.
Despite the global popularity of sports video games such as FIFA and NBA 2K, the Chinese market struggles with few titles, homogeneous gameplay, high development barriers, and monetization issues, prompting a need for diversified design, esports integration, and strategic marketing to unlock its large potential.
This article presents a comprehensive guide to Unity rendering pipelines, key terminology, and practical performance‑optimization techniques—including AR, texture, memory, heat, and package‑size improvements—applied to the VI Sales Crown product, with detailed tools, methods, and measurable results.
This article explains how mobile games assign default graphics quality levels to various devices using configuration tables, code‑based matching, and a hybrid approach, detailing iOS and Android specifics, server switches, testing practices, and the trade‑offs of each method.
A team of three spent over ten months constructing a 1 Hz CPU, custom GPU, and complete game logic inside unmodded Minecraft using only redstone, enabling a playable 3D version of Minecraft within Minecraft itself.
This article walks through recreating the popular ‘Sheep a Sheep’ puzzle game using Godot Engine, detailing the game’s mechanics, three stack patterns, data structures, detection of selectable tiles, level generation, shuffling, mask handling, and inter‑object communication, while sharing code snippets and design insights.
The author explains how the viral “Sheep Sheep” puzzle’s random mechanics make it nearly impossible to clear, then details the creation of a clone called “Fish Fish” with customizable difficulty, open‑source code, and the core implementation techniques used.
This article introduces Bilibili’s self‑developed BVA avatar file format, compares it with VRM, details its features such as unified model specifications, advanced material support, dynamic bone physics, and provides step‑by‑step Unity integration, export procedures for avatars, scenes, and runtime loading, along with sample code and resources.
Unreal Engine 5, a powerful real‑time 3D creation platform, is reshaping game development, film production, architectural visualization, automotive design, simulation, and virtual events by offering open‑source C++ APIs, visual scripting, high‑fidelity rendering, and seamless workflow integration across industries.
At GDC 2022, the creators of Naraka: Bladepoint detailed how they designed a popular face‑customization system, covering why a battle‑royale game needs it, user research insights, key facial features, AI‑driven tools, cultural aesthetic considerations, sustainability, and its impact on player engagement and the industry.
This guide demonstrates how to enable touch‑based movement for a hero character, add directional walking animations, integrate animation logic, and implement physics‑based collision detection with walls in Cocos Creator, including code snippets for event handling, animation state management, and physics component setup.
This tutorial explains how to use the Tiled map editor to design tile‑based levels, import and configure the generated maps in a Cocos Creator project, add animations, replace maps, and switch to curve‑based collision walls for smoother gameplay.
This tutorial walks you through creating a fully functional Snake game in Python with Pygame, covering required environment setup, visual assets, and a complete source code example that demonstrates grid handling, movement logic, collision detection, and scoring.
This tutorial walks you through configuring scene assets, creating player, star, and game controller scripts, adding movement, jump, scoring, failure detection, and audio effects in Cocos Creator, providing complete code snippets and editor instructions to build a functional 2D platformer.
This article describes the design and implementation of an intelligent compatibility testing platform for mobile games, covering device fragmentation challenges, testing strategies, hardware setup, automated and AI‑driven testing services, real‑time monitoring, remote maintenance, and the integration of Airtest for script automation.
This article shares NetEase’s six‑year experience in building an early‑stage game evaluation framework presented at GDC 2022, outlining how to define “early” phases, key success metrics, practical assessment methods, common pitfalls, and actionable recommendations for creating better games.
The BVA format is a Chinese‑localized, glTF‑based 3D avatar standard and open‑source Unity SDK that unifies avatar specifications, adds facial‑capture and extensible features, supports scene export, multithreaded and on‑demand loading, and works across Unity, WebGL, Maya, Blender and other platforms.
This article explains what white‑box analysis is, why it matters for game feature testing, outlines a complete testing workflow from requirement to post‑release, and provides concrete examples and tips for QA engineers to improve test precision and efficiency.
This article explains how to design and code a hint feature for a 24‑point puzzle app on iOS, covering random number generation, validation of solvable sets, recursive expression search, expression‑to‑string conversion, optimization of parentheses, and provides complete Swift source code with detailed algorithmic explanations.
This article introduces Vizard, a C/C++‑based virtual‑reality development platform with Python bindings, and demonstrates how to load avatars and objects, implement a random‑walk pigeon, create talking characters, handle character movement via keyboard, capture mouse motion, and combine these techniques into a functional VR scene.
MarkovJunior, a probabilistic programming language based on Markov algorithms, can automatically create countless non‑repeating 2D and 3D mazes, terrain maps, and circuit diagrams for games, using simple rewrite rules and a single line of code.
This tutorial walks you through the complete workflow of preparing, optimizing, sculpting, organizing, and rigging a 3D donkey character in Cinema 4D, covering topology tools, sculpt mode, skeleton creation, controller adjustment, skin binding, and final animation tips.
This article introduces a PHP command‑line Minesweeper game, explains how to set rows, columns, and bomb count, shows how to start the game with a simple command, and provides a solution for Windows console encoding problems using chcp 65001.
This article describes the challenges of handling massive art assets in the Nishuihan MMO, introduces a distributed build pipeline that separates resource processing, incremental packaging, and multi‑machine scheduling, and details a series of optimizations that reduced the overall build time from over ten hours to about one and a half hours while supporting multiple functional teams.
The article explains how C++20 coroutines and the emerging execution framework are used to redesign a single‑threaded game‑server architecture, detailing custom async wrappers, integration with asio and libunifex, job‑type scheduling, example coroutine code, current limitations, and a roadmap toward a simpler, sender/receiver‑based async library.
This article introduces typical subtraction, multiplication, and division damage formulas, explains their design principles, demonstrates practical examples from games such as Arknights and Dota 2, and outlines testing methods, effective metrics, and additional concepts like stacking, round‑table theory, and second‑roll analysis for balanced combat systems.
This article provides a comprehensive introduction to Unity memory concepts—including physical, virtual, native, and managed memory—and offers practical optimization techniques for native and managed resources, graphics rendering, and tooling to improve game performance on both desktop and mobile platforms.
This article presents a complete Python implementation of the classic Gomoku board game with Pygame, explaining the rules, showing a dynamic demo, providing the full source code for the checkerboard logic, AI opponent, rendering, and instructions for running the game on your own machine.
Version 0.7 of the open‑source Oasis Engine introduces a suite of enhancements—including a new text renderer, ClearCoat PBR material, dynamic PhysX colliders, expanded BlendShape support, HDR skybox loading, keyboard interaction, and API refinements—plus comprehensive documentation and example updates for developers.
This article outlines practical strategies for organizing, reducing, and testing art assets in game development, covering resource reference standards, systematic reduction workflows, timely management of seasonal assets, detailed QA testing guidelines, and solutions to common testing challenges.
This article explores how front‑end engineers can improve H5 game experiences by focusing on stable 60 fps rendering, high‑quality assets, multi‑screen compatibility, performance‑aware animation, and intuitive interaction design, while balancing limited resources and trade‑offs to approach native‑like quality.
This article presents a complete Python pygame implementation of a classic 'Plane War' game, detailing background music integration, enemy destruction effects, scoring system, and player controls, and provides the full source code spanning over three hundred lines for readers to study and run.
This article explains the Scrum framework—its core concepts, roles, ceremonies, and iterative process—and discusses how game development teams can adopt Scrum and Scrum of Scrums to improve efficiency, manage change, and deliver valuable products.
This article demonstrates how to build a low‑poly 3D browser game using Three.js, React, and Cannon.js, covering resource loading, scene setup, physics with Heightfield terrain, joystick controls, animation handling, UI flow, and deployment, with full code examples and implementation details.
This article reviews the metaverse's 3D foundations, compares WebGL and several 3D engines—including Unity, LayaBox, Egret, Godot, and BabylonJS—explains the team's technical selection process, outlines development challenges such as model bounds, collision detection, scene switching, and memory usage, and showcases the final BabylonJS demo.
This article explains how to build a Python-based snake game with both human and AI players, detailing the development environment, core features, AI path‑finding logic using BFS, and providing complete source code for a fully functional AI snake that can compete against a human‑controlled snake.
This article walks through building a browser‑based Duck Hunt‑style shooting game using Vue 3 for the UI framework, PixiJS as the rendering engine, and supporting tools such as Vite, SCSS, mitt, and GSAP to handle asset loading, scene management, animations, hit detection, and responsive scaling.
This article presents a full Python pygame implementation of a side‑scrolling runner game, detailing imports, configuration, class definitions for the player, obstacles and background, and the main game loop with input handling, collision detection, scoring and restart logic.
This article walks through creating a navigation mesh and implementing A* pathfinding for a 3D sandbox game using Babylon.js, covering Babylon's built‑in RecastJS features, their limitations, a step‑by‑step custom NavMesh generation, algorithm choices, optimization techniques, and final integration with character movement.
