XCOM 2 was released yesterday across all territories, and brings with it the promise of a glorious strategy renaissance. But not all players are able to fully enjoy the game–a minority of players have, as with every PC title, been experiencing issues with XCOM 2.

• Xcom 2 Modding Tutorial Episode 3
• Xcom 2 Modding Tutorial Pc

The issues in the game range from crashes, errors, low framerate, and more.
We’ve prepared this guide to provide solutions for these issues. These fixes have been confirmed by players on reddit and the Steam forums to work, though your mileage may vary.

XCOM 2 Crashes on Startup

If your game crashes on startup, there’s a good chance your installation of XCOM 2 is corrupted. To fix this, simply go to your Library in Steam, right-click on XCOM 2 and select Local Files > Verify integrity of game cache, and let Steam redownload any files you’re missing.

XCOM 2 Crashes at the End of the Tutorial

If you’re running the game on an AMD graphics card, you may experience a crash when the game tries to play the cutscene immediately following the basic unit movements tutorial. To fix this issue, download the AMD Crimson Drivers 15.12 or newer.

Error 41

This error only occurs if you have a virus scanner running in the background. Disable Norton, Kaspersky, McAfee, or whatever antivirus software you have on your computer before running the game.

VCOMP120.DLL Crash

Official Map Modding Tutorial (Part 2): Making a custom ydr! This topic has been deleted. Only users with topic management privileges can see it. Background Info: Whats up modders back at you with my second tutorial for gta V map modding. In this one we will be making a custom.ydr.

If your game crashes with this error, you’ll need reinstall some run-time components on your PC. Grab it directly from Microsoft and avoid any other websites. There’s a lot of malware out there.

Geoscape Crash

If your game hangs upon loading up the Geoscape interface after you complete the two tutorial missions, simply reload a combat autosave from the most recent battle and finish the mission again.

Stuttering Cutscenes and Low Framerate

You should disable Ambient Occlusion and Screen Space Reflections, and turn your Anti-Aliasing (AA) down to FXAA or off. By default, the game will set your AA to the highest settings possible, which introduces a lot of performance issues.

• 2Programs and Tools
• 3Details

Overview

