Redscript

https://wiki.redmodding.org/redscript
Admin
Redscript is an open-source programming language and toolset for Cyberpunk 2077's scripting runtime,...
Tokens:25,482
Snippets:131
Trust Score:7.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Example redscript Project File Structure

Source: https://wiki.redmodding.org/redscript/getting-started/setup-for-vscode

This snippet illustrates the typical directory layout for a redscript project named 'Cocktail', showing the placement of the configuration file, main script files, and nested directories for data and services.

```Filesystem
Cocktail/
|-- red.config.json                // Project's configuration, see README.
|-- scripts/
    |-- FruitCocktail.reds
    |-- Utils.reds
    |-- Data/
        |-- Fruit.reds
        |-- Banana.reds
    |-- Services/
        |-- CocktailService.reds
    |-- Extensions/
        |-- PlayerPuppet.reds
        |-- ItemObject.reds
```

--------------------------------

### Redscript Example: Basic LogChannel Usage

Source: https://wiki.redmodding.org/redscript/references-and-examples/logging

Illustrates how to use the `LogChannel` function within a wrapped method. This example demonstrates logging a simple debug message to a specified channel when the `OnRestored` method of `EquipmentSystemPlayerData` is executed, providing immediate feedback during gameplay.

```redscript
@wrapMethod(EquipmentSystemPlayerData)
func OnRestored() -> Void {
    wrappedMethod(); // call the original function
    LogChannel(n"DEBUG", "Player Initialized"); // create a log output
}
```

--------------------------------

### Test redscript Plugin Functionality

Source: https://wiki.redmodding.org/redscript/getting-started/setup-for-jetbrains-ides

This redscript code snippet is provided to verify the successful installation and configuration of the redscript plugin in a JetBrains IDE. It demonstrates basic redscript syntax, including module and class definitions, function declarations, variable assignments, conditional statements, and calls to game-related APIs, allowing users to test features like syntax highlighting, auto-completion, and 'go to declaration'.

```redscript
// Simple test
module Awesome

public class SimpleTest extends ScriptableSystem {

  /* Ain't this great?! */
  public func Chat(msg: String) {
    FTLog(s"Says \(msg)");
    let test = GoToDeclaration.CtrlClick();

    if test == true {
      FTLog("Yes");
    } else {
      FTLog("No");
    }
    let gi = GetGameInstance();
    let cameraSystem: wref<CameraSystem> = gi.GetCameraSystem();
    let ratio: Float = cameraSystem.GetAspectRatio();

    FTLog(s"camera ratio: \(ratio)");
  }

}

public class GoToDeclaration {

  public static func CtrlClick() -> Bool {
    FTLog("CTRL + CLICK should redirect you.");
    FTLog("You can test it by writing this class in another file.");
    return true;
  }

}
```

--------------------------------

### red-cli pack Command Output Archive Structure

Source: https://wiki.redmodding.org/redscript/getting-started/setup-for-vscode

This snippet demonstrates the resulting ZIP archive structure generated by running the `red-cli pack` command on the example 'Cocktail' project. It shows how redscript files are bundled, merged per module, and organized for release, with global scope code merged into a '.Global.reds' file.

```Filesystem
Cocktail/
|-- Cocktail-v0.1.0.zip
    |-- r6/
        |-- scripts/
            |-- Cocktail/
                |-- Cocktail.reds
                |-- Cocktail.Global.reds
                |-- Cocktail.Data.reds
                |-- Cocktail.Services.reds
                |-- Cocktail.Extensions.reds
```

--------------------------------

### Wrap Method for Photo Mode Inventory Setup

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Wraps the `SetupInventory` method in `PhotoModePlayerEntityComponent`, likely for customizing inventory display or behavior within photo mode.

```Redscript
@wrapMethod(PhotoModePlayerEntityComponent)
private final func SetupInventory(isCurrentPlayerObjectCustomizable: Bool)
```

--------------------------------

### Correct Redscript Field Declaration Example

Source: https://wiki.redmodding.org/redscript/getting-started/setup-for-vscode

This redscript code snippet shows the correct way to declare a field. The type 'Bool' is correctly capitalized, resolving the error from the previous example and allowing the code to compile successfully.

```redscript
//add field to NPC class
@addField(NPCPuppet)
let testField: Bool;
```

--------------------------------

### ComputerMenuButtonController Method Wrapping

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Example of wrapping the `Initialize` method in `ComputerMenuButtonController`, used to set up the button with game controller and widget data. This allows for custom initialization logic for computer menu buttons.

```redscript
@wrapMethod(ComputerMenuButtonController)
public func Initialize(gameController: ref<ComputerInkGameController>, widgetData: SComputerMenuButtonWidgetPackage) -> Void
```

--------------------------------

### DamageSystem.ProcessPipeline Method Signature

Source: https://wiki.redmodding.org/redscript/getting-started/how-to-start-redscripting/step-2-finding-the-right-class

Signature for the ProcessPipeline method within the DamageSystem class. This is the starting event that gets called when an object is hit and possesses a gameHitEvent variable.

```REDscript
private final func ProcessPipeline(hitEvent: ref<gameHitEvent>, cache: ref<CacheData>) -> Void
```

