Technical Analysis

Back to Home Page

Warband will be utilising the Unreal 3 Engine created by Epic Games Inc. to create a realistic and believable world to immerse the player in.

The animation tool in the Unreal Engine is advanced but yet relatively straight forward to use when compared with competitors such as Valve's Source engine. Unreal includes an AnimSet viewer tool for browsing and organizing animations into different groups. Using the AnimSet Viewer sockets can be placed on bones of the model to be used with attaching objects, such as guns, to the skeleton in game. Overlay meshes can also be created and previewed in the viewer and based off the same skeleton which can be useful for creating the armour structure for a skeletal mesh.

Animation in the engine is driven by the AnimTree, a tree of animation nodes, which includes:
Blend controllers - the ability to blend between animations: instead of capturing additional animations for transitions between actions, such as walking to running, blend controllers are used to make the animation blend fluidly and save time in motion capturing.

The animation tool in the Unreal Engine is capable of mirroring an animation set of a character in real time to obtain the "opposite" animation set. For example the animation data of a character in cover facing left can be mirrored in real time to obtain the animation data of a character facing right with no restrictions on the number of animations playing at the same time, the number of blends or post-processing operations; Additionally the Unreal Engine supports Group animations which can be as a whole, or just a subset and handle notifications for the whole group. By combining the blending and mirroring of animations together much less motion captured animations are required to achieve a fully functional set of animation trees for any game - different animation blend types can be picked per blend node and per blend controller.

The Unreal Engine also features export tools for 3D Studio Max, Maya and XSI for bringing in custom created weighted meshes, skeletons and animation sequences into the engine.

UnrealMatinee is the system that is used for keyframing properties of an object or a group of objects over time and creating in-game cinematics - unreal matinee features movie director-class control over all the objects in a scene as well as cameras and cuts using the director track to determine which cameras are to be shown at specified points of any given scene.

UnrealMatinee utilises a track-based non-linear style of editing system with support for controlling object movement, rotation and animation, playing audio, modifying an actor's properties, cutting between cameras, toggling field-of-view and much more. Animations can be accomplished by using easily created key frames for actors and objects; which can be manipulated directly in the editor viewport using transform gizmos and property sheets - Animations can be previewed completely in-editor for real time feedback without any waits for rendering of an object. UnrealMatineee features an Intergrated Curve Editor to allow for precise control of keyframed motion and properties over time. Specific curve chanels can be manipulated, control point targets can be adjusted and curves can be flattened or broken.


UnrealMatinee has many built-in track types for animating any scene; Audio master tracks for controlling global volume and pitch, visibility tracks for showing and hiding objects, event tracks for triggering UnrealScript code from within an animation sequence - any property can generally be exposed for UnrealMatinee to control and new types of animation tracks can easily be added.

Not only is the Unreal 3 Engine able to produce realistic game environments, but it is also capable of creating pre-rendered cinematics that can be played back offline or converted to a standard video format. Scenery, animation curves and actor transformations can be exported for use with stand alone animation software, such as 3ds Max; changes can be imported back into UnrealMatinee.

UnrealKismet has an easy to use user-interface. This allows the user to have limitless control of almost every aspect of the game without even touching code. The point-to-point system allows a visual representation of the events the user is changing. The user can change anything from simply giving the player a weapon or other item to creating an entire complex animatic sequence without ever having to use anything but the simple actions given to them in kismet.

Prototyping is a very quick and effective way to demonstrate a game and its aspects. This is made even simpler with kismet as even basic knowledge of the engine will give you control over many aspects that would be hard to change in other engines, even with script.


Along with the basic actions given to you, there is also a complex Mathematical feature to kismet which allows the user to perform simple and complex algorithms to help with their games mechanics. This means that counters, tallies and other mathematical points in the game can be done automatically within the engines using new or existing integers, floats and booleans.

Unreal supports hierarchies of scripts for sorting various scripts into simple actions that can be linked and combined to perform complex actions without having to debug endless lines of script. This allows programmers to extend or even create their own specific game events and actions. This makes doing complex things in unreal very easy, cutting down on time and money. This also means that designers can do a lot of things that normally only programmers could do. This leaves a lot more time for them to go deeper into the foundations of the game, UScript.

There is a native language support available for many different aspects necessary to the scripting element for the engine, such as "dynamically scoped state machines and time-based execution of code" using the built in delta-time (overall game time).

UScript automatically supports metadata and is fully backwards compatible with other versions of UScript. It also allows the designers to see when code will execute in UnrealEd. This makes collaboration a lot easier between the programmers and the designers because they can easily communicate where and when they want events to happen within the game itself.

The syntax is very generic and is basically the same as C++ and many other scripting languages. The general layout and wording is easy to understand and work with. It also uses a class system with allows the user to easily find what they are looking for or reference something from another piece of script. The class system also allows the user to take a piece of script that is already used in the engine and modify it to do whatever they want. This is called a mutator.