[The following is based upon wghost81's pseudo-code decompiler.]

When examining decompiled hex code that has been rendered in UnrealScript, it is often necessary to identify the hex code of certain operators and functions ('tokens'). So the following tables are often called 'token tables'.

Rev: Apr 2015

Programs and Tools

Though not required for use with this article, see reference Modding Tools - XCOM:EU 2012 for links. Here are short descriptions of the necessary tools.

UE Explorer

An Unreal Engine decompiler. For more information on decompilers in general, see this Decompiler Wikipedia article. This program lets you see the decompiled code almost as their creators wrote it, providing key information you will need to change UPK files, such as getting its hex representation, etc.

HxD HEX Editor

A general purpose hex editor. This is the program used to actually change the UPK files with the compiled hex codes.

Details

These tables show the decompiled UnrealScript and it's compiled hex code equivalent.

See Native Tables - XCOM:EU 2012 for the interpretation guidelines for byte-codes into decompiled code used within the UE Explorer (UEE) tool, which in turn is described and linked in Modding Tools - XCOM:EU 2012.

See Hex editing UPK files for information on how to apply this information. Basically these tables are used to interpret what a particular hex code means in terms of program function (using UE Explorer), and also how to convert an intended functionality into the necessary hex code to modify or replace the existing code (using a hex editor such as HxD).

Tokens

Since tokens are 1 byte in size, they can hold values from 0x00 to 0xFF, which gives 256 possible values. And there are way more native functions in the Unreal Engine (UE) than 256. To solve this problem UE uses the 0x60-0x6F tokens as markers which indicate that the index of that function exceeds the 0x00-0xFF range and that the next token should be used to identify a native function with an index greater than 0xFF. This effectively makes extended native function tokens 2 bytes long and increases the possible index range up to 0xFFF.

The thing with the 0x61-0x6F tokens is that they allow extending the native table beyond 256 functions.

Token 0x60 marks the beginning of the extended native tokens group and is never actually used in scripts. I believe they did it to save memory space, as the most frequently used tokens are 1 byte long and less frequently used extended tokens are 2 bytes long.

So, indexes 0x00-0x5F belong to the most frequently used tokens, which define basic UnrealScript operators. Those operators are defined in C++ code and are not declared inside Core and EngineUnrealScript classes. Indexes 0x70 to 0xFF are used for common operations, like comparison and summation. Corresponding functions are declared in base UnrealScript classes (like Object and Actor) but defined in C++ code. All the other functions with indexes from 0x100 to 0xFFF are declared in UnrealScript classes and defined in C++ code. Such functions have native(XXX) keyword, which indicates that they are a part of the native table ('XXX' is a placeholder for a native table index).

Basic UnrealScript functions have a specific hex data format and all the other native functions follow the same pattern:

This pattern holds for tokens 0x70 through 0xFF <ExtendedNativeToken>. (Token 0x60 is omitted to save space.)

For tokens 0x100 through 0xFFF the pattern is:

So as an example, for the 0x60 extended function with index 921 (= 0x399) the UnrealScript is:

Xcom 2 Modding Tutorial Episode 3

The shortened version of this explanation is given inside the tokens table on this page. Since all the extended functions follow the same pattern, their hex data format is identical.

In the same way, Cast Tokens belong in a different table, as they are not reused tokens but a second part of the PrimitiveCast token0x38.

Since tokens 0x00 through 0x5F do not have an associated Package.Class and have a different hex format and a lot of notes, they are placed in a separate table just for them alone.

NativeTableIndex

Actual size of the Native Table is 0x1000 (4096 dec) possible native functions. NativeTableIndex is the value in parentheses in their UnrealScript code. Example:

By looking at this definition we can see that the boolean equal-equal comparison operator is a native function with NativeTableIndex=242 (dec).

Here is another example:

This definition means that Vector2D multiply operator has NativeTableIndex=2513 (dec). (In the ODS tableNativeTableIndex is given in column D in dec and in column E in hex representation.) So, every native function has its own unique index in between 0x000 and 0xFFF.

Now let's look at how those indexes are represented in bytecode. Each 'expression' in bytecode starts with one or two tokens, which represent the corresponding native function call: <ExtendedNativeToken> <FunctionToken>.

If NativeTableIndex is less than 256 (indexes from 0x000 to 0x0FF) then <FunctionToken>=NativeTableIndex and <ExtendedNativeToken> is entirely omitted. So, boolean equal-equal comparison operator with NativeTableIndex=242 is represented by one byte: F2 in bytecode. Stock and commodity market bcom notes.

If NativeTableIndex is greater than 255 (indexes from 0x100 to 0xFFF) then both <ExtendedNativeToken> and <FunctionToken> are present as two bytes in the bytecode:

So, the Vector2D multiply operator with NativeTableIndex=2513 (dec; 0x9D1) is represented by two bytes in bytecode: 69 D1, so it will appear in the 0x69 Extended Function table. That is: for indexes 256 (0x100) through 4095 (0xFFF), the first byte is equal to one of the 'NativeFunctionX' tokens (0x61-0x6F) and the second byte is equal to the rightmost byte of NativeTableIndex for this function.

They could just use 2 bytes for each token, but this wouldn't be as effective as it is now, because on average each script would be twice as long.

UnrealScript Code Table

Values from this table are used directly; no additional prefix token is needed.

Example (LocalVariable):

<FunctionToken> = 1 byte NativeTableIndex

Xcom 2 Modding Tutorial Pc

UnrealScript Code Table - Extended Native Functions

Values from this table are never used directly, they are used as prefix tokens for calling Extended Native Functions with indexes > 255.

2 byte NativeTableIndex = <ExtendedNativeToken 'x'> <FunctionToken>

UnrealScript Code Table (continued)

Values from this table are used directly, no additional prefixing token is needed. Function call follows this pattern:

Example (GotoState):

<FunctionToken> = 1 byte NativeTableIndex

Extended Native Function 0x61 Table

Values from this table require prefixing the 61 (NativeFunction1 token) before the <Function token>. Function call follows this pattern:

Example (Sleep):

2 byte Bytecode Value = <ExtendedNativeToken '0x61'> <FunctionToken 'x'> (i.e. 0x6100-0x61FF).
2 byte NativeTableIndex (i.e. NTIndex) = 0x01 <FunctionToken 'x'> (i.e. 0x0100-0x01FF).

Extended Native Function 0x62 Table

Values from this table require prefixing the 62 (NativeFunction2 token) before the <Function token>. Function call follows this pattern:

Example (CanSee):

2 byte Bytecode Value = <ExtendedNativeToken '0x62'> <FunctionToken 'x'> (i.e. 0x6200-0x62FF).
2 byte NativeTableIndex (i.e. NTIndex) = 0x02 <FunctionToken 'x'> (i.e. 0x0200-0x02FF).

Extended Native Function 0x65 Table

Values from this table require prefixing the 65 (NativeFunction5 token) before the <Function token>. Function call follows this pattern:

Example (IsZero):

2 byte Bytecode Value = <ExtendedNativeToken '0x65'> <FunctionToken 'x'> (i.e. 0x6500-0x65FF).
2 byte NativeTableIndex (i.e. NTIndex) = 0x05 <FunctionToken 'x'> (i.e. 0x0500-0x05FF).

Extended Native Function 0x69 Table

Values from this table require prefixing the 69 (NativeFunction9 token) before the <Function token>. Function call follows this pattern:

Example (V2DSize):

2 byte Bytecode Value = <ExtendedNativeToken '0x69'> <FunctionToken 'x'> (i.e. 0x6900-0x69FF).
2 byte NativeTableIndex (i.e. NTIndex) = 0x09 <FunctionToken 'x'> (i.e. 0x0900-0x09FF).

Extended Native Function 0x6A Table

Values from this table require prefixing the 6A (NativeFunctionA token) before the <Function token>. Function call follows this pattern:

Example (Multiply_Vector2DVector2D):

2 byte Bytecode Value = <ExtendedNativeToken '0x6A'> <FunctionToken 'x'> (i.e. 0x6A00-0x6AFF).
2 byte NativeTableIndex (i.e. NTIndex) = 0x0A <FunctionToken 'x'> (i.e. 0x0A00-0x0AFF).

Extended Native Function 0x6F Table

Values from this table require prefixing the 6F (NativeFunctionF token) before the <Function token>. Function call follows this pattern:

Example (SetPhysics):

2 byte Bytecode Value = <ExtendedNativeToken '0x6F'> <FunctionToken 'x'> (i.e. 0x6F00-0x6FFF).
2 byte NativeTableIndex (i.e. NTIndex) = 0x0F <FunctionToken 'x'> (i.e. 0x0F00-0x0FFF).

PrimitiveCast Tokens 0x38 Table

Cast tokens are used for primitive cast operations: i.e. if you need to convert a variable of type INT to type FLOAT for example, you need to use a Cast Token; which is prefixed by the PrimitiveCast token0x38.

Example (INT to FLOAT):

Cast tokens are using one native PrimitiveCast Function (token 38) and the CastToken itself is a 'parameter' for this function.

References

Referred to by this article:

That refer to this article: