This tutorial demonstrates how to use Python and the Pygame library to create a real‑time visual simulation of the solar system, complete with background images, rotating planet sprites, optional music, and frame‑rate control, providing a hands‑on example of basic game‑style graphics programming.
This article explains the role of maps in games and provides a step‑by‑step guide to creating a top‑down, real‑time minimap that follows the player, covering preparation, objectives, technical solutions, canvas rendering, ray‑casting calculations, and implementation details for both orthographic and oblique perspectives.
This article details Baidu's strategy of integrating interactive games, collectible cards, and video challenges into its app during the Asian Games, outlining design decisions, immersive experience phases, IP creation, and operational goals to boost user engagement and session time.
This article presents seven beginner‑friendly Python mini‑projects—including a graphical calculator, a notepad editor, a login/registration interface, a Snake game, a Tetris clone, and a Link‑Match puzzle—each explained with design ideas, implementation steps, and complete source code using Tkinter or Pygame.
This article provides a comprehensive technical overview of GPU architecture, from memory hierarchy and compute units to rendering pipelines and optimization techniques, explaining how modern graphics hardware processes shaders, manages resources, and balances performance across different rendering strategies.
The article provides a full Python Pygame implementation of a two‑player “Airplane Battle” game, detailing initialization, background scrolling, player controls, bullet and asteroid handling, scoring, and the main game loop, along with the complete source code.
This article provides a step‑by‑step tutorial and full Python Pygame source code for creating a simple endless‑runner game, covering imports, configuration, character, obstacle and background classes, game initialization, object spawning, logic updates, collision detection, and scoring.
This article details Ubisoft China's strategy for integrating generative AI into AAA game production, covering the evolution of diffusion models, their impact on 2D concept art workflows, data collection and preparation, model fine‑tuning with proprietary tools, experimental results, and insights from a Q&A session with Development Director Alexis Rolland.
This article provides step-by-step tutorials and complete Python Pygame source code for implementing four classic games—2048, Snake, Tetris, and LianLianKan—explaining game mechanics, design principles, and code structure to help Python developers build and understand these interactive applications.
This article explores why 1980s games like Contra could deliver rich graphics, music, and gameplay within just 128KB by examining data size perception, tile‑based graphics, limited audio chips, and ultra‑compact code techniques that contrast sharply with modern app bloat.
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.