--------------------------------

### REDscript: Defining Custom Classes and Methods

Source: https://wiki.redmodding.org/redscript/language/intro/redscript-in-2-minutes

This example demonstrates how to define a custom class (IntTuple) in REDscript. It includes defining properties, a static factory method (Create) for object instantiation, and an instance method (Swap) to modify object state.

```REDscript
// you can define your own classes
public class IntTuple {
  let fst: Int32;
  let snd: Int32;

  // you can define static member functions
  public static func Create(fst: Int32, snd: Int32) -> ref<IntTuple> {
    let tuple = new IntTuple();
    tuple.fst = fst;
    tuple.snd = snd;
    return tuple;
  }

  public func Swap() {
    let tmp = this.fst;
    this.fst = this.snd;
    this.snd = tmp;
  }
}
```

--------------------------------

### Redscript Example: Using Custom Mod Logger

Source: https://wiki.redmodding.org/redscript/references-and-examples/logging

Demonstrates how to import and utilize the custom `MyMod.Logger` functions within a `ScriptableService` class. This snippet shows how the prefixed log messages appear in the game log, providing clear identification of the source of each log entry.

```redscript
import Codeware.*
import MyMod.Logger.*

class CrazyService extends ScriptableService {
  private cb func OnLoad() {
    MyLog("Psycho stuff!");
    MyLogWarn("Psycho stuff!");
    MyLogError("Psycho stuff!");
  }
}
```

--------------------------------

### Access Custom Scriptable System in Redscript

Source: https://wiki.redmodding.org/redscript/references-and-examples/common-patterns/scriptable-systems-singletons

This snippet illustrates how to retrieve an instance of a custom scriptable system from the `GameInstance` using `GetScriptableSystemsContainer` and `Get`. It highlights the importance of including the namespace when accessing systems defined within modules and demonstrates calling a method on the retrieved system.

```redscript
let container = GameInstance.GetScriptableSystemsContainer(gameInstance);
// don't forget the namespace if you're using modules
let system = container.Get(n"MyMod.MySystem") as MySystem;

LogChannel(n"DEBUG", ToString(system.GetData()));
```

--------------------------------

### Example TOML Configuration for REDscript User Hints

Source: https://wiki.redmodding.org/redscript/language/language-features/configurable-user-hints

This TOML configuration demonstrates how to define custom hint messages for the REDscript compiler. It shows how to match specific error codes (e.g., 'UNRESOLVED_REF', 'UNRESOLVED_TYPE') using patterns like 'span_starts_with' or 'line_contains' and then provide a user-friendly message, such as advising the installation of a missing dependency like TweakXL.

```TOML
[[UNRESOLVED_REF]]
id = "MISSING_TWEAKXL"
span_starts_with = "TweakDBManager"
message = "one of your mods depends on TweakXL, try installing it"

[[UNRESOLVED_TYPE]]
id = "MISSING_TWEAKXL"
file = "CraftingQualityOfLife/RandomQualityModsTweakDB.reds"
line_contains = "extends ScriptableTweak"
message = "CraftingQualityOfLife depends on TweakXL, try installing it"
```

--------------------------------

### Redscript Extracted Folder Structure

Source: https://wiki.redmodding.org/redscript/getting-started/setup-for-vscode

This snippet illustrates the expected folder structure after extracting the redscript zip file. These folders ('engine' and 'r6') should be merged directly into the Cyberpunk 2077 game directory.

```plaintext
- engine
- r6
```

--------------------------------

### ComputerControllerPS Method Wrapping

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Example of wrapping the `GetMenuButtonWidgets` method in `ComputerControllerPS`, which retrieves an array of computer menu button widget packages, useful for customizing computer UI elements.

```redscript
@wrapMethod(ComputerControllerPS)
public final func GetMenuButtonWidgets() -> array<SComputerMenuButtonWidgetPackage>
```

--------------------------------

### InventoryItemModeLogicController Method Wrapping

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Examples of wrapping methods in `InventoryItemModeLogicController`, focusing on UI interactions like updating wardrobe, handling item clicks, and hover events. These methods manage the logic behind inventory item interactions.

```redscript
@wrapMethod(InventoryItemModeLogicController)
private final func UpdateOutfitWardrobe(active: Bool, activeSetOverride: Int32)
protected cb func OnItemDisplayClick(evt: ref<ItemDisplayClickEvent>) -> Bool
protected cb func OnItemDisplayHoverOver(evt: ref<ItemDisplayHoverOverEvent>) -> Bool
private final func SetInventoryItemButtonHintsHoverOver(const displayingData: script_ref<InventoryItemData>, opt display: ref<InventoryItemDisplayController>)
private final func HandleItemClick(const itemData: script_ref<InventoryItemData>, actionName: ref<inkActionName>, opt displayContext: ItemDisplayContext, opt isPlayerLocked: Bool)
```

--------------------------------

### Example REDscript Compiler Error Output

Source: https://wiki.redmodding.org/redscript/language/language-features/configurable-user-hints

This code snippet illustrates typical REDscript compiler errors, specifically 'UNRESOLVED_TYPE' and 'UNRESOLVED_REF', that arise when a required mod or dependency, such as TweakXL, is not installed. These errors indicate that the compiler cannot locate definitions for classes or references used within the mod's scripts.

```REDscript
 [ERROR] [UNRESOLVED_TYPE] At ./r6/scripts/CraftingQualityOfLife/RandomQualityModsTweakDB.reds:41:1:
public class AddFixedQualityModRecords extends ScriptableTweak {
^^^
class ScriptableTweak not found

 [ERROR] [UNRESOLVED_REF] At ./r6/scripts/CraftingQualityOfLife/RecraftIconicsTweakDB.reds:160:13:
            TweakDBManager.CloneRecord(newCraftingRecipeElement, weaponIngredientRecipeElement.GetID());
            ^^^^^^^^^^^^^^
unresolved reference TweakDBManager
```

--------------------------------

### Example Usage of Redscript StaticCallback with DelaySystem

Source: https://wiki.redmodding.org/redscript/references-and-examples/common-patterns/generic-callbacks

Illustrates how to use the `StaticCallback` class within a `ScriptableService` to schedule a static method call (`OnPlay`) after a delay using `DelaySystem`. This example shows creating a `StaticCallback` instance with a module-qualified function name and passing arguments, demonstrating its use for global or static function callbacks.

```redscript
module MyModule

public class MyService extends ScriptableService {

  // ...

  public cb func OnSessionReady(event: ref<GameSessionEvent>) {
    if event.IsPreGame() {
      return;
    }
    let delaySystem = GameInstance.GetDelaySystem(GetGameInstance());
    let callback = StaticCallback.Create(n"MyModule.MyService::OnPlay", [n"Choom"]);
    let delay: Float = 1.0; // seconds

    delaySystem.DelayCallback(callback, delay, false);
    // callback.Call();
  }

  // [cb] is required to make function a callback.
  // [name] is an optional argument which can be passed when calling [StaticCallback.Create].
  private static cb func OnPlay(name: CName) {
    FTLog(s"name: \(name)");
    // do stuff after [delay] s.
  }

}
```

--------------------------------

### REDscript: Adding New Methods to Existing Classes with @addMethod

Source: https://wiki.redmodding.org/redscript/language/intro/redscript-in-2-minutes

This example demonstrates how to extend existing game classes (e.g., BackpackMainGameController) by adding new methods using the @addMethod decorator. It includes iterating through player items, calling helper functions, and using CName literals for game resource references.

```REDscript
// you can add new methods to existing classes as well
// they are visible to other code using the class
@addMethod(BackpackMainGameController)
private final func DisassembleAllJunkItems() -> Void {
  let items = this.m_InventoryManager.GetPlayerItemsByType(gamedataItemType.Gen_Junk);
  let i = 0;
  for item in items {
    ItemActionsHelper.DisassembleItem(this.m_player, InventoryItemData.GetID(item));
  };
  // some methods require CName literals, they need to be prefixed with the n letter
  this.PlaySound(n"Item", n"OnBuy");
}
```

--------------------------------

### Redscript: Registering a Codeware Callback for Key Input

Source: https://wiki.redmodding.org/redscript/references-and-examples/codeware-callbacks

This Redscript example demonstrates how to create a `ScriptableService` that registers a callback with Codeware's `CallbackSystem`. The `OnLoad` function initializes the system and binds the `OnKeyInput` method to the `Input/Key` event, ensuring it only reacts once to a key press by using an internal flag.

```Redscript
class ExampleService extends ScriptableService {
  // instance variables
  private let callbackSystem: wref<CallbackSystem>;
  private let found: Bool = false;

  // This function is always executed
  private func OnLoad() {
    this.callbackSystem = GameInstance.GetCallbackSystem();
    this.callbackSystem.RegisterCallback(n"Input/Key", this, n"OnKeyInput", true);

    LogChannel(n"DEBUG", s"ExampleService loaded");
  }

  // Will always listen, but only react once
  private cb func OnKeyInput(event: ref<KeyInputEvent>) {
    if this.found {
      return;
    }
    LogChannel(n"DEBUG", s"You pressed your key, going dormant now: \(event.GetAction()) \(event.GetKey())");
    this.found = true;
  }

}
```

--------------------------------

### UIInventoryItem Method Wrapping

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Examples of wrapping methods in `UIInventoryItem`, including checks for equipped status, transmog, and a static `Make` method for creating an inventory items manager. These methods are fundamental for UI representation and management of inventory items.

```redscript
@wrapMethod(UIInventoryItem)
public final func IsEquipped(opt force: Bool) -> Bool
public final func IsTransmogItem() -> Bool
public final static func Make(player: wref<PlayerPuppet>, transactionSystem: ref<TransactionSystem>, uiScriptableSystem: wref<UIScriptableSystem>) -> ref<UIInventoryItemsManager>
public final func IsItemEquippedInSlot(itemID: ItemID, slotID: TweakDBID) -> Bool
public final func IsItemTransmog(itemID: ItemID) -> Bool
```

--------------------------------

### Example Usage of Redscript Callback with DelaySystem

Source: https://wiki.redmodding.org/redscript/references-and-examples/common-patterns/generic-callbacks

Demonstrates how to integrate and use the `Callback` class within a `ScriptableService` to schedule a method call (`OnPlay`) after a specified delay using `DelaySystem`. It illustrates the creation of a `Callback` instance, passing an instance reference and arguments, and defines the target callback method with the `cb` keyword.

```redscript
public class MyService extends ScriptableService {

  // ...

  public cb func OnSessionReady(event: ref<GameSessionEvent>) {
    if event.IsPreGame() {
      return;
    }
    let delaySystem = GameInstance.GetDelaySystem(GetGameInstance());
    let callback = Callback.Create(this, n"OnPlay", [42]);
    let delay: Float = 1.0; // seconds

    delaySystem.DelayCallback(callback, delay, false);
    // callback.Call();
  }

  // [cb] is required to make function a callback.
  // [arg] is an optional argument which can be passed when calling [Callback.Create].
  private cb func OnPlay(arg: Int32) {
    FTLog(s"arg: \(arg)");
    // do stuff after [delay] s.
  }

}
```

--------------------------------

### Redscript Persistent Field Declaration Example

Source: https://wiki.redmodding.org/redscript/references-and-examples/common-patterns/persistence

This Redscript example demonstrates how to declare fields with the `persistent` modifier within a custom class (`Entry`) and how to use an array of these persistent objects within a `ScriptableSystem`. It highlights that only fields explicitly marked `persistent` will be saved, while others will be initialized with defaults.

```Redscript
module MyMod

public class Entry {
    // both of these will be persisted
    public persistent let related: TweakDBID;
    public persistent let lasting: Int32;
    // this won't be persisted
    public let temporary: Int32;
}

public class MySystem extends ScriptableSystem {
    private persistent let m_entries: array<ref<Entry>>;
}
```

--------------------------------

### BrowserController Method Wrapping

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Example of wrapping the `OnPageSpawned` callback method in `BrowserController`, which is triggered when a browser page widget is spawned. This provides a hook for custom actions upon browser page creation.

```redscript
@wrapMethod(BrowserController)
protected cb func OnPageSpawned(widget: ref<inkWidget>, userData: ref<IScriptable>) -> Bool
```

--------------------------------

### Redscript Conditional Compilation Examples with @if

Source: https://wiki.redmodding.org/redscript/language/language-features/conditional-compilation

This comprehensive example illustrates various applications of the `@if` annotation for conditional compilation in Redscript. It demonstrates how to conditionally import modules, define alternative function implementations, apply method wrappers, declare entire classes, and conditionally define fields and methods within a class, all based on the existence of other modules.

```redscript
module My.Mod
// This line will only import Other.Mod if it exists.
@if(ModuleExists("Other.Mod"))
import Other.Mod.*

// This function has two versions: one for when Other.Mod exists and one for
// when it doesn't.
// The imports from Other.Mod are only valid in the first version, because
// they depend on the condition.
@if(ModuleExists("Other.Mod"))
func Testing() -> Int32 {
    return 1;
}
@if(!ModuleExists("Other.Mod"))
func Testing() -> Int32 {
    return 2;
}

// This method wrapper/replacement only take effect if Other.Mod doesn't exist.
@if(!ModuleExists("Other.Mod"))
@wrapMethod(PlayerPuppet)
protected cb func OnGameAttached() -> Bool {
  Log("I'm in a wrapper");
  wrappedMethod();
}

// Class is defined only if Other.Mod exists.
@if(ModuleExists("Other.Mod"))
public class MySettings {
  // Same as Testing() above, but for fields of a class.
  @if(ModuleExists("Other.Mod"))
  let resolution: Vector2;
  @if(!ModuleExists("Other.Mod"))
  let resolution: String;

  // Same as Testing() above, but for methods of a class.
  @if(ModuleExists("My.Mod.Test"))
  public func GetMode() -> CName {
    return n"Debug";
  }
  @if(!ModuleExists("My.Mod.Test"))
  public func GetMode() -> CName {
    return n"Release";
  }
}
```

--------------------------------

### Timeskip Game Controller Hook

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Example of wrapping the `Apply` method in `TimeskipGameController`, which is executed when the player skips time in the game. This allows for custom actions or modifications during time-skipping events.

```redscript
@wrapMethod(TimeskipGameController)
private final func Apply() -> Void
```

--------------------------------

### Implement a while loop in REDscript

Source: https://wiki.redmodding.org/redscript/language/language-features/loops

Demonstrates how to use a `while` loop in REDscript to repeatedly execute a block of code as long as a condition is true. This example iterates through an array, logging each element.

```REDscript
let i = 0;
let array = ["a", "b", "c"];

while i < ArraySize(array) {
  let elem = array[i];
  Log(elem);
  i += 1;
}
// will log a, b and c
```

--------------------------------

### Redscript Conditional Compilation Directives

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Examples of redscript conditional compilation directives (`@if` and `@if!`) used to check for the existence of specific modules like 'VirtualAtelier.Site'. These are used to conditionally include or exclude code blocks during compilation.

```redscript
@if(ModuleExists("VirtualAtelier.Site"))
@if(!ModuleExists("VirtualAtelier.Site"))
```

--------------------------------

### Define a Custom In-Game Popup using Codeware

Source: https://wiki.redmodding.org/redscript/references-and-examples/ui-scripting/popups

Defines a custom popup class 'MinimalPopup' that extends Codeware's 'InGamePopup'. This example illustrates how to structure a reusable UI component with custom header, footer, and content, including dynamic text updates and widget creation.

```redscript
public class MinimalPopup extends InGamePopup {
    protected let m_header: ref<InGamePopupHeader>;
    protected let m_footer: ref<InGamePopupFooter>;
    protected let m_content: ref<InGamePopupContent>;
    protected let m_text: wref<inkText>;
    protected let customText: String = "Default text";

    public static func Create() -> ref<MinimalPopup> {
        let self: ref<MinimalPopup> = new MinimalPopup();
        self.CreateInstance();
        return self;
    }

    protected cb func OnInitialize() {
        super.OnInitialize();
        this.m_text.SetText(this.customText);
    }

    protected cb func OnCreate() {
	super.OnCreate();
	this.m_container.SetSize(new Vector2(800.0, 600.0));
	this.m_header = InGamePopupHeader.Create();
	this.m_header.SetTitle("Minimal Popup");
	this.m_header.SetFluffRight("Text Example");
	this.m_header.Reparent(this);
	this.m_footer = InGamePopupFooter.Create();
	this.m_footer.SetFluffIcon(n"fluff_triangle2");
	this.m_footer.SetFluffText("Simple popup with updatable text");
	this.m_footer.Reparent(this);
	this.m_content = InGamePopupContent.Create();
	this.m_content.Reparent(this);

	let canvas = new inkCanvas();
	canvas.SetName(n"canvas");
	canvas.SetAnchor(inkEAnchor.Fill);
	canvas.Reparent(this.m_content.GetRootCompoundWidget());

	let text = new inkText();
	text.SetName(n"updatableText");
	text.SetFontFamily("base\\gameplay\\gui\\fonts\\raj\\raj.inkfontfamily");
	text.SetFontStyle(n"Medium");
	text.SetFontSize(30);
	text.SetHorizontalAlignment(textHorizontalAlignment.Center);
	text.SetVerticalAlignment(textVerticalAlignment.Center);
	text.SetAnchor(inkEAnchor.Centered);
	text.SetAnchorPoint(new Vector2(0.5, 0.5));
	text.SetMargin(new inkMargin(0.0, 0.0, 0.0, 0.0));
	text.SetWrapping(true, 700.0);
	text.SetFitToContent(true);
	text.SetStyle(r"base\\gameplay\\gui\\common\\main_colors.inkstyle");
	text.BindProperty(n"tintColor", n"MainColors.Blue");
        text.SetText("Default text");
        text.Reparent(canvas);
	this.m_text = text;
    }

    public func SetCustomText(text: String) -> Void {
        this.customText = text;
    }
}
```

--------------------------------

### Define a REDscript Module with Public Functions

Source: https://wiki.redmodding.org/redscript/language/language-features/modules

This example illustrates how to define a REDscript module that contains public functions. These functions, 'Pi' and 'E', are made accessible from other files, but require fully qualified names for direct access at runtime.

```REDscript
module Math.Constants

public func Pi() -> Float = 3.14159
public func E() -> Float = 2.71828
```

--------------------------------

### Log UI Layer Hierarchy in Redscript

Source: https://wiki.redmodding.org/redscript/references-and-examples/ui-scripting/logging-widget-trees

This Redscript function demonstrates how to retrieve a specific UI layer's virtual window and then log its widget tree. It uses `GameInstance.GetInkSystem().GetLayer()` to access the layer by its `CName` and `GetVirtualWindow()` to get its root. The `LogChannelTree` function (assumed to be defined elsewhere) is called to perform the actual logging of the widget hierarchy.

```redscript
private static func PrintLayerHierarchy(CName layerName) {
    let window = GameInstance.GetInkSystem().GetLayer(layerName).GetVirtualWindow();
    let rootWidget = window.GetWidgetByPathName(n"Root") as inkCanvas;
    // The function LogWidgetTree is defined below
    LogChannelTree(n"DEBUG", baseHudRoot);
}

PrintLayerHierarchy(n"inkHUDLayer")
```

--------------------------------

### Redscript Native Logging and Tracing Functions (Cyberpunk 2.01+)

Source: https://wiki.redmodding.org/redscript/references-and-examples/logging

Defines the native logging and tracing functions available in Cyberpunk 2.01 and later versions. These functions are essential for outputting debug information to the CET console or `scripting.log` and require inclusion in a file like `r6\scripts\Logs.reds` to avoid `UNRESOLVED_FN` errors during compilation.

```APIDOC
native func Log(const text: script_ref<String>) -> Void
native func LogWarning(const text: script_ref<String>) -> Void
native func LogError(const text: script_ref<String>) -> Void

// output goes to CET window
native func LogChannel(channel: CName, const text: script_ref<String>)
native func LogChannelWarning(channel: CName, const text: script_ref<String>) -> Void
native func LogChannelError(channel: CName, const text: script_ref<String>) -> Void

native func FTLog(const value: script_ref<String>) -> Void
native func FTLogWarning(const value: script_ref<String>) -> Void
native func FTLogError(const value: script_ref<String>) -> Void

native func Trace() -> Void
native func TraceToString() -> String
```

--------------------------------

### Redscript Custom Logger with Stack Trace Information

Source: https://wiki.redmodding.org/redscript/references-and-examples/logging

Enhances the `MyMod.Logger` to automatically include class and function names from the call stack in log messages. By leveraging `GetStackTrace` from Codeware, this advanced logger provides valuable context for debugging without requiring manual input of location details.

```redscript
module MyMod.Logger

public static func MyLog(value: script_ref<String>) -> Void {
  let entries = GetStackTrace(1, true);
  let entry = entries[0];
  let trace = "";

  if IsDefined(entry.object) {
    trace = s"[\(entry.class)][\(entry.function)]";
  } else {
    trace = s"[\(entry.function)]";
  }
  FTLog(s"[MyMod] \(trace) \(value)");
}
```

--------------------------------

### Incorrect Redscript Field Declaration Example

Source: https://wiki.redmodding.org/redscript/getting-started/setup-for-vscode

This redscript code snippet demonstrates an incorrect field declaration. The type 'bool' is lowercase, which will result in a compilation error in redscript, as types are typically capitalized.

```redscript
//add field to NPC class
@addField(NPCPuppet)
let testField: bool;
```

--------------------------------

### WardrobeSetPreviewGameController Method Wrapping

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Demonstrates wrapping methods in `WardrobeSetPreviewGameController`, such as `OnInitialize`, `OnPreviewInitialized`, and `RestorePuppetEquipment`. These methods control the initialization and restoration of wardrobe set previews.

```redscript
@wrapMethod(WardrobeSetPreviewGameController)
protected cb func OnInitialize() -> Bool
protected cb func OnPreviewInitialized() -> Bool
public final func RestorePuppetEquipment()
```

--------------------------------

### Wrap Method for Equipment Preview Initialization

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Wraps the `OnPreviewInitialized` callback method in `inkPuppetPreviewGameController`, used to inject custom logic when the equipment preview is initialized.

```Redscript
@wrapMethod(inkPuppetPreviewGameController)
protected cb func OnPreviewInitialized() -> Bool
```

--------------------------------

### REDscript: Basic Syntax, Variables, and Global Functions

Source: https://wiki.redmodding.org/redscript/language/intro/redscript-in-2-minutes

This snippet introduces fundamental REDscript syntax, including line and block comments, global function definition, variable declaration with type inference, arithmetic operations, type casting, array literals, and iteration with logging.

```REDscript
// redscript allows line comments
/* as well as block comments */

// it supports global functions
func add2(x: Int32, y: Int32) -> Int32 {
  return x + y;
}

// functions without a type annotation default to Void return type
func tutorial() {
  let x: Int32 = 10;
  // compiler can infer types for local variables, y will be Int32
  let y = 20;
  // it supports arithmetic
  let sum = x + y + 13;
  // as well as mutation
  let mutable = 0;
  mutable += 10;
  // numbers with decimal points default to type Float
  let num = 10.0;
  // you can cast between some types
  let uint: Uint8 = Cast(10);
  // array literals
  let arr = [1, 2, 3];
  // array iteration
  for item in arr {
    // logging and string operations
    Log("at " + ToString(item));
  }
}
```

--------------------------------

### Redscript Usage of Static Factory `Create` Method

Source: https://wiki.redmodding.org/redscript/references-and-examples/common-patterns/class-constructors

Illustrates how to use the `CustomClass.Create` static factory method to instantiate and initialize an object in a single line. This approach provides a cleaner syntax for object creation compared to manual field assignment.

```Redscript
let myCustomClass = CustomClass.Create(1,"Hello");
```

--------------------------------

### Wrap Method for D-Pad Wheel Initialization

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Wraps the `OnInitialize` callback method for `DpadWheelGameController`, enabling modifications to the weapon selection wheel's initialization process.

```Redscript
@wrapMethod(DpadWheelGameController)
protected cb func OnInitialize() -> Bool
```

--------------------------------

### Wrap Methods for Backpack Main Game Controller

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Wraps `OnInitialize`, `OnItemDisplayClick`, and `NewShowItemHints` methods in `BackpackMainGameController` to customize backpack behavior, including initialization, item interaction, and hint display.

```Redscript
@wrapMethod(BackpackMainGameController)
protected cb func OnInitialize() -> Bool
protected cb func OnItemDisplayClick(evt: ref<ItemDisplayClickEvent>) -> Bool
private final func NewShowItemHints(itemData: wref<UIInventoryItem>)
```

--------------------------------

### Dynamically Remove Vehicle Components in Redscript

Source: https://wiki.redmodding.org/redscript/references-and-examples/vehicle-system

This example shows how to create a `ScriptableSystem` (`MyVehicleWatcher`) to dynamically modify vehicle components during the assembly phase. It registers an `OnEntityAssemble` callback to intercept entity assembly events. The code specifically targets a 'quadra_type66_vtech_noralee' vehicle and iterates through its components to hide the 'body_01' mesh by setting its `chunkMask` to 0, effectively removing it visually.