The script is also capable of managing the garbage data and the overall lifetime of objects and other scripts. This means that the game will run a lot smoother and won't build up a large cache of information, making it run much better on lower specification machines.

Because the game and engine run from the same executable the script can be compiled through the same file. This makes compiling the script a lot more efficient and easier to do.

UScript has built in support for networking, making running particular scripts in one or more location very easy. The scripts can be run on the server, the client’s machine or on both to keep them up to date. This makes running the game over a local area network or the internet a lot quicker as you don't always have to download scripts and events from the server to the client. This can be controlled very easily by the game state. This will decide what data is transmitted across the network and when it is sent/received. The native binary format of the script is compiled into separate packages (usually in the same class), similar to .dlls, with the built in support for cross-package referencing.

The script itself allows support for interfaces and is capable of delegating itself to particular scripts. Meaning it will behave like a different type of script. For example a weapon script can also act like a pickup script in the sense that they can both be picked up in the same way and they both go into a particular inventory slot. There is also a debugger called nFringe (created by Pixel Mine Games) that runs in Microsoft Visual Studio making the script a lot easier to handle.

The engine is a state-of-the-art visual interface, designed for use by a variety of skill levels, from beginner to professional. The editor allows simple placement of various objects such as players, NPCs, inventory items, AI paths and light sources. This makes the editor very easy to use and change.

The editor allows fully interactive real-time rending of every aspect of the level while editing so the player can see exactly what the level will look like to the player in-game. Everything with dynamic lighting to shadows is included in the update and it can be easily turned off if you have a lot on screen or a lower specification computer. This can be achieved because the editor is part of the game itself and runs through the same executable. This also means that the editor can jump into the game at any point with the click of a button.

The editor is built of a network of data-driven properties, allowing level designers to easily and effectively customize any object in the game, and for programmers to expose new variables in almost any object. This opens up unlimited possibilities to the designers.

The editor can load huge environments by creating sub-levels to maximise efficiency and seamlessly stream between them. The brush-based architectural design system (BSP or Builder Brush) allows for rapid level prototyping and shelling, meaning the level designer doesn't have to create 3D models of every wall and column in the game.


The multi-thread technology allows the editor to take full advantage of the multiprocessor technology for increasing workflow, such as rapidly generating static lighting and shadow interaction.

The following information is from

Unreal Engine includes a suite of content editing tools:
• A powerful new Content Browser for organizing game assets of all types, including a robust asset tagging system, and a slick, modern interface. Users can quickly search through all assets in the entire game (whether they’re loaded or not) and apply tags without having to check out files or worry about contention between users. Search features are simple and intuitive, and a robust filtering system is right at hand. Assets can be organized into "collections" and shared with other users. Users can create and maintain asset package files with full support for source control interactions.
• Terrain Editor, a landscape design tool. Supports geometry editing and painting of alpha layers onto terrain to control blending and decoration, collision data, and displacement maps.
• Material Editor, an intuitive visual tool for designing materials and shaders.
• Mesh Editor, for previewing meshes and adjusting physics properties. Also includes support for simplification of meshes, generating LODs and texture coordinates, and fracturing objects.
• Animation Editors, for configuring skeletal animation behavior, designing complex animation states, and binding them to in-game events such as sounds and script notifications.
• UnrealPhAT, the Physics Asset Tool for creating physics rigs for characters and objects (e.g. ragdolls).
• UnrealCascade, a particle physics and environmental effects editor.
• UnrealMatinee, a powerful tool for authoring in-game cinematics.
• UnrealKismet, a visual scripting language.
• UI Editor, a style-based designer for user interfaces. Includes built-in support for importing True Type fonts.
• Sound Cue Editor, for sequencing audio events and adjusting sound properties.
• Post-process Editor, for chaining together after-effects such as motion blur and depth of field.
• Lens Flare Editor, for cinematic lens effects.
• Mesh fracturing tool, enables developers to take virtually any existing mesh, slice it up into as many fragments as desired, and destroy structures.
• Task Browser, for keeping track of outstanding tasks for the currently-loaded level. Integrates with defect-tracking software of choice, with built-in support for TestTrack Pro by Seapine Software.
• Scene Manager with ample geometry and lighting statistics to help teams optimize scene complexity and performance.
• Reference Graph viewer keeps track of level’s asset dependencies automatically.
• Asset workflow:
• Plug-ins for Autodesk 3ds Max, Maya and SoftImage XSI allow for importing models with mesh topology, mapping coordinates, skeleton structure, animation data, smoothing groups and materials names.
• Built-in support for importing meshes and animations from COLLADA files.
• Fully integrated source control, so that artists and level designers can check out content packages, modify, and check in from within the editor.

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License