private List <List <ulong> > GetSkins(ItemDefinition def)
{
List <List <ulong> > skinsPages;
if (skinsCache.TryGetValue(def.shortname, out skinsPages))
{
return(skinsPages);
}
var skins = new List <ulong> {
0
};
skins.AddRange(ItemSkinDirectory.ForItem(def).Select(skin => (ulong)skin.id));
skins.AddRange(Rust.Workshop.Approved.All.Where(s => ItemManager.itemList.Find(p => p.name == s.Skinnable.ItemName)?.shortname == def.shortname).Select(skin => skin.WorkshopdId));
List <ulong> workshopSkins;
if (WorkshopSkins.TryGetValue(def.shortname, out workshopSkins))
{
skins.AddRange(workshopSkins);
}
this.skins[def.shortname] = skins.ToList();
skinsPages = new List <List <ulong> >();
for (int i = 0; i < PagesCount(skins); i++)
{
skinsPages.Add(GetPage(skins, i, 18));
}
skinsCache.Add(def.shortname, skinsPages);
return(skinsPages);
}
private void InitializeWeaponData()
{
var skinNameDir = new List <string>();
for (int i = 0; i < Rust.Workshop.Approved.All.Length; i++)
{
var skin = Rust.Workshop.Approved.All[i];
if (skin.Skinnable.Category == Rust.Workshop.Category.Weapon)
{
skinNameDir.Add(skin.Name);
}
}
ItemStructure outStructure;
for (int i = 0; i < ItemManager.itemList.Count; i++)
{
var definition = ItemManager.itemList[i];
if (definition == null)
{
continue;
}
if ((definition.category == ItemCategory.Weapon || definition.category == ItemCategory.Tool || definition.category == ItemCategory.Ammunition) && !definition.shortname.Contains("mod") && !weaponData.Weapons.TryGetValue(definition.shortname, out outStructure))
{
weaponData.Weapons[definition.shortname] = new ItemStructure {
Name = definition.displayName.english, GlobalModifier = 1.0f, PrefabModifiers = new Dictionary <string, float>(), IndividualParts = CreateBodypartList()
}
}
;
var skinDir = ItemSkinDirectory.ForItem(definition) ?? null;
if (skinDir != null && skinDir.Length > 0 && (definition.category == ItemCategory.Weapon || definition.category == ItemCategory.Tool))
{
for (int j = 0; j < skinDir.Length; j++)
{
var skin = skinDir[j];
var name = skin.invItem?.displayName?.english ?? skin.name;
if (!skinNameDir.Contains(name))
{
skinNameDir.Add(name);
}
}
}
}
for (int i = 0; i < skinNameDir.Count; i++)
{
var skin = skinNameDir[i];
if (!weaponData.Weapons.TryGetValue(skin, out outStructure))
{
weaponData.Weapons[skin] = new ItemStructure {
Name = skin, GlobalModifier = 1.0f, PrefabModifiers = new Dictionary <string, float>(), IndividualParts = CreateBodypartList()
}
}
;
}
SaveData();
}
private bool HasSkins(ItemDefinition item)
{
if (item != null)
{
var skins = ItemSkinDirectory.ForItem(item).ToList();
if (skins.Count > 0)
{
return(true);
}
}
return(false);
}
private List <ulong> GetSkins(ItemDefinition def)
{
List <ulong> skins;
if (skinsCache.TryGetValue(def.shortname, out skins))
{
return(skins);
}
skins = new List <ulong>();
skins.AddRange(ItemSkinDirectory.ForItem(def).Select(skin => (ulong)skin.id));
skins.AddRange(Rust.Workshop.Approved.All.Values.Where(skin => skin.Skinnable.ItemName == def.shortname).Select(skin => skin.WorkshopdId));
skinsCache.Add(def.shortname, skins);
return(skins);
}
private List <int> GetSkins(ItemDefinition def)
{
ItemSkinDirectory.Skin[] skins10;
skins10 = ItemSkinDirectory.ForItem(def);
Puts(skins10.Length.ToString());
List <int> skins = new List <int>();
//foreach (ItemSkinDirectory.Skin val in skins10) Puts("[DEBUG] "+val.name+" - "+val.id);
foreach (ItemSkinDirectory.Skin val in skins10)
{
skins.Add(val.id);
}
return(skins);
}
private void FillSkinList(ItemDefinition item)
{
if (itemSkins.ContainsKey(item.itemid))
{
int i = 0;
var skins = ItemSkinDirectory.ForItem(item).ToList();
itemSkins[item.itemid].Add(i, 0);
i++;
foreach (var entry in skins)
{
itemSkins[item.itemid].Add(i, entry.id); i++;
}
}
}
private List <int> GetSkins(ItemDefinition def)
{
List <int> skins;
if (skinsCache.TryGetValue(def.shortname, out skins))
{
return(skins);
}
skins = new List <int> {
0
};
skins.AddRange(ItemSkinDirectory.ForItem(def).Select(skin => skin.id));
skins.AddRange(Rust.Workshop.Approved.All.Where(skin => skin.ItemName == def.shortname).Select(skin => (int)skin.InventoryId));
skinsCache.Add(def.shortname, skins);
return(skins);
}
private List <int> GetSkins(ItemDefinition def)
{
List <int> skins = new List <int> {
0
};
skins.AddRange(ItemSkinDirectory.ForItem(def).Select(skin => skin.id));
skins.AddRange(Rust.Workshop.Approved.All.Where(skin => skin.ItemName == def.shortname).Select(skin => (int)skin.WorkshopdId));
if (!Convert.ToBoolean(Config["Settings", "AllowDefaultSkin"]))
{
if (skins.Contains(0))
{
skins.Remove(0);
}
}
return(skins);
}
public void Initialize(List <ItemDefinition> itemList)
{
if (this.itemMods != null)
{
Debug.LogError((object)("Item Definition Initializing twice: " + ((Object)this).get_name()));
}
this.skins = ItemSkinDirectory.ForItem(this);
this.itemMods = (ItemMod[])((Component)this).GetComponentsInChildren <ItemMod>(true);
foreach (ItemMod itemMod in this.itemMods)
{
itemMod.ModInit();
}
this.Children = itemList.Where <ItemDefinition>((Func <ItemDefinition, bool>)(x => Object.op_Equality((Object)x.Parent, (Object)this))).ToArray <ItemDefinition>();
this.ItemModWearable = (ItemModWearable)((Component)this).GetComponent <ItemModWearable>();
this.isHoldable = Object.op_Inequality((Object)((Component)this).GetComponent <ItemModEntity>(), (Object)null);
this.isUsable = Object.op_Inequality((Object)((Component)this).GetComponent <ItemModEntity>(), (Object)null) || Object.op_Inequality((Object)((Component)this).GetComponent <ItemModConsume>(), (Object)null);
}
public void Initialize(List <ItemDefinition> itemList)
{
if (itemMods != null)
{
Debug.LogError("Item Definition Initializing twice: " + base.name);
}
skins = ItemSkinDirectory.ForItem(this);
itemMods = GetComponentsInChildren <ItemMod>(true);
ItemMod[] array = itemMods;
for (int i = 0; i < array.Length; i++)
{
array[i].ModInit();
}
Children = itemList.Where((ItemDefinition x) => x.Parent == this).ToArray();
ItemModWearable = GetComponent <ItemModWearable>();
isHoldable = GetComponent <ItemModEntity>() != null;
isUsable = GetComponent <ItemModEntity>() != null || GetComponent <ItemModConsume>() != null;
}
///////////////////////////////////////////////////////////////
/// <summary>
/// Player command to see their clans clothing
/// If a skin is used will show the skin name
/// </summary>
/// <param name="player"></param>
/// <param name="command"></param>
/// <param name="args"></param>
/// ///////////////////////////////////////////////////////////////
private void ViewClanClothingChatCommand(BasePlayer player, string command, string[] args)
{
if (!CheckPermission(player, UsePermission, true))
{
return; //Player does not have permission
}
string playerClanTag = GetPlayerClanTag(player);
if (playerClanTag == null)
{
return; //Failed to get Clan Tag for player
}
if (_storedData.ClanClothing[playerClanTag] == null) //Players clan has not setup clan clothing
{
PrintToChat(player, $"{_pluginConfig.Prefix} {Lang("NotAvaliable", player.UserIDString)}");
return;
}
//Prepare the message to the player to display their clans clothing
string message = _pluginConfig.Prefix + "\n";
foreach (ClothingItem clothingItem in _storedData.ClanClothing[playerClanTag])
{
ItemDefinition item = ItemManager.FindItemDefinition(clothingItem.ItemId); //Information about the clothing item
if (clothingItem.SkinId == 0) //No skin is set
{
message += $" {item.displayName.translated}\n";
}
else //skin is set
{
foreach (var skin in ItemSkinDirectory.ForItem(item)) //Loop over all the skins for the item
{
if (skin.id == clothingItem.SkinId) //If the skin id's match add the skin display name to the message
{
message += $" {skin.invItem.displayName.translated}\n";
break;
}
}
}
}
PrintToChat(player, message);
}
public void Initialize(List <ItemDefinition> itemList)
{
if (this.itemMods != null)
{
Debug.LogError(string.Concat("Item Definition Initializing twice: ", base.name));
}
this.skins = ItemSkinDirectory.ForItem(this);
this.itemMods = base.GetComponentsInChildren <ItemMod>(true);
ItemMod[] itemModArray = this.itemMods;
for (int i = 0; i < (int)itemModArray.Length; i++)
{
itemModArray[i].ModInit();
}
this.Children = (
from x in itemList
where x.Parent == this
select x).ToArray <ItemDefinition>();
this.ItemModWearable = base.GetComponent <ItemModWearable>();
this.isHoldable = base.GetComponent <ItemModEntity>() != null;
this.isUsable = (base.GetComponent <ItemModEntity>() != null ? true : base.GetComponent <ItemModConsume>() != null);
}
void LoadSkinsList(ItemDefinition def)
{
if (SkinsList.ContainsKey(def.shortname))
{
SkinsList.Remove(def.shortname);
}
List <ulong> ids = new List <ulong>()
{
0
};
if (!configData.PreventDefaultSkins)
{
ItemSkinDirectory.Skin[] skins = ItemSkinDirectory.ForItem(def);
List <string> uniqSkins = new List <string>();
foreach (ItemSkinDirectory.Skin skin in skins)
{
if (!skin.isSkin)
{
continue;
}
if (uniqSkins.Contains(skin.name))
{
continue;
}
uniqSkins.Add(skin.name);
ids.Add((ulong)skin.id);
}
}
if (configData.Workshop.ContainsKey(def.shortname))
{
foreach (ulong wid in configData.Workshop[def.shortname])
{
ids.Add(wid);
}
}
SkinsList.Add(def.shortname, ids);
}
private void OnServerInitialized()
{
var strs = GameManifest.Current.pooledStrings;
for (int i = 0; i < strs.Length; i++)
{
var str = strs[i].str ?? string.Empty;
prefabNames.Add(str);
}
for (int i = 0; i < ItemManager.itemList.Count; i++)
{
var item = ItemManager.itemList[i];
var skinDir = ItemSkinDirectory.ForItem(item);
if (skinDir == null || skinDir.Length < 1)
{
continue;
}
for (int j = 0; j < skinDir.Length; j++)
{
var skin = skinDir[j];
var skinID = 0ul;
if (ulong.TryParse(skin.id.ToString(), out skinID))
{
skinIDName[skinID] = (skin.invItem?.displayName?.english ?? skin.name);
}
}
}
for (int i = 0; i < Rust.Workshop.Approved.All.Length; i++)
{
var skin = Rust.Workshop.Approved.All[i];
skinIDName[skin.WorkshopdId] = skin.Name;
}
wData = Interface.Oxide.DataFileSystem.GetFile("damagescaler_data");
LoadData();
}