```Redscript
class MyVehicleWatcher extends ScriptableSystem {
  private let m_callbackSystem: wref<CallbackSystem>;

  private func OnAttach() {
    this.m_callbackSystem = GameInstance.GetCallbackSystem();
    this.m_callbackSystem.RegisterCallback(n"Entity/Assemble", this, n"OnEntityAssemble");
  }

  private cb func OnEntityAssemble(event: ref<EntityLifecycleEvent>) {
    // Something useful to note is that during vehicle assembly the vehicle record
    // is null, so you cannot use it to identify the car. This is why entity
    // appearance is used.
    let entity = event.GetEntity();
    let templatePath = r"base\\vehicles\\sport\\v_sport2_quadra_type66__basic_01.ent";
    let appearanceName = n"quadra_type66_vtech_noralee";

    if entity.GetTemplatePath() == templatePath && Equals(entity.GetCurrentAppearanceName(), appearanceName) {
      let vehicle = entity as VehicleObject;

      if !IsDefined(vehicle) {
        return;
      }
      let components = vehicle.GetComponents();

      for comp in components {
        if Equals(comp.GetName(), n"body_01") {
          let meshComp = comp as MeshComponent;

          meshComp.chunkMask = 0ul;
        }
      }
    }
  }
}
```

--------------------------------

### QuestTrackerGameController Method Wrapping

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Shows wrapping the `OnInitialize` method of `QuestTrackerGameController`, which is called when the quest tracker is initialized.

```redscript
@wrapMethod(QuestTrackerGameController)
protected cb func OnInitialize() -> Bool
```

--------------------------------

### Wrap Methods for In-Game Menu Controller

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Wraps methods in `gameuiInGameMenuGameController` to customize the in-game menu, including initialization, puppet readiness, equipment changes, and uninitialization.

```Redscript
@wrapMethod(gameuiInGameMenuGameController)
protected cb func OnInitialize() -> Bool
protected cb func OnPuppetReady(sceneName: CName, puppet: ref<gamePuppet>) -> Bool
protected cb func OnEquipmentChanged(value: Variant) -> Bool
protected cb func OnUninitialize() -> Bool
```

--------------------------------

### Wrap Method for Inventory Puppet Preview Initialization

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Wraps the `OnInitialize` method in `inkInventoryPuppetPreviewGameController`, allowing custom logic to be executed when the inventory puppet preview is initialized.

```Redscript
@wrapMethod(inkInventoryPuppetPreviewGameController)
protected cb func OnInitialize() -> Bool
```

--------------------------------

### Redscript Class with Static Factory `Create` Method

Source: https://wiki.redmodding.org/redscript/references-and-examples/common-patterns/class-constructors

Introduces a common pattern to simulate constructors in Redscript: a static factory method named `Create`. This method encapsulates the object instantiation and field initialization, returning a `ref` to the newly created and configured `CustomClass` instance, providing a cleaner initialization syntax.

```Redscript
public class CustomClass{
    //all the variables
    public let myInt: Int32;
    public let myString: String;

    public static func Create(inputInt: Int32, inputString: String) -> ref<CustomClass>{
        //you create the new instance of your class here instead of in your code
        //and set its variables
        let self = new CustomClass();
        self.myInt = inputInt;
        self.myString = inputString;
        return self;
    }
}
```

--------------------------------

### Declare Literal Types in redscript

Source: https://wiki.redmodding.org/redscript/language/native-types

Examples of declaring `String`, `CName`, `ResRef`, and `TweakDBID` literal types in redscript, demonstrating their respective prefixes and syntax for creating constant values.

```redscript
"Hello world"
```

```redscript
n"VehicleComponent"
```

```redscript
r"base\\anim_cooked.cookedanims"
```

```redscript
t"Items.RequiredItemStats"
```

--------------------------------

### InventoryItemDisplayController Method Wrapping

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Demonstrates wrapping methods within the `InventoryItemDisplayController` class, including `Bind` (with overloaded signatures) and UI refresh functions. These methods are crucial for managing how inventory items are displayed in the game UI.

```redscript
@wrapMethod(InventoryItemDisplayController)
public func Bind(inventoryDataManager: ref<InventoryDataManagerV2>, equipmentArea: gamedataEquipmentArea, opt slotIndex: Int32, opt displayContext: ItemDisplayContext, opt setWardrobeOutfit: Bool, opt wardrobeOutfitIndex: Int32) {
public func Bind(inventoryScriptableSystem: ref<UIInventoryScriptableSystem>, equipmentArea: gamedataEquipmentArea, opt slotIndex: Int32, displayContext: ItemDisplayContext)
protected func RefreshUI()
protected func NewUpdateRequirements(itemData: ref<UIInventoryItem>)
```

--------------------------------

### React to Headlight Changes in Redscript

Source: https://wiki.redmodding.org/redscript/references-and-examples/vehicle-system

This snippet demonstrates how to define a custom event `vehicleChangeHeadLightModeEvent` and implement a protected callback `OnChangeHeadLightModeEvent` within a `VehicleObject`. The callback logs the current headlight mode when the event is triggered, specifically checking if the player is mounted in the vehicle.

