Jötunn

https://valheim-modding.github.io/Jotunn/
Admin
Jötunn is a comprehensive library for Valheim modding that provides common helper utilities,...
Tokens:939,436
Snippets:5,858
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### Hardcoding localizations with CustomLocalization

Source: https://valheim-modding.github.io/Jotunn/tutorials/localization.html

C# example showing how to get a CustomLocalization instance and add translations for multiple languages. Call this in your mod's Awake method.

```csharp
// Your mod's custom localization
private CustomLocalization Localization;

private void AddLocalizations()
{
    // Get your mod translation instance
    Localization = LocalizationManager.Instance.GetLocalization();

    // Add translations for our custom skill
    Localization.AddTranslation("English", new Dictionary<string, string>
    {
        {"skill_TestingSkill", "TestLocalizedSkillName" },
    });

    // Add translations for the custom item in AddClonedItems
    Localization.AddTranslation("English", new Dictionary<string, string>
    {
        {"item_evilsword", "Sword of Darkness"},
        {"item_evilsword_desc", "Bringing the light"},
        {"evilsword_shwing", "Woooosh"},
        {"evilsword_scroll", "*scroll*"},
        {"evilsword_beevil", "Be evil"},
        {"evilsword_beevilmessage", ":reee:"},
        {"evilsword_effectname", "Evil"},
        {"evilsword_effectstart", "You feel evil"},
        {"evilsword_effectstop", "You feel nice again"},
    });

    // Add translations for the custom piece in AddPieceCategories
    Localization.AddTranslation("English", new Dictionary<string, string>
    {
        { "piece_lul", "Lulz" },
        { "piece_lul_description", "Do it for them" },
        { "piece_lel", "Lölz" },
        { "piece_lel_description", "Härhärhär" },
    });

    // Add translations for the custom item in AddVariants
    Localization.AddTranslation("English", new Dictionary<string, string>
    {
        { "lulz_shield", "Lulz Shield" },
        { "lulz_shield_desc", "Lough at your enemies" },
        { "lulz_sword", "Lulz Sword" },
        { "lulz_sword_desc", "Lulz on a stick" },
    });
}
```

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

### Create DoPrebuild.props to enable assembly publicizing

Source: https://valheim-modding.github.io/Jotunn/guides/guide.html

Create this file in your solution directory to enable automatic publicizing of Valheim assemblies. Set ExecutePrebuild to true. If using ModStub, the file already exists and you only need to change ExecutePrebuild to true. Enabling this generates new publicised assemblies on PreBuild only if the binaries have been updated since the last run.

```xml
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <ExecutePrebuild>true</ExecutePrebuild>
  </PropertyGroup>
</Project>

```

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

### ConfigManagerUtils.Plugin

Source: https://valheim-modding.github.io/Jotunn/api/Jotunn.Utils.ConfigManagerUtils.html

Gets the ConfigurationManager plugin instance if installed, otherwise null. Safe to use even if ConfigurationManager is not installed.

```APIDOC
## Property: Plugin

### Description
The ConfigurationManager plugin instance if installed, otherwise null.

### Syntax
```csharp
public static object Plugin { get; }
```

### Property Value
Type: object

### Remarks
Safe to use even if ConfigurationManager is not installed.
```

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

### GUID Property

Source: https://valheim-modding.github.io/Jotunn/api/Jotunn.Utils.ModRegistry.ModInfo.GUID.html

Gets the mod GUID. This property is read-only and returns a string representing the mod's unique identifier.

```APIDOC
## GUID Property

### Description
Gets the mod GUID.

### Declaration
```csharp
public string GUID { get; }
```

### Property Value
| Type | Description |
|------|-------------|
| string | The mod GUID. |

```

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

### BindConfig example for server sync

Source: https://valheim-modding.github.io/Jotunn/tutorials/config.html

Creates sample configuration values using BindConfig with server sync enabled. AcceptableValueRange<float> is used for the float value. In local/single player games, the player is always considered the admin.

```csharp
// Create some sample configuration values to check server sync
private void CreateConfigValues()
{
    AcceptableValueRange<float> floatRange = new AcceptableValueRange<float>(0f, 1000f);

    // Add server config which gets pushed to all clients connecting and can only be edited by admins
    // In local/single player games the player is always considered the admin
    Config.BindConfig("Server config", "StringValue1", "StringValue", "Server side string", synced: true);
    Config.BindConfig("Server config", "FloatValue1", 750f, "Server side float", synced: true, acceptableValues: floatRange);
    Config.BindConfig("Server config", "IntegerValue1", 200, "Server side integer", synced: true);
    Config.BindConfig("Server config", "BoolValue1", false, "Server side bool", synced: true);
}
```

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

### Create empty and piece-specific key hints

Source: https://valheim-modding.github.io/Jotunn/tutorials/inputs.html

Shows how to override the default key hint with an empty config and add custom key hints for specific building pieces. The empty config has no ButtonConfigs, while piece-specific configs override the 'Attack' key text with different hint tokens.

```csharp
// Override "default" KeyHint with an empty config
KeyHintConfig KHC_base = new KeyHintConfig
{
    Item = "BlueprintTestRune"
};
KeyHintManager.Instance.AddKeyHint(KHC_base);

// Add custom KeyHints for specific pieces
KeyHintConfig KHC_make = new KeyHintConfig
{
    Item = "BlueprintTestRune",
    Piece = "make_testblueprint",
    ButtonConfigs = new[]
    {
        // Override vanilla "Attack" key text
        new ButtonConfig { Name = "Attack", HintToken = "$bprune_make" }
    }
};
KeyHintManager.Instance.AddKeyHint(KHC_make);

KeyHintConfig KHC_piece = new KeyHintConfig
{
    Item = "BlueprintTestRune",
    Piece = "piece_testblueprint",
    ButtonConfigs = new[]
    {
        // Override vanilla "Attack" key text
        new ButtonConfig { Name = "Attack", HintToken = "$bprune_piece" }
    }
};
KeyHintManager.Instance.AddKeyHint(KHC_piece);
```

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

### GetClutter(string)

Source: https://valheim-modding.github.io/Jotunn/api/Jotunn.Utils.ModRegistry.html

Gets all added CustomClutter objects of a mod by GUID.

```APIDOC
## GetClutter(string)

### Description
Gets all added CustomClutter objects of a mod by GUID.

### Method
GetClutter

### Parameters
- **guid** (string) - The GUID of the mod.

### Syntax
```csharp
public static IEnumerable<CustomClutter> GetClutter(string guid)
```

### Returns
- **IEnumerable<CustomClutter>** - All added CustomClutter objects of the specified mod.
```

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

### GetCreatures(string)

Source: https://valheim-modding.github.io/Jotunn/api/Jotunn.Utils.ModRegistry.GetCreatures.html

Gets all added CustomCreatures of a specific mod by GUID.

```APIDOC
## GetCreatures(string modGuid)

### Description
Gets all added CustomCreatures of a mod by GUID.

### Method
GetCreatures(string modGuid)

### Parameters
- **modGuid** (string) - Required - GUID of the mod

### Returns
- **IEnumerable<CustomCreature>** - An IEnumerable<T> of CustomCreature from a specific mod

### Declaration
```csharp
public static IEnumerable<CustomCreature> GetCreatures(string modGuid)
```
```

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

### Create(string, int, bool)

Source: https://valheim-modding.github.io/Jotunn/api/Jotunn.Entities.MockRequirement.Create.html

Creates a mocked Piece.Requirement with the specified prefab name, amount, and recover flag.

```APIDOC
## Create(string, int, bool)

### Description
Creates a mocked Piece.Requirement.

### Method
Create

### Signature
public static Piece.Requirement Create(string name, int amount = 1, bool recover = true)

### Parameters
- **name** (string) - Required - Prefab name
- **amount** (int) - Optional - Amount (default: 1)
- **recover** (bool) - Optional - Whether the item is dropped after deconstructing a piece (default: true)

### Returns
- **Requirement** - The mocked Piece.Requirement.
```

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

### Create a map overlay showing zone boundaries

Source: https://valheim-modding.github.io/Jotunn/tutorials/map.html

Subscribe to OnVanillaMapAvailable and draw zone borders onto the overlay's texture. Use GetMapOverlay to retrieve or create the overlay, set pixels, and apply changes. Do not save references to overlays as they are recreated on each world load.

```csharp
private void Awake()
{
    // Add map overlays to the minimap on world load
    MinimapManager.OnVanillaMapAvailable += CreateMapOverlay;
}

// Map overlay showing the zone boundaries
private void CreateMapOverlay()
{
    // Get or create a map overlay instance by name
    var zoneOverlay = MinimapManager.Instance.GetMapOverlay("ZoneOverlay");

    // Create a Color array with space for every pixel of the map
    int mapSize = zoneOverlay.TextureSize * zoneOverlay.TextureSize;
    Color[] mainPixels = new Color[mapSize];
            
    // Iterate over the dimensions of the overlay and set a color for
    // every pixel in our mainPixels array wherever a zone boundary is
    Color color = Color.white;
    int zoneSize = 64;
    int index = 0;
    for (int x = 0; x < zoneOverlay.TextureSize; ++x)
    {
        for (int y = 0; y < zoneOverlay.TextureSize; ++y, ++index)
        {
            if (x % zoneSize == 0 || y % zoneSize == 0)
            {
                mainPixels[index] = color;
            }
        }
    }

    // Set the pixel array on the overlay texture
    // This is much faster than setting every pixel individually
    zoneOverlay.OverlayTex.SetPixels(mainPixels);

    // Apply the changes to the overlay
    // This also triggers the MinimapManager to display this overlay
    zoneOverlay.OverlayTex.Apply();
}
```

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

### Plugin Property

Source: https://valheim-modding.github.io/Jotunn/api/Jotunn.Utils.ConfigManagerUtils.Plugin.html

Gets the ConfigurationManager plugin instance if installed, otherwise null.

```APIDOC
## Plugin Property

### Description
Gets the ConfigurationManager plugin instance if installed, otherwise null.

### Declaration
```csharp
public static BaseUnityPlugin Plugin { get; }
```

### Property Value
| Type | Description |
|------|-------------|
| BaseUnityPlugin | The ConfigurationManager plugin instance, or null if not installed. |

```

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

### GetItems(string modGuid)

Source: https://valheim-modding.github.io/Jotunn/api/Jotunn.Utils.ModRegistry.GetItems.html

Gets all added CustomItems of a specific mod by its GUID.

```APIDOC
## GetItems(string modGuid)

### Description
Gets all added CustomItems of a mod by GUID.

### Method
GetItems(string modGuid)

### Declaration
```csharp
public static IEnumerable<CustomItem> GetItems(string modGuid)
```

### Parameters
| Type | Name | Description |
|------|------|-------------|
| string | modGuid | GUID of the mod |

### Returns
| Type | Description |
|------|-------------|
| IEnumerable<CustomItem> | An IEnumerable<T> of CustomItem from a specific mod |

```

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

### Print all modded prefabs using ModQuery.GetPrefabs()

Source: https://valheim-modding.github.io/Jotunn/tutorials/mod-registry.html

Iterates over all modded prefabs indexed by the Mod Query and logs their names and source mods. Vanilla prefabs are not included.

```csharp
Jotunn.Logger.LogInfo($"Modded prefabs:");
foreach (var moddedPrefab in ModQuery.GetPrefabs())
{
    Jotunn.Logger.LogInfo($"  {moddedPrefab.Prefab.name} added by {moddedPrefab.SourceMod.Name}");
}

```

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

### UpdatedPluginGUIDs Property

Source: https://valheim-modding.github.io/Jotunn/api/Jotunn.Utils.ConfigurationSynchronizationEventArgs.UpdatedPluginGUIDs.html

Gets or sets the set of plugin GUIDs that received configuration data during a synchronization event.

```APIDOC
## UpdatedPluginGUIDs Property

### Description
GUID for each Plugin that received configuration data.

### Declaration
```csharp
public HashSet<string> UpdatedPluginGUIDs { get; set; }
```

### Property Value
| Type | Description |
|------|-------------|
| HashSet<string> | The set of plugin GUIDs that received configuration data. |

```

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

### IsModuleOnServer(string)

Source: https://valheim-modding.github.io/Jotunn/api/Jotunn.Utils.ModCompatibility.IsModuleOnServer.html

Checks if a mod, identified by its GUID string, is installed and loaded on the server. Can be called from both client and server.

```APIDOC
## IsModuleOnServer(string)

### Description
Checks if a mod, identified by its GUID string, is installed and loaded on the server. Can be called from both client and server.

### Method
IsModuleOnServer(string modGUID)

### Parameters
- **modGUID** (string) - Required - BepInEx mod GUID to check

### Returns
- **bool** - true if the mod is loaded on the server. false if the mod is not loaded on the server or no server connection is established.

### Declaration
```csharp
public static bool IsModuleOnServer(string modGUID)
```
```

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

### Create BetterSpawnCommand console command

Source: https://valheim-modding.github.io/Jotunn/tutorials/console-commands.html

Defines a custom console command that spawns prefabs. Overrides CommandOptionList to enable tab auto-completion using ZNetScene prefab names. Prints an error message if the prefab does not exist.

```csharp
public class BetterSpawnCommand : ConsoleCommand
{
    public override string Name => "better_spawn";

    public override string Help => "like spawn but BETTER";

    public override void Run(string[] args)
    {
        if (args.Length == 0)
        {
            return;
        }

        GameObject prefab = PrefabManager.Instance.GetPrefab(args[0]);
        if (!prefab)
        {
            Console.instance.Print("that doesn't exist: " + args[0]);
            return;
        }

        int cnt = args.Length < 2 ? 1 : int.Parse(args[1]);
        for (int i = 0; i < cnt; i++)
        {
            UnityEngine.Object.Instantiate<GameObject>(prefab, Player.m_localPlayer.transform.position + Player.m_localPlayer.transform.forward * 2f + Vector3.up, Quaternion.identity);
        }
    }

    public override List<string> CommandOptionList()
    {
        return ZNetScene.instance?.GetPrefabNames();
    }
}

```

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

### public static event Action OnVanillaMapAvailable

Source: https://valheim-modding.github.io/Jotunn/api/Jotunn.Managers.MinimapManager.OnVanillaMapAvailable.html

Event that gets fired once the Map for a World has started and Mods can begin to draw.

```APIDOC
## Event OnVanillaMapAvailable

### Description
Event that gets fired once the Map for a World has started and Mods can begin to draw.

### Namespace
Jotunn.Managers

### Assembly
Jotunn.dll

### Syntax
```csharp
public static event Action OnVanillaMapAvailable
```

### Returns
| Type | Description |
| --- | --- |
| Action | Event that gets fired once the Map for a World has started and Mods can begin to draw. |

```
Tokens:
Raw