NAV Navbar
csharp
  • Getting Started
  • Universal Hooks
  • Server Hooks
  • Player Hooks
  • Entity Hooks
  • Item Hooks
  • Resource Gathering Hooks
  • Structure Hooks
  • Vehicle Hooks
  • Commands
  • Configurations
  • Storing Data
  • Timers (Basic)
  • Web Requests
  • Plugin Calling
  • Item List
  • Styling Messages
  • Getting Started

    namespace Oxide.Plugins
    {
        [Info("EpicStuff", "Unknown", 0.1)]
        [Description("Makes epic stuff happen")]
    
        class EpicStuff : HurtworldPlugin
        {
            // The rest of the code and magic
        }
    }
    

    The Title variable is what defines your plugin. This should be a unique codename or short description such as Pets.

    The Author variable is used to show who made the plugin. This should match your OxideMod.org username if releasing.

    The Version variable is used to tell if the plugin is outdated or not, and is incremented with each release. Semantic Versioning recommended.

    The Description variable helps explain to users what your plugin does, in case the title isn't enough. Make it good, but not too long!

    Universal Hooks

    Available for all supported games

    7 Days to Die Blockstorm Hurtworld Reign of Kings Rust Rust Legacy The Forest Unturned

    Init

    void Init()
    {
        Puts("Init works!");
    }
    

    Loaded

    void Loaded()
    {
        Puts("Loaded works!");
    }
    

    Unload

    void Unload()
    {
        Puts("Save files, destroy timers, etc");
    }
    

    LoadDefaultConfig

    protected override void LoadDefaultConfig()
    {
        Puts("Default configuration created");
    }
    

    LoadDefaultMessages

    private new void LoadDefaultMessages()
    {
        lang.RegisterMessages(new Dictionary<string, string>
        {
            ["Example"] = "This is an example message!",
            ["AnotherExample"] = "Here is another example"
        }, this);
    }
    

    OnFrame

    void OnFrame()
    {
        Puts("OnFrame works!");
    }
    

    OnPluginLoaded

    void OnPluginLoaded(Plugin name)
    {
        Puts($"Plugin '{name}' has been loaded");
    }
    

    OnPluginUnloaded

    void OnPluginUnloaded(Plugin name)
    {
        Puts($"Plugin '{name}' has been unloaded");
    }
    

    OnServerInitialized

    void OnServerInitialized()
    {
        Puts("OnServerInitialized works!");
    }
    

    OnServerSave

    void OnServerSave()
    {
        Puts("OnServerSave works!");
    }
    

    OnPermissionRegistered

    void OnPermissionRegistered(string name, Plugin owner)
    {
        Puts($"Permission '{name}' has been registered {(owner != null ? $"for {owner.Title}" : "")}");
    }
    

    OnGroupPermissionGranted

    void OnGroupPermissionGranted(string name, string perm)
    {
        Puts($"Group '{name}' granted permission: {perm}");
    }
    

    OnGroupPermissionRevoked

    void OnGroupPermissionRevoked(string name, string perm)
    {
        Puts($"Group '{name}' revoked permission: {perm}");
    }
    

    OnGroupCreated

    void OnGroupCreated(string name)
    {
        Puts($"Group '{name}' created!");
    }
    

    OnGroupDeleted

    void OnGroupDeleted(string name)
    {
        Puts($"Group '{name}' deleted!");
    }
    

    OnGroupTitleSet

    void OnGroupTitleSet(string name, string title)
    {
        Puts($"Title '{title}' set on group '{name}'");
    }
    

    OnGroupRankSet

    void OnGroupRankSet(string name, int rank)
    {
        Puts($"Rank '{rank}' set on group '{name}'");
    }
    

    OnGroupParentSet

    void OnGroupParentSet(string name, string parent)
    {
        Puts($"Parent '{parent}' set on group '{name}'");
    }
    

    OnUserNameUpdated

    void OnUserNameUpdated(string id, string oldName, string newName)
    {
        Puts($"Player name changed from {oldName} to {newName} for ID {id}");
    }
    

    OnUserGroupAdded

    void OnUserGroupAdded(string id, string name)
    {
        Puts($"User '{id}' added to group: {name}");
    }
    

    OnUserGroupRemoved

    void OnUserGroupRemoved(string id, string name)
    {
        Puts($"Player '{id}' removed from group: {name}");
    }
    

    OnUserPermissionGranted

    void OnUserPermissionGranted(string id, string perm)
    {
        Puts($"Player '{id}' granted permission: {perm}");
    }
    

    OnUserPermissionRevoked

    void OnUserPermissionRevoked(string id, string perm)
    {
        Puts($"Player '{id}' revoked permission: {perm}");
    }
    

    OnUserKicked

    void OnUserKicked(IPlayer player, string reason)
    {
        Puts($"Player {player.Name} ({player.Id}) was kicked");
    }
    

    OnUserBanned

    void OnUserBanned(string name, string id, string address, string reason)
    {
        Puts($"Player {name} ({id}) was banned: {reason}");
    }
    

    OnUserUnbanned

    void OnUserUnbanned(string name, string id, string ip)
    {
        Puts($"Player {name} ({id}) was unbanned");
    }
    

    Server Hooks

    OnServerCommand

    void OnServerCommand(string command)
    {
        Puts("OnServerCommand works!");
    }
    

    OnRemoteCommand

    void OnRemoteCommand(PlayerSession session, string command)
    {
        Puts("OnRemoteCommand works!");
    }
    

    Player Hooks

    CanClientLogin

    void CanClientLogin(PlayerSession session)
    {
        Puts("CanClientLogin works!");
    }
    

    CanCraft

    void CanCraft(PlayerSession session, CrafterServer crafter)
    {
        Puts("CanCraft works!");
    }
    

    CanUseMachine

    void CanUseMachine(PlayerSession session, object machine)
    {
        Puts("CanUseMachine works!");
    }
    

    OnFindSpawnPoint

    void OnFindSpawnPoint(PlayerSession session)
    {
        Puts("OnFindSpawnPoint works!");
    }
    

    OnPlayerChat

    void OnPlayerChat(PlayerSession session, string message)
    {
        Puts("OnPlayerChat works!");
    }
    

    OnPlayerConnected

    void OnPlayerConnected(PlayerSession session)
    {
        Puts("OnPlayerConnected works!");
    }
    

    OnPlayerDeath

    void OnPlayerDeath(PlayerSession session, EntityEffectSourceData source)
    {
        Puts("OnPlayerDeath works!");
    }
    

    OnPlayerDisconnected

    void OnPlayerDisconnected(PlayerSession session)
    {
        Puts("OnPlayerDisconnected works!");
    }
    

    OnPlayerInput

    void OnPlayerInput(PlayerSession session, InputControls input)
    {
        Puts("OnPlayerInput works!");
    }
    

    OnPlayerRespawn

    void OnPlayerRespawn(PlayerSession session, Vector3 spawnLocation)
    {
        Puts("OnPlayerRespawn works!");
    }
    

    OnPlayerSpawn

    void OnPlayerSpawn(PlayerSession session)
    {
        Puts("OnPlayerSpawn works!");
    }
    

    OnPlayerSuicide

    void OnPlayerSuicide(PlayerSession session)
    {
        Puts("OnPlayerSuicide works!");
    }
    

    OnPlayerTakeDamage

    void OnPlayerTakeDamage(PlayerSession session, EntityEffectSourceData source)
    {
        Puts("OnPlayerTakeDamage works!");
    }
    

    OnPlayerVoice

    void OnPlayerVoice(PlayerSession session)
    {
        Puts("OnPlayerVoice works!");
    }
    

    OnUserApprove

    void OnUserApprove(Network.Connection connection)
    {
        Puts("OnUserApprove works!");
    }
    

    Entity Hooks

    OnEntityDeath

    void OnEntityDeath(AnimalStatManager stats, EntityEffectSourceData source)
    {
        Puts("OnEntityDeath works!");
    }
    

    OnEntitySpawned

    void OnEntitySpawned(HNetworkView data)
    {
        Puts("OnEntitySpawned works!");
    }
    

    OnEntityTakeDamage

    void OnEntityTakeDamage(AIEntity entity, EntityEffectSourceData source)
    {
        Puts("OnEntityTakeDamage works!");
    }
    

    Item Hooks

    OnItemDrop

    void OnItemDrop(Inventory inventory, int slot)
    {
        Puts("OnItemDrop works!");
    }
    

    OnItemEquipped

    void OnItemEquipped(ItemInstance item, EquippedHandlerServer player, int slot)
    {
        Puts("OnItemEquipped works!");
    }
    

    OnItemPickup

    void OnItemPickup(IStorable inventory, WorldItemInteractServer player)
    {
        Puts("OnItemPickup works!");
    }
    

    OnItemSelected

    void OnItemSelected(ItemInstance item, EquippedHandlerServer player, int slot, byte sessionId)
    {
        Puts("OnItemSelected works!");
    }
    

    Resource Gathering Hooks

    OnCollectiblePickup

    void OnCollectiblePickup(LootOnPickup node, WorldItemInteractServer player, List<ItemInstance> items)
    {
        Puts("OnCollectiblePickup works!");
    }
    

    OnDispenserGather

    void OnDispenserGather(GameObject resourceNode, HurtMonoBehavior player, List<ItemInstance> items)
    {
        Puts("OnDispenserGather works!");
    }
    

    OnPlantGather

    void OnPlantGather(GrowingPlantUsable plant, WorldItemInteractServer player, List<ItemInstance> items)
    {
        Puts("OnPlantGather works!");
    }
    

    Structure Hooks

    CanUseDoubleDoor

    void CanUseDoubleDoor(PlayerSession session, DoubleDoorServer door)
    {
        Puts("CanUseDoubleDoor works!");
    }
    

    CanUseGarageDoor

    void CanUseGarageDoor(PlayerSession session, GarageDoorServer door)
    {
        Puts("CanUseGarageDoor works!");
    }
    

    CanUsePillboxDoor

    void CanUsePillboxDoor(PlayerSession session, DoorPillboxServer door)
    {
        Puts("CanUsePillboxDoor works!");
    }
    

    CanUseSingleDoor

    void CanUseSingleDoor(PlayerSession session, SingleDoorServer door)
    {
        Puts("CanUseSingleDoor works!");
    }
    

    OnDoubleDoorUsed

    void OnDoubleDoorUsed(PlayerSession session, DoubleDoorServer door)
    {
        Puts("OnDoubleDoorUsed works!");
    }
    

    OnGarageDoorUsed

    void OnGarageDoorUsed(PlayerSession session, GarageDoorServer door)
    {
        Puts("OnGarageDoorUsed works!");
    }
    

    OnSingleDoorUsed

    void OnSingleDoorUsed(PlayerSession session, SingleDoorServer door)
    {
        Puts("OnSingleDoorUsed works!");
    }
    

    Vehicle Hooks

    CanEnterVehicle

    void CanEnterVehicle(PlayerSession session, VehiclePassenger vehicle)
    {
        Puts("CanEnterVehicle works!");
    }
    

    CanExitVehicle

    void CanExitVehicle(PlayerSession session, VehiclePassenger vehicle)
    {
        Puts("CanExitVehicle works!");
    }
    

    OnEnterVehicle

    void OnEnterVehicle(PlayerSession session, VehiclePassenger vehicle)
    {
        Puts("OnEnterVehicle works!");
    }
    

    OnExitVehicle

    void OnExitVehicle(PlayerSession session, VehiclePassenger vehicle)
    {
        Puts("OnExitVehicle works!");
    }
    

    Commands

    Default commands

    oxide.load *|<pluginname>+
    oxide.unload *|<pluginname>+
    oxide.reload *|<pluginname>+
    oxide.grant <group|user> <name|id> *|<permission>
    oxide.revoke <group|user> <name|id> *|<permission>
    oxide.group <add|set> <name> [title] [rank]
    oxide.group <remove> <name>
    oxide.group <parent> <name> <parentname>
    oxide.usergroup <add|remove> <username> <groupname>
    oxide.show <group|user|perm> <name>
    oxide.show <groups|perms>
    oxide.version
    

    Chat commands

    namespace Oxide.Plugins
    {
        [Info("Epic Stuff", "Unknown", "1.0.0")]
        [Description("A basic chat command")]
        class EpicStuff : CovalencePlugin
        {
            [Command("test")]
            void TestCommand(IPlayer player, string command, string[] args)
            {
                player.Reply("Test successful!");
            }
        }
    }
    

    Console commands

    using UnityEngine;
    
    namespace Oxide.Plugins
    {
        [Info("Epic Stuff", "Unknown", "1.0.0")]
        [Description("A basic console command")]
        class EpicStuff : CovalencePlugin
        {
            [Command("global.test")]
            void TestCommand(IPlayer player)
            {
                Puts("Test successful!");
            }
        }
    }
    

    Configurations

    Creating a configuration

    namespace Oxide.Plugins
    {
        [Info("Epic Stuff", "Unknown", 1.0)]
        [Description("This example illustrates how to use a basic configuration file")]
        class EpicStuff : CovalencePlugin
        {
            protected override void LoadDefaultConfig()
            {
                PrintWarning("Creating a new configuration file");
                Config.Clear();
                Config["ShowJoinMessage"] = true;
                Config["ShowLeaveMessage"] = true;
                Config["JoinMessage"] = "Welcome to this server";
                Config["LeaveMessage"] = "Goodbye";
                SaveConfig();
            }
        }
    }
    

    Since many users won't want to (or can't) edit the plugin directly to change the default configuration, it's best to offer to offer them a configuration file that can easily be edited without worrying about messing up the plugin.

    Saving a configuration

    namespace Oxide.Plugins
    {
        [Info("Epic Stuff", "Unknown", 1.0)]
        [Description("This example illustrates how to update a value in a configuration file")]
        class EpicStuff : CovalencePlugin
        {
            [Command("Test")]
            void Test(IPlayer player, string command, string[] args)
            {
                if ((bool)Config["ShowJoinMessage"])
                    Config["ShowJoinMessage"] = false;
                else
                    Config["ShowJoinMessage"] = true;
                SaveConfig();
            }
        }
    }
    

    You can change and save configuration entries by simply assigning the new values and calling the save function.

    Storing Data

    Creating a data table

    using System.Collections.Generic;
    using Oxide.Core;
    
    namespace Oxide.Plugins
    {
        [Info("Epic Stuff", "Unknown", 1.0)]
        [Description("This example illustrates how to create a data file")]
        class EpicStuff : CovalencePlugin
        {
            class StoredData
            {
                public HashSet<PlayerInfo> Players = new HashSet<PlayerInfo>();
    
                public StoredData()
                {
                }
            }
    
            class PlayerInfo
            {
                public string UserId;
                public string Name;
    
                public PlayerInfo()
                {
                }
    
                public PlayerInfo(BasePlayer player)
                {
                    UserId = player.userID.ToString();
                    Name = player.displayName;
                }
            }
    
            StoredData storedData;
    
            void Loaded()
            {
                storedData = Interface.Oxide.DataFileSystem.ReadObject<StoredData>("MyDataFile");
            }
        }
    }
    

    To store plugin related data to use in your plugin, you want to create a data file.

    Saving a data table

    using System.Collections.Generic;
    using Oxide.Core;
    
    namespace Oxide.Plugins
    {
        [Info("Epic Stuff", "Unknown", 1.0)]
        [Description("This example illustrates how to save to a data file")]
        class EpicStuff : CovalencePlugin
        {
            class StoredData
            {
                public HashSet<PlayerInfo> Players = new HashSet<PlayerInfo>();
    
                public StoredData()
                {
                }
            }
    
            class PlayerInfo
            {
                public string UserId;
                public string Name;
    
                public PlayerInfo()
                {
                }
    
                public PlayerInfo(IPlayer player)
                {
                    UserId = player.Id;
                    Name = player.Name;
                }
            }
    
            StoredData storedData;
    
            void Loaded()
            {
                storedData = Interface.Oxide.DataFileSystem.ReadObject<StoredData>("MyDataFile");
            }
    
            [Command("Test")]
            void Test(IPlayer player, string command, string[] args)
            {
                var info = new PlayerInfo(player);
                if (storedData.Players.Contains(info))
                    PrintToChat(player, "Your data has already been added to the file");
                else
                {
                    PrintToChat(player, "Saving your data to the file");
                    storedData.Players.Add(info);
                    Interface.Oxide.DataFileSystem.WriteObject("MyDataFile", storedData);
                }
            }
        }
    }
    

    Timers (Basic)

    Timers are great for delaying code, allowing it to be run later.

    Single timer

    timer.Once(3f, () =>
    {
        Puts("Hello world!")
    });
    

    Executes the specified function once after the specified delay.

    Repeating timer

    timer.Repeat(5f, 0, () =>
    {
        Puts("Hello world!")
    });
    

    Executes the specified function every "delay" seconds.

    If "repeats" is specified, the function will only be called "repeats" times.

    Next frame timer

    NextFrame(() =>
    {
        Puts("Hello world!");
    });
    

    Executes the specified function at the next frame.

    Web Requests

    Web requests allow you to send a HTTP GET or POST to a specified URL.

    The request will return true if the web request was sent, false if not. The callback is called with 2 parameters - an integer HTTP response code and a string response.

    Basic Get method

    using Oxide.Core.Libraries.Covalence;
    
    namespace Oxide.Plugins
    {
        [Info("EpicStuff", "Unknown", 1.0)]
        [Description("This example illustrates how to use a GET WebRequest")]
    
        class EpicStuff : CovalencePlugin
        {
            [Command("get")]
            void GetRequest(IPlayer player, string command, string[] args)
            {
                webrequest.EnqueueGet("http://www.google.com/search?q=oxide", (code, response) => GetCallback(code, response, player), this);
            }
    
            void GetCallback(int code, string response, IPlayer player)
            {
                if (response == null || code != 200)
                {
                    Puts($"Error: {code} - Couldn't get an answer from Google for {player.Name}");
                    return;
                }
    
                Puts($"Google answered for {player.Name}: {response}");
            }
        }
    }
    

    This uses the raw connection to a web page as you would on your browser.

    Basic POST method

    using Oxide.Core.Libraries.Covalence;
    
    namespace Oxide.Plugins
    {
        [Info("EpicStuff", "Unknown", 1.0)]
        [Description("This example illustrates how to use a POST WebRequest")]
    
        class EpicStuff : CovalencePlugin
        {
            [Command("post")]
            void PostRequest(IPlayer player, string command, string[] args)
            {
                webrequest.EnqueuePost("http://www.google.com/search?q=oxide", "param1=value1&param2=value2", (code, response) => PostCallback(code, response, player), this);
            }
    
            void PostCallback(int code, string response, IPlayer player)
            {
                if (response == null || code != 200)
                {
                    Puts($"Error: {code} - Couldn't get an answer from Google for {player.Name}");
                    return;
                }
                Puts("Google answered for " + player.Name + ": " + response);
            }
        }
    }
    

    Advanced GET method

    using Oxide.Core.Libraries.Covalence;
    
    namespace Oxide.Plugins
    {
        [Info("EpicStuff", "Unknown", 1.0)]
        [Description("This example illustrates how to use a GET WebRequest")]
    
        class EpicStuff : CovalencePlugin
        {
            [Command("get")]
            void GetRequest(IPlayer player, string command, string[] args)
            {
                // Set a custom timeout (in milliseconds)
                var timeout = 200f;
    
                // Set some custom request headers (eg. for HTTP Basic Auth)
                var headers = new Dictionary<string, string> { { "header", "value" } };
    
                webrequest.EnqueueGet("http://www.google.com/search?q=oxide", (code, response) => GetCallback(code, response, player), this, headers, timeout);
            }
    
            void GetCallback(int code, string response, IPlayer player)
            {
                if (response == null || code != 200)
                {
                    Puts($"Error: {code} - Couldn't get an answer from Google for {player.Name}");
                    return;
                }
    
                Puts($"Google answered for {player.Name}: {response}");
            }
        }
    }
    

    Advanced POST method

    using Oxide.Core.Libraries.Covalence;
    
    namespace Oxide.Plugins
    {
        [Info("EpicStuff", "Unknown", 1.0)]
        [Description("This example illustrates how to use a POST WebRequest")]
    
        class EpicStuff : CovalencePlugin
        {
            [Command("post")]
            void PostRequest(IPlayer player, string command, string[] args)
            {
                // Set a timeout (in milliseconds)
                var timeout = 200f;
    
                // Set some custom request headers (eg. for HTTP Basic Auth)
                var headers = new Dictionary<string, string> { { "header", "value" } };
    
                webrequest.EnqueuePost("http://www.google.com/search?q=oxide", "param1=value1&param2=value2", (code, response) => PostCallback(code, response, player), this, headers, timeout);
            }
    
            void PostCallback(int code, string response, IPlayer player)
            {
                if (response == null || code != 200)
                {
                    Puts($"Error: {code} - Couldn't get an answer from Google for {player.Name}");
                    return;
                }
                Puts("Google answered for " + player.Name + ": " + response);
            }
        }
    }
    

    Plugin Calling

    Oxide allows you to expose methods in your plugin and make them available to other plugins. This allows you to access objects or properties from other plugins without having to replicate functionality yourself.

    Exposing a plugin's method

    namespace Oxide.Plugins
    {
        [Info("EpicStuff", "Unknown", 0.1)]
        [Description("Makes epic stuff happen")]
        class EpicStuff : CovalencePlugin
        {
            // Plugin methods can be a simple bool that is returned
            bool GetReturn()
            {
                return true;
            }
    
            // Plugin methods can take parameters and return simple types
            string TakeParam(string param, int secondParam)
            {
                if (param == "first parameter") return param;
                else return "First parameter didn't match!";
            }
    
            // To return complex types, they should first be converted
            // into builtin types (e.g. JSON.net types like JObject, JArray, etc. or builtin
            // collections like System.Collections.Generic.Dictionary)
            JObject ReturnObject()
            {
                var myObject = new JObject();
                myObject["key"] = "value";
                myObject["array"] = new JArray();
                return myObject;
            }
    
            // Plugin methods don't have to return something
            void SendMessage()
            {
                Puts("You just called the 'SendMessage' method!");
            }
        }
    }
    

    Exposing a plugin's method allows other plugins to call that method.

    For example, you could write a plugin that does some player management, then allow other plugins to "query" it to get a list of players who have certain privileges set in the original plugin.

    Calling a plugin's method

    namespace Oxide.Plugins
    {
        [Info("SecondEpicStuff", "Unknown", 0.1)]
        [Description("Makes more epic stuff happen")]
        class SecondEpicStuff : CovalencePlugin
        {
            // First, add a reference to the plugin you are trying to call
            // The name of this field needs to be the exact name of the desired plugin
            // eg. We are referencing the example plugin above which is called 'EpicStuff'
            [PluginReference]
            Plugin EpicStuff;
    
            // It's a good idea to check if the plugin you're trying to call
            // has been loaded by oxide (otherwise you can't call the method)
            void OnServerInitialized()
            {
                // Note: Trying to do this check in the plugin Init() method may
                // fail, as the plugin load order may be different each time
                if (EpicStuff == null)
                {
                    PrintWarning("Plugin 'EpicStuff' was not found!");
                }
            }
    
            void CallPlugin()
            {
                // Plugin methods return objects, so cast the API call to the type
                // you're expecting
                var getTypedReturn = (bool)EpicStuff?.Call("GetReturn");
    
                // Send parameters through as variables after the method name
                var takeParam = (string)EpicStuff?.Call("TakeParam", "param1", 1024);
    
                // Use JSON.net to process the returned object
                var returnedObject = EpicStuff?.Call("ReturnObject");
    
                // Call a plugin to do some work without returning anything
                EpicStuff?.Call("SendMessage");
            }
        }
    }
    

    Calling a plugin's method allows you to access results from another plugin.

    Item List

    Item Id Item Name
    289 Albino Tokar Mask
    87 Amber
    23 Animal Fat
    34 Animal Tendon
    278 AR Bullet
    229 Arctic Pelt
    283 Arctic Shigi Mask
    48 Arrow
    51 Ash
    98 Assault Rifle Auto
    225 Assault Rifle Semi
    214 Aussie Hat
    88 Backpack
    303 Baldness Hat
    96 Basic Boots
    140 Basic Pants
    128 Basic Spear
    142 Beacon
    167 Billycart Wheel
    53 Blast Furnace
    116 Blue Beanie
    290 Blue Tokar Mask
    7 Bolt Action Rifle
    276 Bor Backpack
    286 Bor Mask
    146 Bow of Punishment
    119 Brown Sneakers
    107 Brown TShirt
    144 C4
    154 Campfire
    92 Car Hunting Bow
    68 Chemsuit Jacket
    69 Chemsuit Pants
    28 Clay
    302 Clean Shave
    20 Coal
    44 Concrete
    91 Construction Hammer
    5 Cooked Steak
    152 Crude Coolant
    323 Cut Diamond
    299 Damaged Goat Engine
    176 Damaged Roach Engine
    90 Debug Backpack
    231 Detonator Cap
    324 Diamond Dust
    325 Diamond Saw
    95 Dirty Doubleshirt
    105 Dirtyer Doubleshirt
    192 Drifting Sand Hopper
    127 Drill
    308 Drill Blue
    307 Drill Green
    155 Dynamite
    148 Earth Magnet
    103 EmoHair
    309 Fabricator
    270 Feather A
    271 Feather B
    31 Fire Pit
    316 Fireplace
    216 Flannel Shirt
    311 Flare Gun
    17 Flint
    89 Flint Hatchet
    285 Forest Shigi Mask
    149 Fridge
    151 Frozen Cooked Steak
    150 Frozen Raw Steak
    71 Gas Mask
    147 Gasoline
    180 Goat Camo Paint Design
    181 Goat Flames Paint Design
    223 Goat Flat Paint Design
    186 Goat Judge Backpanel
    185 Goat Judge Frontpanel
    224 Goat Maze Paint Design
    300 Goat Offroad Gearbox
    190 Goat Racer Backpanel
    189 Goat Racer Frontpanel
    301 Goat Road Gearbox
    182 Goat Side Stripe Paint Design
    183 Goat Skull Paint Design
    188 Goat Stasher Backpanel
    187 Goat Stasher Frontpanel
    222 Goat Twin Stripes Paint Design
    79 Gold Axe
    109 Gray TShirt
    129 Gray Winter Jacket
    110 Green TShirt
    102 Grey Beanie
    104 Grey Sneakers
    113 HairColor2
    114 HairColor3
    49 Hunting Bow
    226 Ice Spear
    78 Iron Axe
    18 Iron Ore
    30 Iron Pickaxe
    277 Irradiated Bor Backpack
    287 Irradiated Bor Mask
    294 Irradiated Owrong Seeds
    342 Kanga Angelica Design
    336 Kanga Crow Frontpanel
    337 Kanga Crow Rearpanel
    330 Kanga Damaged Engine
    338 Kanga Earwig Frontpanel
    339 Kanga Earwig Rearpanel
    345 Kanga Eva Design
    343 Kanga Grade80 Design
    334 Kanga Knobbler Wheel
    332 Kanga Offroad Gearbox
    335 Kanga Paddlin Wheel
    328 Kanga Powerful Engine
    340 Kanga Raider Frontpanel
    341 Kanga Raider Rearpanel
    331 Kanga Road Gearbox
    344 Kanga Rocketto Design
    333 Kanga Saw Wheel
    329 Kanga Standard Engine
    327 Kanga Weak Engine
    346 Kanga ZebraTech Design
    273 Landcrab Mine
    85 Leather
    42 Limestone
    314 Machine Wrench
    306 Mangler Wheel
    275 Medusa Seeds
    138 Mining Bow
    227 Molten Spear
    132 Mondinium Ore
    137 Mondinium Pickaxe
    50 Mouldy Owrong
    115 Moustache
    221 Mullet
    117 Orange Beanie
    93 Ownership Stake
    25 Owrong
    26 Owrong Seeds
    232
    Paint #001
    233
    Paint #002
    234
    Paint #003
    235
    Paint #004
    236
    Paint #005
    237
    Paint #006
    238
    Paint #007
    239
    Paint #008
    240
    Paint #009
    241
    Paint #010
    242
    Paint #011
    243
    Paint #012
    244
    Paint #013
    245
    Paint #014
    246
    Paint #015
    247
    Paint #016
    248
    Paint #017
    249
    Paint #018
    250
    Paint #019
    251
    Paint #020
    252
    Paint #021
    253
    Paint #022
    254
    Paint #023
    255
    Paint #024
    256
    Paint #025
    257
    Paint #026
    258
    Paint #027
    259
    Paint #028
    260
    Paint #029
    261
    Paint #030
    262
    Paint #031
    263
    Paint #032
    264
    Paint #033
    265
    Paint #034
    266
    Paint #035
    267
    Paint #036
    268
    Paint #037
    291 Parrot Tokar Mask
    279 Pistol
    280 Pistol Bullet
    153 Pitcher Seeds
    295 Poison Sac
    274 Poison Trap
    112 Poo TShirt
    296 Powerfull Goat Engine
    173 Powerfull Roach Engine
    184 Quadbike Nipple Wheel
    318 Raiding Drill
    321 Raiding Drill Base
    320 Raiding Drill Motor
    319 Raiding Drillbit
    6 Rancid Steak
    4 Raw Steak
    130 Red Winter Jacket
    122 Repair Bow
    52 Rifle Bullet
    204 Roach 1986 Design
    163 Roach 44 Galon Armor
    199 Roach Chaser Bumper
    200 Roach Chaser Hood
    203 Roach Chaser Rear Panel
    202 Roach Chaser Roof Scoop
    201 Roach Chaser Side Panel
    178 Roach Default Design
    205 Roach Digital Camo Design
    206 Roach Eyes Design
    193 Roach Front Seat
    207 Roach Graff Design
    174 Roach Offroad Gearbox
    175 Roach Road Gearbox
    165 Roach Roof Lights
    194 Roach Sharkweek Bumper
    195 Roach Sharkweek Hood
    198 Roach Sharkweek Rear Panel
    197 Roach Sharkweek Roof Scoop
    196 Roach Sharkweek Side Panel
    164 Roach Skull Bumper
    179 Roach Swirler Paint Design
    162 Roach Triple Door Panel
    313 Rocket Launcher
    322 Rough Diamond
    70 Rubber Boots
    72 Rubber Gloves
    12 Ruby
    166 Sand Hopper Wheel
    230 Sasquach Pelt
    293 Sasquatch Mask
    317 Shack
    36 Shaped Iron
    135 Shaped Mondinium
    134 Shaped Titranium
    136 Shaped Ultranium
    228 Sharp Spear
    282 Shigi Mask
    141 Shitty TShirt
    125 Shotgun
    191 ShotgunShell
    310 Sign
    217 Singlet
    218 Singlet
    219 Skater Hat
    82 Snare Bow
    220 Sombrero
    298 Standard Goat Engine
    172 Standard Roach Engine
    19 Stone
    139 Stone Pickaxe
    272 Storage Chest
    2 Storage Locker
    45 Strong String
    215 Succulent Seeds
    213 Sunscreen
    131 Titranium Ore
    80 Titranium Pickaxe
    326 Tokar Acid
    288 Tokar Mask
    315 Torch
    305 Toretto Wheel
    27 Tree Bark
    133 Ultranium Ore
    81 Ultranium Pickaxe
    281 Ushanka
    304 Vehicle Wrench
    94 Warm Jeans
    297 Weak Goat Engine
    171 Weak Roach Engine
    35 Weak String
    111 White TShirt
    284 Wolf Shigi Mask
    47 Wood Bow
    21 Wood Log
    22 Wood Plank
    3 Workbench
    269 Yeti Horn
    292 Yeti Mask

    Styling Messages

    Render the text in boldface

    We are <b>not</b> amused.
    

    Render the text in italics

    We are <i>usually</i> not amused.
    

    It is possible to apply more than one style to a section of text by nesting one element inside another.

    We are <b><i>definitely not</i></b> amused
    

    Note the ordering of the ending tags, which is in reverse to that of the starting tags. The reason for this is perhaps clearer when you consider that the inner tags need not span the whole text of the outermost element.

    We are <b>absolutely <i>definitely</i> not</b> amused
    

    Change the size of text, by pixel value

    We are <size=50>largely</size> unaffected.
    

    Change the color of text

    <color=#00ffffff>Hello world</color>
    

    Messages sent from the server via plugins can be stylized using basic HTML. Styling is limited to bold, italic, size, and color.

    The color can be specified in the traditional HTML format. #rrggbbaa... where the letters correspond to pairs of hexadecimal digits denoting the red, green, blue and alpha (transparency) values for the color.

    Another option is to use the name of the color. This is easier to understand but naturally, the range of colors is limited and full opacity is always assumed. <color=cyan>... The available color names are given in the table below.

    Color Name Hex Value Swatch
    aqua (same as cyan) #00ffffff Cyan swatch
    black #000000ff Black swatch
    blue #0000ffff Blue swatch
    brown #a52a2aff Brown swatch
    cyan (same as aqua) #00ffffff Cyan swatch
    darkblue #0000a0ff Darkblue swatch
    fuchsia (same as magenta) #ff00ffff Magenta swatch
    green #008000ff Green swatch
    grey #808080ff Grey swatch
    lightblue #add8e6ff Lightblue swatch
    lime #00ff00ff Lime swatch
    magenta (same as fuchsia) #ff00ffff Magenta swatch
    maroon #800000ff Maroon swatch
    navy #000080ff Navy swatch
    olive #808000ff Olive swatch
    orange #ffa500ff Orange swatch
    purple #800080ff Purple swatch
    red #ff0000ff Red swatch
    silver #c0c0c0ff Silver swatch
    teal #008080ff Teal swatch
    white #ffffffff White swatch
    yellow #ffff00ff Yellow swatch

    Source: http://docs.unity3d.com/Manual/StyledText.html