NAV
csharp

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");
}

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!");
}

OnUserPermissionGranted

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

OnUserPermissionRevoked

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

OnUserGroupAdded

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

OnUserGroupRemoved

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

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}");
}

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)
{
    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(NetworkViewData 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

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

Chat commands

namespace Oxide.Plugins
{
    [Info("EpicStuff", "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("EpicStuff", "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("EpicStuff", "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("EpicStuff", "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("EpicStuff", "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("EpicStuff", "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
black #000000ff
blue #0000ffff
brown #a52a2aff
cyan (same as aqua) #00ffffff
darkblue #0000a0ff
fuchsia (same as magenta) #ff00ffff
green #008000ff
grey #808080ff
lightblue #add8e6ff
lime #00ff00ff
magenta (same as fuchsia) #ff00ffff
maroon #800000ff
navy #000080ff
olive #808000ff
orange #ffa500ff
purple #800080ff
red #ff0000ff
silver #c0c0c0ff
teal #008080ff
white #ffffffff
yellow #ffff00ff

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