```Redscript
native class vehicleChangeHeadLightModeEvent extends Event {}

@addMethod(VehicleObject)
protected cb func OnChangeHeadLightModeEvent(evt: ref<vehicleChangeHeadLightModeEvent>) {
    if this.IsPlayerMounted() {
        LogChannel(n"DEBUG", s"OnChangeHeadLightModeEvent \(this.GetVehiclePS().GetVehicleControllerPS().GetHeadLightMode())");
    }
}
```

--------------------------------

### ComputerInkGameController Method Wrapping

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Illustrates wrapping methods in `ComputerInkGameController`, specifically `ShowMenuByName` and `HideMenuByName`, which are used to control the visibility of computer menus within the game UI.

```redscript
@wrapMethod(ComputerInkGameController)
private final func ShowMenuByName(elementName: String) -> Void
private final func HideMenuByName(elementName: String) -> Void
```

--------------------------------

### Integrate Ragdoll Logic into Damage Processing Wrapper

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook

Finalizes the `ProcessLocalizedDamage` wrapper by integrating the custom ragdoll logic. After initial setup and error handling, this code identifies the hit NPC and calls the `RagdollNPC` helper function to apply the ragdoll effect, completing the mod's functionality.

```redscript
@wrapMethod(DamageSystem)
private func ProcessLocalizedDamage(hitEvent: ref<gameHitEvent>) {
    //start vanilla function, so everything at least runs normally (even if the mod doesnt work)
    wrappedMethod(hitEvent);

    //variables
    let hitUserData: ref<HitShapeUserDataBase>;
    let hitShapes: array<HitShapeData> = hitEvent.hitRepresentationResult.hitShapes;

    //error handling and setting up hitUserData (copy & paste from original)
    if !hitEvent.attackData.GetInstigator().IsPlayer() {
      return;
    };

    if AttackData.IsAreaOfEffect(hitEvent.attackData.GetAttackType()) {
      return;
    };

    if ArraySize(hitShapes) > 0 {
      hitUserData = DamageSystemHelper.GetHitShapeUserDataBase(hitShapes[0]);
    };

    if !IsDefined(hitUserData) {
      return;
    };

    //actual mod code
    let npc: ref<NPCPuppet> = hitEvent.target as NPCPuppet;
    let npcID: StatsObjectID = Cast(npc.GetEntityID());
    if IsDefined(npc) {
      RagdollNPC(npc, 10.0);
    };
}
```

--------------------------------

### Define Custom Scriptable System in Redscript

Source: https://wiki.redmodding.org/redscript/references-and-examples/common-patterns/scriptable-systems-singletons

This snippet demonstrates how to create a custom scriptable system in Redscript by extending the `ScriptableSystem` class. It includes private `OnAttach` and `OnDetach` lifecycle methods for initialization and cleanup, and a public `GetData` function to expose functionality.

```redscript
module MyMod

public class MySystem extends ScriptableSystem {
  private func OnAttach() -> Void {
    LogChannel(n"DEBUG", "MySystem::OnAttach");
  }

  private func OnDetach() -> Void {
    LogChannel(n"DEBUG", "MySystem::OnDetach");
  }

  public func GetData() -> Float {
    return GetPlayer(this.GetGameInstance()).GetGunshotRange();
  }
}
```

--------------------------------

### Wrap Methods for Inventory Game Controller

Source: https://wiki.redmodding.org/redscript/language/intro/how-to-create-a-hook/things-to-hook

Wraps methods in `gameuiInventoryGameController` to customize inventory behavior, including initialization, uninitialization, wardrobe button clicks, popup closures, and equipment clicks.

```Redscript
@wrapMethod(gameuiInventoryGameController)
protected cb func OnInitialize() -> Bool
protected cb func OnUninitialize() -> Bool
private final func SetupSetButton() -> Void
protected cb func OnWardrobeBtnClick(evt: ref<inkPointerEvent>) -> Bool
protected cb func OnWardrobePopupClose(data: ref<inkGameNotificationData>)
protected cb func OnBack(userData: ref<IScriptable>) -> Bool
protected cb func OnEquipmentClick(evt: ref<ItemDisplayClickEvent>) -> Bool
```

--------------------------------

### Safe Downcasting with `as` and `IsDefined` in Redscript

Source: https://wiki.redmodding.org/redscript/references-and-examples/common-patterns/safe-downcasting

This Redscript example demonstrates how to safely downcast a `ref<VehicleObject>` to more specific types such as `WheeledObject`, `CarObject`, or `BikeObject`. The `as` operator attempts the cast, returning `null` on failure. The `IsDefined` check then verifies if the cast was successful, allowing type-specific operations only when the object is of the expected type.

```redscript
let vehicle: ref<VehicleObject>;

let wheels = vehicle as WheeledObject;
if IsDefined(wheels) {
  // vehicle is known to be a WheeledObject.
}

let car = vehicle as CarObject;
if IsDefined(car) {
  // vehicle is known to be a CarObject.
}

let bike = vehicle as BikeObject;
if IsDefined(bike) {
  // vehicle is known to be a BikeObject.
}
```
Tokens:
Raw