标签：#unrealengine

With all of the primary mechanics sufficiently developed to allow playtesting, the next step in the project was to develop levels to teach players how to use them as well as a single level containing puzzles for players to solve using the knowledge provided in the tutorial levels. The Tutorial The game tutorial is split into five short levels. Each level imparts knowledge of one or more of the previously developed game mechanics. The number of tutorial levels was decided by listing out all the required mechanics and dividing them up across a number of levels that gave each mechanic the desired amount of attention. The goal of this was to ensure that the player was not overwhelmed with too much new information at any one time. Here is how the mechanics were divided across the five levels: Level 1: Player movement, looking around, jumping, and interacting with objects Level 2: Command generation system, Activate command, and signal blocking and range limitations Level 3: Controlling robot NPCs, target destinations, Follow command, Move To command, Cancel command, NPC-locked doors, and pressure plates Level 4: Using the Attack command against NPCs and destinations Level 5: Reflective and absorptive surfaces, signal reflection, low-frequency signals, signal penetration limits, and secret areas Tell and Show The tutorial levels all follow a pattern of tell then show. Every mechanic is explained via text on walls in the levels, and immediately followed by an opportunity or obligation to use that mechanic. For example, the first tutorial level starts with the player facing a wall displaying the controls to look around. In order to progress into the next area, the player must use those controls to turn around in order to see the way out of the starting room as well as the text explaining how to move. Similarly, at the beginning of the second tutorial level, the controls for generating an Activate command are displayed on the wall in front of the player with a door to their

Evidence checked on July 25, 2026. This comparison separates vendor claims, general coding evidence, and native Unreal Engine delivery. Those are not the same thing. Kimi K3, Claude Opus 5, and Qwen3.8-Max-Preview all arrived with unusually strong claims around coding, visual iteration, long-running agents, or 3D creation. That makes one question inevitable for game developers: Which AI model is actually best for building an Unreal Engine 5 game? The short answer is Claude Opus 5 currently has the strongest public evidence for reliable agentic engineering and 3D reconstruction; Kimi K3 has the clearest first-party claim around playable 3D games and vision-in-the-loop iteration; Qwen3.8-Max-Preview is promising for large, multimodal engineering tasks but remains a preview with no official Unreal delivery proof. The more important answer is that none of these model announcements, by itself, proves that the model can deliver a valid native Unreal project, compile Blueprint or C++, cook assets, package a build, and reproduce the result. For Unreal work, the execution environment often matters more than a small difference in model intelligence. TL;DR: the Unreal-specific verdict Model Strongest relevant evidence Unreal-specific gap Best current role Claude Opus 5 Strong agentic coding, verification, computer use, a successful 3D FreeCAD reconstruction case, and early-user reports of better games and 3D output No official native Unreal project or packaging benchmark Lead engineering agent for difficult implementation, debugging, and review Kimi K3 First-party claim for playable multiplayer and 3D games, native vision, 1M context, long-horizon tool use, and screenshot-driven iteration Showcases do not establish .uproject , Blueprint, C++, cook, or package success Long-context, visually iterative game prototyping and tool-driven workflows Qwen3.8-Max-Preview 2.4T multimodal preview positioned for repository-scale coding, long tasks, image/video/document understanding, and a

Note: If you're new to execution calculations, I'd recommend starting with my previous post which covers them in detail, then coming back here. What is attribute capturing and why would you use it Attribute capturing refers to directly exposing certain attributes to your execution calculation from attribute sets, to be used in execution calculations. Capturing attributes lets you handle things like damage in a more complex way. So for example, you could have advantages and weaknesses against certain damage types, or an attribute like armor that should reduce incoming damage. This is just two use cases, but once you learn how to do it, you should naturally be able to see in what other ways they can be used. In this example, I will show how to get attribute magnitude from captured attributes and using them in calculations, which is the most common way of using captured attributes. Capturing attributes Defining the struct, declaring and defining attribute capture definitions In this post, I will show how to use a static struct to access all your captured attributes, as a good performance-aware solution. You are also free to choose not to use the struct. For the struct approach, the first step is to go to the .cpp of the execution calculation, and define your struct there. In the struct, we first use the DECLARE_ATTRIBUTE_CAPTUREDEF() macro, passing in the name of your attribute. After that, we make the constructor of the struct, and in the constructor we use the DEFINE_ATTRIBUTE_CAPTUREDEF() macro, passing in the attribute set that has the attribute, the attribute from it, whether the attribute from the Target or Source should be used (the Target is the ASC the ExecCalc is outputting its result to, and the Source is the ASC that called it), and a bool for if the captured attribute should be snapshotted (if the attribute should be frozen at ExecCalc GE application (snapshotted) or if the value should be read at execution time). In my case, I will show 2 examples of non-