public static void ChangePenguinOutfit([NamedToggleValue(typeof(EquipmentNameGenerator), 0u)] int definitionId)
{
CPDataEntityCollection cPDataEntityCollection = Service.Get <CPDataEntityCollection>();
if (cPDataEntityCollection.TryGetComponent(cPDataEntityCollection.LocalPlayerHandle, out AvatarDetailsData component))
{
Dictionary <int, TemplateDefinition> dictionary = Service.Get <GameData>().Get <Dictionary <int, TemplateDefinition> >();
TemplateDefinition templateDefinition = dictionary[definitionId];
AvatarDefinition definitionByName = Service.Get <AvatarService>().GetDefinitionByName("penguinAvatar");
EquipmentModelDefinition equipmentDefinition = definitionByName.GetEquipmentDefinition(templateDefinition.AssetName);
DCustomEquipment dCustomEquipment = default(DCustomEquipment);
dCustomEquipment.DefinitionId = templateDefinition.Id;
dCustomEquipment.Name = equipmentDefinition.Name;
dCustomEquipment.Id = 1L + (long)definitionId;
dCustomEquipment.Parts = new DCustomEquipmentPart[equipmentDefinition.Parts.Length];
for (int i = 0; i < equipmentDefinition.Parts.Length; i++)
{
dCustomEquipment.Parts[i].SlotIndex = equipmentDefinition.Parts[i].SlotIndex;
DCustomEquipmentDecal[] decals = new DCustomEquipmentDecal[0];
dCustomEquipment.Parts[i].Decals = decals;
}
component.Outfit = new DCustomEquipment[1]
{
dCustomEquipment
};
}
}
private void renderRewardItem(long requestId, DCustomEquipment customEquipment)
{
itemImageBuilder = ItemImageBuilder.acquire();
try
{
AbstractImageBuilder.CallbackToken callbackToken = default(AbstractImageBuilder.CallbackToken);
callbackToken.Id = requestId;
callbackToken.DefinitionId = customEquipment.DefinitionId;
itemImageBuilder.RequestImage(customEquipment, delegate(bool success, Texture2D texture, AbstractImageBuilder.CallbackToken token)
{
if (success)
{
onIconReady(texture);
}
else
{
cleanupItemImageBuilder();
}
}, callbackToken, itemIconBackgroundColor, itemIconPenguinColor);
}
catch (Exception ex)
{
Log.LogException(this, ex);
cleanupItemImageBuilder();
}
}
public static DCustomEquipment[] ConvertResponseToOutfit(CustomEquipment[] outfit)
{
if (outfit == null)
{
return(new DCustomEquipment[0]);
}
DCustomEquipment[] array = new DCustomEquipment[outfit.Length];
int num = 0;
for (int i = 0; i < outfit.Length; i++)
{
try
{
array[num++] = ConvertResponseToCustomEquipment(outfit[i]);
}
catch (KeyNotFoundException)
{
}
}
if (num != array.Length)
{
DCustomEquipment[] array2 = new DCustomEquipment[num];
Array.Copy(array, array2, num);
return(array2);
}
return(array);
}
public void SetUpButton(CatalogItemData catalogItemData, Color foreground, Color background, bool isCreatorNameHidden = false)
{
itemData = catalogItemData;
DCustomEquipment equipment = CustomEquipmentResponseAdaptor.ConvertResponseToCustomEquipment(itemData.equipment);
if (isCreatorNameHidden)
{
DisableName();
}
CreatorNameText.text = itemData.creatorName;
CatalogItemIcon component = GetComponent <CatalogItemIcon>();
AbstractImageBuilder.CallbackToken callbackToken = default(AbstractImageBuilder.CallbackToken);
callbackToken.Id = itemData.clothingCatalogItemId;
callbackToken.DefinitionId = equipment.DefinitionId;
base.itemImageBuilder.RequestImage(equipment, component.SetIcon, callbackToken, background, foreground);
if (!isAlreadyOwned)
{
isAlreadyOwned = ((itemData.equipment.equipmentId != 0) ? true : false);
}
ItemOwned.SetActive(isAlreadyOwned);
PriceTagText.text = itemData.cost.ToString();
PriceTag.SetActive(!isAlreadyOwned);
int definitionId = equipment.DefinitionId;
Dictionary <int, TemplateDefinition> dictionary = Service.Get <GameData>().Get <Dictionary <int, TemplateDefinition> >();
TemplateDefinition templateDefinition = dictionary.Values.ToList().First((TemplateDefinition x) => x.Id == definitionId);
isMemberUnlocked = !templateDefinition.IsMemberOnly || Service.Get <CPDataEntityCollection>().IsLocalPlayerMember();
if (!isMemberUnlocked)
{
MemberLock.SetActive(value: true);
}
}
private bool onInventoryRetrieved(InventoryServiceEvents.InventoryLoaded evt)
{
Service.Get <EventDispatcher>().RemoveListener <InventoryServiceEvents.InventoryLoaded>(onInventoryRetrieved);
DataEntityHandle localPlayerHandle = Service.Get <CPDataEntityCollection>().LocalPlayerHandle;
if (!localPlayerHandle.IsNull)
{
InventoryData inventoryData = Service.Get <CPDataEntityCollection>().AddComponent <InventoryData>(localPlayerHandle);
inventoryData.Inventory = new Dictionary <long, InventoryIconModel <DCustomEquipment> >();
inventoryData.CurrentAvatarEquipment = new List <long>();
for (int i = 0; i < evt.Inventory.Count; i++)
{
try
{
DCustomEquipment data = CustomEquipmentResponseAdaptor.ConvertResponseToCustomEquipment(evt.Inventory[i]);
InventoryIconModel <DCustomEquipment> value = new InventoryIconModel <DCustomEquipment>(data.Id, data, isEquipped: false, isMemberItem: true);
inventoryData.Inventory.Add(data.Id, value);
}
catch (KeyNotFoundException)
{
}
}
}
else
{
Log.LogError(this, "Unable to find the LocalPlayerHandle.");
}
if (callback != null)
{
callback();
callback = null;
}
return(false);
}
private bool onPurchaseComplete(CatalogServiceEvents.ItemPurchaseCompleteEvent e)
{
int coins = Service.Get <CPDataEntityCollection>().GetComponent <CoinsData>(Service.Get <CPDataEntityCollection>().LocalPlayerHandle).Coins;
if (e.Response.newCoinTotal < coins)
{
coins -= (int)e.Response.newCoinTotal;
Service.Get <CPDataEntityCollection>().GetComponent <CoinsData>(Service.Get <CPDataEntityCollection>().LocalPlayerHandle).RemoveCoins(coins);
}
if (selectedItem.clothingCatalogItemId == purchaseItem.clothingCatalogItemId && buyPanel != null)
{
buyPanel.SetState(CatalogShopBuyPanelState.Success);
}
if (itemForPurchase.HasValue)
{
DCustomEquipment data = CustomEquipmentResponseAdaptor.ConvertResponseToCustomEquipment(itemForPurchase.Value);
data.Id = e.Response.equipmentId;
data.DateTimeCreated = DateTime.UtcNow.GetTimeInMilliseconds();
DataEntityHandle localPlayerHandle = Service.Get <CPDataEntityCollection>().LocalPlayerHandle;
InventoryData component = Service.Get <CPDataEntityCollection>().GetComponent <InventoryData>(localPlayerHandle);
if (component != null)
{
InventoryIconModel <DCustomEquipment> value = new InventoryIconModel <DCustomEquipment>(data.Id, data, isEquipped: false, isMemberItem: true);
component.Inventory.Add(data.Id, value);
Service.Get <NotificationBreadcrumbController>().AddPersistentBreadcrumb(BreadcrumbType, data.Id.ToString());
}
else
{
Log.LogError(this, "Unable to locate InventoryData object.");
}
}
Service.Get <CatalogServiceProxy>().cache.ClearCache();
return(false);
}
public DCatalogShopItem(int themeid, int id, string submitterName, TemplateDefinition template, DCustomEquipment customEquipment)
{
ThemeId = themeid;
Id = id;
SubmitterName = submitterName;
Template = template;
CustomEquipment = customEquipment;
}
public void RequestImage(DCustomEquipment equipment, RequestImageCallback callback)
{
CallbackToken callbackToken = default(CallbackToken);
callbackToken.Id = equipment.Id;
callbackToken.DefinitionId = equipment.DefinitionId;
RequestImage(equipment, callback, callbackToken, Color.clear, Color.clear);
}
private static string calcHash(DCustomEquipment data, Color backgroundColor, Color penguinColor)
{
StructHash structHash = default(StructHash);
structHash.Combine(data.GetFullHash());
structHash.Combine(backgroundColor);
structHash.Combine(penguinColor);
return(Convert.ToString(structHash));
}
public void Init(DCustomEquipment item)
{
submittedItem = item;
if (ItemNameText != null)
{
TemplateDefinition templateDefinition = Service.Get <GameData>().Get <Dictionary <int, TemplateDefinition> >().Values.ToList().First((TemplateDefinition x) => x.Id == item.DefinitionId);
ItemNameText.text = Service.Get <Localizer>().GetTokenTranslation(templateDefinition.Name);
}
}
public void RemoveImageFromCache(DCustomEquipment equipment)
{
string hashName = calcHash(equipment, Color.clear, Color.clear);
if (imageCache.ContainsImage(hashName))
{
imageCache.RemoveImage(hashName);
}
}
private static DCustomOutfit createOutfit(DCustomEquipment equipment)
{
DCustomOutfit result = default(DCustomOutfit);
result.LodLevel = 0;
result.Equipment = new DCustomEquipment[1] {
equipment
};
return(result);
}
private bool onEquipmentRemovedFromAvatar(InventoryModelEvents.EquipmentRemovedFromAvatar evt)
{
DCustomEquipment data = inventoryModel.InventoryData.Inventory[evt.EquipmentId].Data;
if (!Model.RemoveEquipment(data.Name))
{
Log.LogErrorFormatted(this, "Equipment {0} was not removed from AvatarModel with id {1}.", data.Name, evt.EquipmentId);
}
inventoryModel.RemoveEquipmentById(evt.EquipmentId);
return(false);
}
public DCustomEquipment[] GetCurrentAvatarEquipment()
{
DCustomEquipment[] array = new DCustomEquipment[InventoryData.CurrentAvatarEquipment.Count];
for (int i = 0; i < InventoryData.CurrentAvatarEquipment.Count; i++)
{
long key = InventoryData.CurrentAvatarEquipment[i];
DCustomEquipment data = InventoryData.Inventory[key].Data;
data.Name = data.Name.ToLower();
array[i] = data;
}
return(array);
}
private void applyEquipmentToMannequin(TemplateDefinition templateDefinition)
{
EquipmentModelDefinition equipmentDefinition = Model.Definition.GetEquipmentDefinition(templateDefinition.AssetName);
currentTemplateDefition = templateDefinition;
currentEquipment = default(DCustomEquipment);
currentEquipment.DefinitionId = templateDefinition.Id;
currentEquipment.Name = templateDefinition.AssetName;
totalRenders = equipmentDefinition.Parts.Length;
itemZoomOffset = templateDefinition.ZoomOffset;
Model.ApplyEquipment(currentEquipment);
}
public DCustomEquipment[] GetOutfitByIds(long[] equipmentIds)
{
List <DCustomEquipment> list = new List <DCustomEquipment>();
for (int i = 0; i < equipmentIds.Length; i++)
{
if (InventoryData.Inventory.ContainsKey(equipmentIds[i]))
{
DCustomEquipment data = InventoryData.Inventory[equipmentIds[i]].Data;
list.Add(data);
}
}
return(list.ToArray());
}
public void RequestImage(DCustomEquipment equipment, RequestImageCallback callback, CallbackToken callbackToken, Color backgroundColor, Color penguinColor)
{
string imageHash = calcHash(equipment, backgroundColor, penguinColor);
ItemRenderParams itemRenderParams = new ItemRenderParams();
itemRenderParams.CallbackToken = callbackToken;
itemRenderParams.equipment = equipment;
itemRenderParams.BackgroundColor = backgroundColor;
itemRenderParams.bodyColor = penguinColor;
itemRenderParams.ImageHash = imageHash;
ItemRenderParams renderParams = itemRenderParams;
RequestImage(renderParams, callback);
}
private IEnumerator renderToTexture(ItemRenderParams param)
{
param.OutputTexture = null;
DCustomEquipment equipment = param.equipment;
int equipmentTemplateId = equipment.DefinitionId;
Dictionary <int, TemplateDefinition> templates = Service.Get <GameData>().Get <Dictionary <int, TemplateDefinition> >();
if (!templates.ContainsKey(equipmentTemplateId))
{
Log.LogErrorFormatted(this, "Unable to locate template {0} in template definitions with id {1}.", equipment.Name, equipmentTemplateId);
yield break;
}
TemplateDefinition templateDefinition = templates[equipmentTemplateId];
AssetRequest <TemplateRenderData> templateRequest;
try
{
templateRequest = Content.LoadAsync(templateDefinition.RenderDataKey);
}
catch (Exception)
{
Log.LogErrorFormatted(this, "Could not load render data for template definition {0} at {1}.", templateDefinition.Name, templateDefinition.RenderDataKey.Key);
yield break;
}
if (templateRequest != null)
{
yield return(templateRequest);
TemplateRenderData templateRenderData = templateRequest.Asset;
penguin.transform.rotation = templateRenderData.ItemRotation;
ModelRendererConfig config = new ModelRendererConfig(penguin.transform, templateRenderData.ItemPosition, new Vector2(256f, 256f))
{
FieldOfView = templateRenderData.CameraFOV,
FrameObjectInCamera = false,
UseOcclusionCulling = false,
AutoDestroyObjectToRender = false
};
if (param.BackgroundColor != Color.clear)
{
config.CameraBackgroundColor = param.BackgroundColor;
config.UseSolidBackground = true;
}
ModelRenderer modelRenderer = new ModelRenderer(config);
modelRenderer.RotateCamera(templateRenderData.CameraRotation.eulerAngles);
yield return(new WaitForEndOfFrame());
param.OutputTexture = modelRenderer.Image;
modelRenderer.Destroy();
}
}
protected void SetEquipment()
{
DCustomEquipment dCustomEquipment = CustomEquipmentResponseAdaptor.ConvertResponseToCustomEquipment(ItemData.equipment);
AvatarDetailsData avatarDetailsData = new AvatarDetailsData();
DCustomEquipment[] outfit = ((dCustomEquipment.Parts.Length != 0) ? new DCustomEquipment[1] {
dCustomEquipment
} : new DCustomEquipment[0]);
avatarDetailsData.Init(outfit);
if (!Service.Get <CPDataEntityCollection>().LocalPlayerHandle.IsNull&& Service.Get <CPDataEntityCollection>().TryGetComponent <AvatarDetailsData>(Service.Get <CPDataEntityCollection>().LocalPlayerHandle, out var component))
{
avatarDetailsData.BodyColor = component.BodyColor;
}
AvatarRenderTextureComponent.RenderAvatar(avatarDetailsData);
}
public static DCustomEquipment[] ConvertResponseToOutfit(CustomEquipment[] outfit)
{
if (outfit == null)
{
return(new DCustomEquipment[0]);
}
DCustomEquipment[] array = new DCustomEquipment[outfit.Length];
int num = 0;
for (int i = 0; i < outfit.Length; i++)
{
try
{
ref DCustomEquipment reference = ref array[num++];
reference = ConvertResponseToCustomEquipment(outfit[i]);
}
public static bool TryGetDCustomEquipment(CustomEquipment equipment, out DCustomEquipment equipmentData)
{
if (Service.Get <CPDataEntityCollection>().TryGetComponent <InventoryData>(Service.Get <CPDataEntityCollection>().LocalPlayerHandle, out var component) && component.Inventory != null)
{
Dictionary <long, InventoryIconModel <DCustomEquipment> > .Enumerator enumerator = component.Inventory.GetEnumerator();
while (enumerator.MoveNext())
{
InventoryIconModel <DCustomEquipment> value = enumerator.Current.Value;
if (IsEquipmentEqual(value.Data, equipment))
{
equipmentData = value.Data;
return(true);
}
}
}
equipmentData = default(DCustomEquipment);
return(false);
}
public static bool IsEquipmentEqual(DCustomEquipment equipment1, CustomEquipment equipment2)
{
if (equipment1.DefinitionId != equipment2.definitionId)
{
return(false);
}
if (equipment1.Parts.Length != equipment2.parts.Length)
{
return(false);
}
for (int i = 0; i < equipment1.Parts.Length; i++)
{
if (!IsEquipmentPartEqual(equipment1.Parts[i], equipment2.parts[i]))
{
return(false);
}
}
return(true);
}
private TagsArray[] getTagCollection(DCustomEquipment equipment)
{
List <TagDefinition[]> list = new List <TagDefinition[]>();
TagDefinition[] equipmentTags = Service.Get <TagsManager>().GetEquipmentTags(equipment);
if (equipmentTags.Length == 0)
{
return(new TagsArray[0]);
}
list.Add(equipmentTags);
TagsArray[] array = new TagsArray[list.Count];
int num = array.Length;
for (int i = 0; i < num; i++)
{
array[i].TagDefinitions = list[i];
}
return(array);
}
private bool onInventoryRetrieved(InventoryServiceEvents.InventoryLoaded evt)
{
Service.Get <EventDispatcher>().RemoveListener <InventoryServiceEvents.InventoryLoaded>(onInventoryRetrieved);
DataEntityHandle localPlayerHandle = Service.Get <CPDataEntityCollection>().LocalPlayerHandle;
if (!localPlayerHandle.IsNull)
{
inventoryData = Service.Get <CPDataEntityCollection>().AddComponent <InventoryData>(localPlayerHandle);
inventoryData.Inventory = new Dictionary <long, InventoryIconModel <DCustomEquipment> >();
inventoryData.CurrentAvatarEquipment = new List <long>();
setTemplateData();
for (int i = 0; i < evt.Inventory.Count; i++)
{
try
{
DCustomEquipment data = CustomEquipmentResponseAdaptor.ConvertResponseToCustomEquipment(evt.Inventory[i]);
InventoryIconModel <DCustomEquipment> value = new InventoryIconModel <DCustomEquipment>(data.Id, data, isEquipped: false, isMemberItem: true);
inventoryData.Inventory.Add(data.Id, value);
}
catch (KeyNotFoundException)
{
}
}
if (Service.Get <CPDataEntityCollection>().TryGetComponent(localPlayerHandle, out AvatarDetailsData component) && component.Outfit != null)
{
DCustomOutfit currentAvatarEquipment = default(DCustomOutfit);
currentAvatarEquipment.Equipment = component.Outfit;
setCurrentAvatarEquipment(currentAvatarEquipment);
}
}
else
{
Log.LogError(this, "Unable to find the LocalPlayerHandle.");
}
setDefaultScreen();
string key = SceneTransitionService.SceneArgs.ShowCatalogOnEntry.ToString();
if (Service.Get <SceneTransitionService>().HasSceneArg(key) && (bool)Service.Get <SceneTransitionService>().GetSceneArg(key))
{
showCatalog();
}
return(false);
}
private void renderRewardItem(long requestId, DCustomEquipment customEquipment)
{
try
{
AbstractImageBuilder.CallbackToken callbackToken = default(AbstractImageBuilder.CallbackToken);
callbackToken.Id = requestId;
callbackToken.DefinitionId = customEquipment.DefinitionId;
itemImageBuilder.RequestImage(customEquipment, delegate(bool success, Texture2D texture, AbstractImageBuilder.CallbackToken token)
{
if (success)
{
onIconReady(texture, 0);
}
}, callbackToken, Color.clear, Color.clear);
}
catch (Exception ex)
{
Log.LogException(this, ex);
}
}
private void addChallengeItem(int currentThemeDataIndex)
{
GameObject gameObject = UnityEngine.Object.Instantiate(ChallengeItem);
gameObject.transform.SetParent(scrollRectContent, worldPositionStays: false);
CatalogChallengeItem component = gameObject.GetComponent <CatalogChallengeItem>();
component.SetChallengeTheme(themes[currentThemeDataIndex], currentThemeDataIndex);
CatalogItemIcon component2 = gameObject.GetComponent <CatalogItemIcon>();
CurrentThemeData currentThemeData = themes[currentThemeDataIndex];
if (currentThemeData.mostPopularItem.HasValue)
{
DCustomEquipment equipment = CustomEquipmentResponseAdaptor.ConvertResponseToCustomEquipment(currentThemeData.mostPopularItem.Value.equipment);
Color[] colorsByIndex = Service.Get <CatalogServiceProxy>().themeColors.GetColorsByIndex(currentThemeDataIndex);
AbstractImageBuilder.CallbackToken callbackToken = default(AbstractImageBuilder.CallbackToken);
callbackToken.Id = ((equipment.Id == 0) ? currentThemeData.mostPopularItem.Value.clothingCatalogItemId : equipment.Id);
callbackToken.DefinitionId = equipment.DefinitionId;
base.itemImageBuilder.RequestImage(equipment, component2.SetIcon, callbackToken, Color.clear, colorsByIndex[0]);
}
}
public bool IsEquipmentMemberOnly(DCustomEquipment equipment)
{
Dictionary <int, TemplateDefinition> dictionary = Service.Get <GameData>().Get <Dictionary <int, TemplateDefinition> >();
if (dictionary.TryGetValue(equipment.DefinitionId, out var value))
{
if (value.IsMemberOnly)
{
return(true);
}
Dictionary <int, FabricDefinition> dictionary2 = Service.Get <GameData>().Get <Dictionary <int, FabricDefinition> >();
Dictionary <int, DecalDefinition> dictionary3 = Service.Get <GameData>().Get <Dictionary <int, DecalDefinition> >();
DCustomEquipmentPart[] parts = equipment.Parts;
for (int i = 0; i < parts.Length; i++)
{
if (parts[i].Decals == null)
{
continue;
}
for (int j = 0; j < parts[i].Decals.Length; j++)
{
DecalDefinition value3;
if (parts[i].Decals[j].Type == EquipmentDecalType.FABRIC)
{
if (dictionary2.TryGetValue(parts[i].Decals[j].DefinitionId, out var value2) && value2.IsMemberOnly)
{
return(true);
}
}
else if (dictionary3.TryGetValue(parts[i].Decals[j].DefinitionId, out value3) && value3.IsMemberOnly)
{
return(true);
}
}
}
}
return(false);
}
public TagDefinition[] GetEquipmentTags(DCustomEquipment equipment)
{
Dictionary <int, TemplateDefinition> dictionary = Service.Get <GameData>().Get <Dictionary <int, TemplateDefinition> >();
Dictionary <int, FabricDefinition> dictionary2 = Service.Get <GameData>().Get <Dictionary <int, FabricDefinition> >();
Dictionary <int, DecalDefinition> dictionary3 = Service.Get <GameData>().Get <Dictionary <int, DecalDefinition> >();
List <TagDefinition> list = new List <TagDefinition>();
if (dictionary.TryGetValue(equipment.DefinitionId, out TemplateDefinition value))
{
list.AddRange(value.Tags);
DCustomEquipmentPart[] parts = equipment.Parts;
for (int i = 0; i < parts.Length; i++)
{
if (parts[i].Decals == null)
{
continue;
}
for (int j = 0; j < parts[i].Decals.Length; j++)
{
DecalDefinition value3;
if (parts[i].Decals[j].Type == EquipmentDecalType.FABRIC)
{
if (dictionary2.TryGetValue(parts[i].Decals[j].DefinitionId, out FabricDefinition value2))
{
list.AddRange(value2.Tags);
}
}
else if (dictionary3.TryGetValue(parts[i].Decals[j].DefinitionId, out value3))
{
list.AddRange(value3.Tags);
}
}
}
}
return(list.ToArray());
}
private bool onEquipmentCreated(InventoryServiceEvents.EquipmentCreated evt)
{
serviceEventChannel.RemoveListener <InventoryServiceEvents.EquipmentCreated>(onEquipmentCreated);
serviceEventChannel.RemoveListener <InventoryServiceErrors.EquipmentCreationError>(onEquipmentCreationError);
long equipmentId = evt.EquipmentId;
DCustomEquipment customEquipmentModel = itemModel.CustomEquipmentModel;
customEquipmentModel.Id = equipmentId;
customEquipmentModel.DateTimeCreated = DateTime.UtcNow.GetTimeInMilliseconds();
InventoryData component = Service.Get <CPDataEntityCollection>().GetComponent <InventoryData>(Service.Get <CPDataEntityCollection>().LocalPlayerHandle);
if (component != null)
{
InventoryIconModel <DCustomEquipment> value = new InventoryIconModel <DCustomEquipment>(equipmentId, customEquipmentModel, isEquipped: false, isMemberItem: true);
component.Inventory.Add(equipmentId, value);
}
else
{
Log.LogError(this, "Unable to locate InventoryData object.");
}
Service.Get <NotificationBreadcrumbController>().AddPersistentBreadcrumb(BreadcrumbType, equipmentId.ToString());
CustomizationContext.EventBus.DispatchEvent(default(CustomizerUIEvents.SaveClothingItemSuccess));
return(false);
}
public EquipmentAddedToAvatar(DCustomEquipment data)
{
Data = data;
}
