public IHttpActionResult Put(int id, EquipmentCatalog equipmentCatalog)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != equipmentCatalog.equipment_code)
{
return(BadRequest());
}
db.Entry(equipmentCatalog).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!EquipmentCatalogExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public static List <EquipmentIndex> GetEquipment()
{
List <EquipmentIndex> equipment = new List <EquipmentIndex>();
List <EquipmentIndex> equip = new List <EquipmentIndex>();
List <EquipmentIndex> lunar = new List <EquipmentIndex>();
List <EquipmentIndex> other = new List <EquipmentIndex>();
Color32 equipColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.Equipment);
Color32 lunarColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarItem);
foreach (EquipmentIndex equipmentIndex in EquipmentCatalog.allEquipment)
{
Color32 currentEquipColor = ColorCatalog.GetColor(EquipmentCatalog.GetEquipmentDef(equipmentIndex).colorIndex);
if (currentEquipColor.Equals(equipColor)) // equipment
{
equip.Add(equipmentIndex);
}
else if (currentEquipColor.Equals(lunarColor)) // lunar equipment
{
lunar.Add(equipmentIndex);
}
else // other
{
other.Add(equipmentIndex);
}
}
UmbraMenu.unreleasedEquipment = other;
var result = equipment.Concat(lunar).Concat(equip).Concat(other).ToList();
return(result);
}
private void CreateTooltip(Transform parent, PickupDef pickupDefinition, int count)
{
ItemDef itemDefinition = ItemCatalog.GetItemDef(pickupDefinition.itemIndex);
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(pickupDefinition.equipmentIndex);
bool isItem = itemDefinition != null;
TooltipContent content = new TooltipContent();
content.titleColor = pickupDefinition.darkColor;
content.titleToken = isItem ? itemDefinition.nameToken : equipmentDef.nameToken;
content.bodyToken = isItem ? itemDefinition.descriptionToken : equipmentDef.descriptionToken;
if (isItem && ItemStatsMod.enabled)
{
CharacterMaster master = PlayerCharacterMasterController.instances[0].master;
string stats = ItemStatsMod.GetStats(itemDefinition.itemIndex, count, master);
if (stats != null)
{
content.overrideBodyText = $"{Language.GetString(content.bodyToken)}{stats}";
}
}
TooltipProvider tooltipProvider = parent.gameObject.AddComponent <TooltipProvider>();
tooltipProvider.SetContent(content);
}
/// <summary>
/// Add an item to the item pool from a string.
/// </summary>
/// <param name="unlockableRewardIdentifier">The AchievementDef.unlockableRewardIdentifier, e.g. "Item.Bear"</param>
public void AddItemFromString(string unlockableRewardIdentifier)
{
string pattern = @"\w+\."; //this just means "[infinite letters until]."
bool equipment = false;
unlockableRewardIdentifier = Regex.Replace(unlockableRewardIdentifier, pattern, ""); //remove "[infinite letters until]." so we have the itemname remaining
foreach (EquipmentIndex i in EquipmentCatalog.equipmentList)
{
EquipmentDef EqDef = EquipmentCatalog.GetEquipmentDef(i);
string equipmentString = EqDef.name;
if (unlockableRewardIdentifier == equipmentString)
{
Run.instance.availableEquipment.Add(EquipmentCatalog.FindEquipmentIndex(unlockableRewardIdentifier));
equipment = true;
break; //So we don't search everything if we already have it
}
}
if (!equipment) //it doesn't matter if we try to find itemindex for characters or logs, due to the fact that they won't have the same name as an available item, and will not result in an ItemIndex that we can use
{
Run.instance.availableItems.Add(ItemCatalog.FindItemIndex(unlockableRewardIdentifier)); //Add the item from this string into the available items
}
Run.instance.BuildDropTable(); //Makes it so that everything we added actually gets put into the game pool so we can get it on the next items, you can see it that old items do not have it with command, but hopefully that won't matter :]
UpdateDroppedCommandDroplets();
}
// Token: 0x060022C4 RID: 8900 RVA: 0x00096F90 File Offset: 0x00095190
private EquipmentIcon.DisplayData GenerateDisplayData()
{
EquipmentIcon.DisplayData result = default(EquipmentIcon.DisplayData);
EquipmentIndex equipmentIndex = EquipmentIndex.None;
if (this.targetInventory)
{
EquipmentState equipmentState;
if (this.displayAlternateEquipment)
{
equipmentState = this.targetInventory.alternateEquipmentState;
result.hideEntireDisplay = (this.targetInventory.GetEquipmentSlotCount() <= 1);
}
else
{
equipmentState = this.targetInventory.currentEquipmentState;
result.hideEntireDisplay = false;
}
Run.FixedTimeStamp now = Run.FixedTimeStamp.now;
Run.FixedTimeStamp chargeFinishTime = equipmentState.chargeFinishTime;
equipmentIndex = equipmentState.equipmentIndex;
result.cooldownValue = (chargeFinishTime.isInfinity ? 0 : Mathf.CeilToInt(chargeFinishTime.timeUntilClamped));
result.stock = (int)equipmentState.charges;
result.maxStock = (this.targetEquipmentSlot ? this.targetEquipmentSlot.maxStock : 1);
}
else if (this.displayAlternateEquipment)
{
result.hideEntireDisplay = true;
}
result.equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
return(result);
}
void FixedUpdate()
{
if (!body.healthComponent.alive)
{
return;
}
if (icd > 0f)
{
icd -= Time.fixedDeltaTime;
}
var count = DeadManSwitch.instance.GetCount(body);
if (count <= 0)
{
return;
}
var eqp = EquipmentCatalog.GetEquipmentDef(body.equipmentSlot.equipmentIndex);
if (icd <= 0f && body.healthComponent.isHealthLow && eqp != null)
{
icd = Mathf.Pow(1f - DeadManSwitch.instance.cdrStack, count - 1)
* eqp.cooldown
* (DeadManSwitch.instance.externalCdr ? body.inventory.CalculateEquipmentCooldownScale() : 1f);
body.AddTimedBuff(DeadManSwitch.instance.deadManSwitchBuff, icd);
body.equipmentSlot.PerformEquipmentAction(eqp);
}
}
public void UpdatePickupTooltip(TooltipProvider tooltip, PickupIndex pickupIdx, int itemCount = 1)
{
PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIdx);
string descToken;
if (pickupDef.itemIndex != ItemIndex.None)
{
descToken = ItemCatalog.GetItemDef(pickupDef.itemIndex).descriptionToken;
}
else if (pickupDef.equipmentIndex != EquipmentIndex.None)
{
descToken = EquipmentCatalog.GetEquipmentDef(pickupDef.equipmentIndex).descriptionToken;
}
else
{
return;
}
string pickupDesc = Language.IsTokenInvalid(descToken) ? Language.GetString(pickupDef.nameToken) : Language.GetString(descToken);
pickupDesc += "\n\n" + PickupStatsProvider.GetStatsForPickup(pickupIdx, itemCount);
tooltip.overrideBodyText = pickupDesc;
}
private async Task UpdatePricelistEquipment(
EquipmentCatalog equipmentCatalog,
ColorNode colorNode)
{
string pricelist = null;
DateTime?productionFromDate = null;
DateTime?validFromDate = null;
if (colorNode.pricelist != null)
{
pricelist = colorNode.pricelist.price;
productionFromDate = colorNode.pricelist.productionFromDate;
validFromDate = colorNode.pricelist.validFromDate;
}
await this.CarContext.FindOrCreatePricelistCatalogAsync
(
colorNode.name,
colorNode.metallic,
colorNode.hue,
colorNode.picture,
pricelist,
productionFromDate,
validFromDate,
equipmentCatalog.Id
);
}
/*
* Create & read config into blacklists.
*/
private void initConf()
{
//Set Language for storing item names as their ingame English locale inside config comments.
Language.LoadAllFilesForLanguage("EN_US");
//Loop through itemIndex to generate config entry per item.
for (ItemIndex ii = ItemIndex.Syringe; ii < ItemIndex.Count; ii++)
{
icBanned[(int)ii] = Config.Wrap(
"Items",
ii.ToString(),
Language.GetString(ItemCatalog.GetItemDef(ii).nameToken, "EN_US") + " Default Value = false",
false
);
//Ban item if configured value is true.
if (icBanned[(int)ii].Value == true)
{
iblackList.Add(ii);
}
}
//Loop through EquipmentIndex to generate config entry per item.
for (EquipmentIndex ei = EquipmentIndex.CommandMissile; ei < EquipmentIndex.Count; ei++)
{
ecBanned[(int)ei] = Config.Wrap(
"Equipment",
ei.ToString(),
Language.GetString(EquipmentCatalog.GetEquipmentDef(ei).nameToken, "EN_US") + " Default Value = false",
false
);
//Ban equipment if configured value is true.
if (ecBanned[(int)ei].Value == true)
{
eblackList.Add(ei);
}
}
}
public static void customEquip(Inventory inventory)
{
// Custom Equip Blacklist
string[] customEquiplist = CustomEquipBlacklist.Value.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
// Debug.Log("Current equipment: " + inventory.GetEquipment(0).equipmentDef.name);
foreach (string equip in customEquiplist)
{
if (Int32.TryParse(equip, out int x))
{
if (inventory.GetEquipmentIndex() == (EquipmentIndex)x)
{
//Debug.Log("Removed equipment");
inventory.SetEquipmentIndex(EquipmentIndex.None);
}
}
else
{
EquipmentIndex index = EquipmentCatalog.FindEquipmentIndex(equip);
Debug.Log("Index: " + index + " Name: " + equip);
if (index != EquipmentIndex.None)
{
//Debug.Log("Removed equipment");
if (inventory.GetEquipmentIndex() == index)
{
inventory.SetEquipmentIndex(EquipmentIndex.None);
}
}
}
}
}
private async Task UpdateSpecifications(
EquipmentCatalog equipmentCatalog,
EquipmentsEdge edge)
{
if (edge.node.specification != null)
{
if (edge.node.specification.description != null)
{
foreach (var description in edge.node.specification.description)
{
await this.UpdateSpecification
(
equipmentCatalog.Id,
description.name,
description.features
);
}
}
if (edge.node.specification.technical != null)
{
await this.UpdateSpecification
(
equipmentCatalog.Id,
"Техническое описание",
edge.node.specification.technical
);
}
}
await this.SpecificationsCatalogLoader.ActivateNewSpecificationCatalogAsync(equipmentCatalog.Id);
}
private string Util_GetBestBodyName(On.RoR2.Util.orig_GetBestBodyName orig, GameObject bodyObject)
{
var origName = orig(bodyObject);
CharacterBody characterBody = null;
if (bodyObject)
{
characterBody = bodyObject.GetComponent <CharacterBody>();
}
if (characterBody && characterBody.inventory && characterBody.inventory.currentEquipmentIndex != EquipmentIndex.None)
{
var firstLocalUser = LocalUserManager.GetFirstLocalUser();
if (characterBody.teamComponent &&
firstLocalUser != null &&
firstLocalUser.cachedMaster &&
characterBody.teamComponent.teamIndex == LocalUserManager.GetFirstLocalUser().cachedMaster.teamIndex)
{
if ((characterBody.master && characterBody.master.masterIndex == EquipmentDroneMasterIndex && cfgNameEquipmentMode.Value == NameEquipmentMode.EquipmentDrones) ||
cfgNameEquipmentMode.Value == NameEquipmentMode.Any)
{
origName += $" ({Language.GetString(EquipmentCatalog.GetEquipmentDef(characterBody.inventory.currentEquipmentIndex).nameToken)})";
}
//35 char limit ish before truncation
}
}
return(origName);
}
public EquipmentList() : base(equipmentList)
{
if (UmbraMenu.characterCollected)
{
int buttonPlacement = 1;
List <Button> buttons = new List <Button>();
for (int i = 0; i < UmbraMenu.equipment.Count; i++)
{
var equipmentIndex = UmbraMenu.equipment[i];
if (equipmentIndex != EquipmentIndex.None && equipmentIndex != EquipmentCatalog.FindEquipmentIndex("AffixYellow"))
{
void ButtonAction() => GiveEquipment(equipmentIndex);
Color32 equipColor = ColorCatalog.GetColor(EquipmentCatalog.GetEquipmentDef(equipmentIndex).colorIndex);
string equipmentName = Util.GenerateColoredString(Language.GetString(EquipmentCatalog.GetEquipmentDef(equipmentIndex).nameToken), ColorCatalog.GetColor(EquipmentCatalog.GetEquipmentDef(equipmentIndex).colorIndex));
Button button = new Button(new NormalButton(this, buttonPlacement, equipmentName, ButtonAction));
buttons.Add(button);
buttonPlacement++;
}
else
{
void ButtonAction() => GiveEquipment(equipmentIndex);
string equipmentName = Util.GenerateColoredString(equipmentIndex.ToString(), ColorCatalog.GetColor(ColorCatalog.ColorIndex.Equipment));
Button button = new Button(new NormalButton(this, buttonPlacement, equipmentName, ButtonAction));
buttons.Add(button);
buttonPlacement++;
}
}
AddButtons(buttons);
SetActivatingButton(Utility.FindButtonById(3, 4));
SetPrevMenuId(3);
}
}
public static void PopulateItemCatalog()
{
if (!Loaded)
{
foreach (var itemIndex in ItemCatalog.allItems)
{
var itemDef = ItemCatalog.GetItemDef(itemIndex);
if (itemDef.tier != ItemTier.NoTier && itemDef.pickupIconSprite != null && itemDef.pickupIconSprite.name != DropList.NullIconTextureName)
{
if (itemDef.ContainsTag(ItemTag.Scrap))
{
if (!ScrapItems.ContainsKey(itemDef.tier))
{
ScrapItems.Add(itemDef.tier, itemIndex);
}
}
else if (itemDef.ContainsTag(ItemTag.WorldUnique))
{
SpecialItems.Add(itemIndex);
}
}
}
foreach (var equipmentIndex in EquipmentCatalog.allEquipment)
{
var equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
if (!EquipmentCatalog.equipmentList.Contains(equipmentIndex))
{
if (equipmentDef.pickupIconSprite != null &&
equipmentDef.pickupIconSprite.name != DropList.NullIconTextureName)
{
EliteEquipment.Add(equipmentIndex);
}
}
}
foreach (var itemIndex in ItemCatalog.lunarItemList)
{
var itemDef = ItemCatalog.GetItemDef(itemIndex);
var cleansable = false;
foreach (var itemTag in itemDef.tags)
{
if (itemTag == ItemTag.Cleansable)
{
cleansable = true;
}
}
if (!cleansable)
{
if (!ScrapItems.ContainsValue(itemIndex) && itemDef.tier != ItemTier.NoTier &&
itemDef.pickupIconSprite != null &&
itemDef.pickupIconSprite.name != DropList.NullIconTextureName)
{
//print(itemIndex);
}
}
}
Loaded = true;
}
}
private static void CreateNotification(CharacterBody body, EquipmentIndex index)
{
var equipmentDef = EquipmentCatalog.GetEquipmentDef(index);
var description = Language.GetString(equipmentDef.nameToken);
var texture = equipmentDef.pickupIconTexture;
CreateNotification(body, "Equipment dropped", description, texture);
}
private static void CreateNotification(CharacterBody character, Transform transform, EquipmentIndex equipmentIndex)
{
var equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
const string title = "Equipment dropped";
var description = Language.GetString(equipmentDef.nameToken);
var texture = Resources.Load <Texture>(equipmentDef.pickupIconPath);
CreateNotification(character, transform, title, description, texture);
}
public static void DrawChestItemMenu(float x, float y, float widthSize, int mulY, GUIStyle BGstyle, GUIStyle buttonStyle, GUIStyle LabelStyle)
{
int heightMul = 15;
if (Main.lowResolutionMonitor)
{
heightMul = 10;
}
GUI.Box(new Rect(x + 0f, y + 0f, widthSize + 20, 50f + 45 * heightMul), "", BGstyle);
GUI.Label(new Rect(x + 5f, y + 5f, widthSize + 10, 85f), "C H A N G E C H E S T L I S T", LabelStyle);
chestItemChangerScrollPosition = GUI.BeginScrollView(new Rect(x + 0f, y + 0f, widthSize + 10, 50f + 45 * heightMul), chestItemChangerScrollPosition, new Rect(x + 0f, y + 0f, widthSize + 10, 50f + 45 * mulY), false, true);
int buttonPlacement = 1;
if (Chests.IsClosestChestEquip())
{
foreach (var equipmentIndex in Main.equipment)
{
if (equipmentIndex != EquipmentIndex.None)
{
Color32 equipColor = ColorCatalog.GetColor(EquipmentCatalog.GetEquipmentDef(equipmentIndex).colorIndex);
if (equipColor.r <= 105 && equipColor.g <= 105 && equipColor.b <= 105)
{
string equipmentName = Util.GenerateColoredString(Language.GetString(EquipmentCatalog.GetEquipmentDef(equipmentIndex).nameToken), new Color32(255, 255, 255, 255));
DrawButton(buttonPlacement, "chestItemChanger", equipmentName, buttonStyle);
buttonPlacement++;
}
else
{
string equipmentName = Util.GenerateColoredString(Language.GetString(EquipmentCatalog.GetEquipmentDef(equipmentIndex).nameToken), ColorCatalog.GetColor(EquipmentCatalog.GetEquipmentDef(equipmentIndex).colorIndex));
DrawButton(buttonPlacement, "chestItemChanger", equipmentName, buttonStyle);
buttonPlacement++;
}
}
}
}
else
{
foreach (var itemIndex in Main.items)
{
Color32 itemColor = ColorCatalog.GetColor(ItemCatalog.GetItemDef(itemIndex).colorIndex);
if (itemColor.r <= 105 && itemColor.g <= 105 && itemColor.b <= 105)
{
string itemName = Util.GenerateColoredString(Language.GetString(ItemCatalog.GetItemDef(itemIndex).nameToken), new Color32(255, 255, 255, 255));
DrawButton(buttonPlacement, "chestItemChanger", itemName, buttonStyle);
buttonPlacement++;
}
else
{
string itemName = Util.GenerateColoredString(Language.GetString(ItemCatalog.GetItemDef(itemIndex).nameToken), itemColor);
DrawButton(buttonPlacement, "chestItemChanger", itemName, buttonStyle);
buttonPlacement++;
}
}
}
GUI.EndScrollView();
}
private async Task UpdatePricelistsEquipment(
EquipmentCatalog equipmentCatalog,
EquipmentsEdge edge)
{
foreach (var color in edge.node.colors)
{
await UpdatePricelistEquipment(equipmentCatalog, color);
}
}
public IHttpActionResult Get(int id)
{
EquipmentCatalog equipmentCatalog = db.EquipmentCatalogs.Find(id);
if (equipmentCatalog == null)
{
return(NotFound());
}
return(Ok(equipmentCatalog));
}
private async Task UpdateVersionEquipment(
EquipmentCatalog equipmentCatalog,
EquipmentsEdge edge)
{
var versionCatalog = await this.VersionsCatalogLoader.FindOrCreateVersionCatalogAsync(edge);
await this.CarContext.FindOrCreateEquipmentVersionCatalogAsync(
equipmentCatalog.Id,
versionCatalog.Id
);
}
////// Hooks //////
private void CharacterBody_onBodyInventoryChangedGlobal(CharacterBody body)
{
if (!body || !body.inventory)
{
return;
}
if (EquipmentCatalog.GetEquipmentDef(body.inventory.currentEquipmentIndex) == this.equipmentDef && !body.gameObject.GetComponent <RewindComponent>())
{
body.gameObject.AddComponent <RewindComponent>();
}
}
private static EquipmentIndex StringToEquipmentIndex(string indexStr)
{
EquipmentIndex index = EquipmentCatalog.FindEquipmentIndex(indexStr);
if (index == EquipmentIndex.None)
{
AIBlacklister.Logger.LogWarning($"Tried to add equipment to blacklist but '{indexStr}' is not a valid EquipmentIndex.");
}
return(index);
}
public int Compare(EquipmentIndex x, EquipmentIndex y)
{
EquipmentDef equipmentDefx = EquipmentCatalog.GetEquipmentDef(x);
EquipmentDef equipmentDefy = EquipmentCatalog.GetEquipmentDef(y);
int result = equipmentDefx.colorIndex.CompareTo(equipmentDefy.colorIndex);
if (result == 0)
{
result = Language.GetString(equipmentDefx.nameToken).CompareTo(Language.GetString(equipmentDefy.nameToken));
}
return(result);
}
// Token: 0x060021B4 RID: 8628 RVA: 0x0009EE88 File Offset: 0x0009D088
public void SetEquipment(EquipmentIndex equipmentIndex)
{
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
this.titleText.token = equipmentDef.nameToken;
this.descriptionText.token = equipmentDef.pickupToken;
if (equipmentDef.pickupIconPath != null)
{
this.iconImage.texture = Resources.Load <Texture>(equipmentDef.pickupIconPath);
}
this.titleTMP.color = ColorCatalog.GetColor(equipmentDef.colorIndex);
}
public static void UpdateChestListMenu()
{
List <Button> buttons = new List <Button>();
if (isClosestChestEquip)
{
for (int i = 0; i < UmbraMenu.equipment.Count; i++)
{
var equipmentIndex = UmbraMenu.equipment[i];
if (equipmentIndex != EquipmentIndex.None)
{
void ButtonAction() => SetChestEquipment(equipmentIndex);
if (equipmentIndex != EquipmentCatalog.FindEquipmentIndex("AffixYellow"))
{
Color32 equipColor = ColorCatalog.GetColor(EquipmentCatalog.GetEquipmentDef(equipmentIndex).colorIndex);
string equipmentName = Util.GenerateColoredString(Language.GetString(EquipmentCatalog.GetEquipmentDef(equipmentIndex).nameToken), ColorCatalog.GetColor(EquipmentCatalog.GetEquipmentDef(equipmentIndex).colorIndex));
Button button = new Button(new NormalButton(UmbraMenu.chestItemListMenu, i + 1, equipmentName, ButtonAction));
buttons.Add(button);
}
else
{
string equipmentName = Util.GenerateColoredString(equipmentIndex.ToString(), ColorCatalog.GetColor(ColorCatalog.ColorIndex.Equipment));
Button button = new Button(new NormalButton(UmbraMenu.chestItemListMenu, i + 1, equipmentName, ButtonAction));
buttons.Add(button);
}
}
}
}
else
{
for (int i = 0; i < UmbraMenu.items.Count; i++)
{
var itemIndex = UmbraMenu.items[i];
void ButtonAction() => SetChestItem(itemIndex);
Color32 itemColor = ColorCatalog.GetColor(ItemCatalog.GetItemDef(itemIndex).colorIndex);
if (itemColor.r <= 105 && itemColor.g <= 105 && itemColor.b <= 105)
{
string itemName = Util.GenerateColoredString(Language.GetString(ItemCatalog.GetItemDef(itemIndex).nameToken), new Color32(0, 0, 0, 255));
Button button = new Button(new NormalButton(UmbraMenu.chestItemListMenu, i + 1, itemName, ButtonAction));
buttons.Add(button);
}
else
{
string itemName = Util.GenerateColoredString(Language.GetString(ItemCatalog.GetItemDef(itemIndex).nameToken), itemColor);
Button button = new Button(new NormalButton(UmbraMenu.chestItemListMenu, i + 1, itemName, ButtonAction));
buttons.Add(button);
}
}
}
UmbraMenu.chestItemListMenu.AddButtons(buttons);
}
public IHttpActionResult Post(EquipmentCatalog equipmentCatalog)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.EquipmentCatalogs.Add(equipmentCatalog);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = equipmentCatalog.equipment_code }, equipmentCatalog));
}
// Token: 0x060026C5 RID: 9925 RVA: 0x000A909C File Offset: 0x000A729C
public void AddSimplePickup(PickupIndex pickupIndex)
{
ItemIndex itemIndex = pickupIndex.itemIndex;
EquipmentIndex equipmentIndex = pickupIndex.equipmentIndex;
string token = null;
if (itemIndex != ItemIndex.None)
{
ItemDef itemDef = ItemCatalog.GetItemDef(itemIndex);
this.AddDescriptionPanel(Language.GetString(itemDef.descriptionToken));
token = itemDef.loreToken;
ulong statValueULong = this.statSheet.GetStatValueULong(PerItemStatDef.totalCollected.FindStatDef(itemIndex));
ulong statValueULong2 = this.statSheet.GetStatValueULong(PerItemStatDef.highestCollected.FindStatDef(itemIndex));
string stringFormatted = Language.GetStringFormatted("GENERIC_PREFIX_FOUND", new object[]
{
statValueULong
});
string stringFormatted2 = Language.GetStringFormatted("ITEM_PREFIX_STACKCOUNT", new object[]
{
statValueULong2
});
this.AddSimpleTextPanel(new string[]
{
stringFormatted,
stringFormatted2
});
}
else if (equipmentIndex != EquipmentIndex.None)
{
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
this.AddDescriptionPanel(Language.GetString(equipmentDef.descriptionToken));
token = equipmentDef.loreToken;
string stringFormatted3 = Language.GetStringFormatted("EQUIPMENT_PREFIX_COOLDOWN", new object[]
{
equipmentDef.cooldown
});
string stringFormatted4 = Language.GetStringFormatted("EQUIPMENT_PREFIX_TOTALTIMEHELD", new object[]
{
this.statSheet.GetStatDisplayValue(PerEquipmentStatDef.totalTimeHeld.FindStatDef(equipmentIndex))
});
string stringFormatted5 = Language.GetStringFormatted("EQUIPMENT_PREFIX_USECOUNT", new object[]
{
this.statSheet.GetStatDisplayValue(PerEquipmentStatDef.totalTimesFired.FindStatDef(equipmentIndex))
});
this.AddSimpleTextPanel(stringFormatted3);
this.AddSimpleTextPanel(new string[]
{
stringFormatted4,
stringFormatted5
});
}
this.AddNotesPanel(Language.IsTokenInvalid(token) ? Language.GetString("EARLY_ACCESS_LORE") : Language.GetString(token));
}
public void DuplicateDropLists(Run run)
{
if (!OriginalListsSaved)
{
Tier1DropListOriginal = BackupDropList(run.availableTier1DropList);
Tier2DropListOriginal = BackupDropList(run.availableTier2DropList);
Tier3DropListOriginal = BackupDropList(run.availableTier3DropList);
LunarDropListOriginal = BackupDropList(run.availableLunarDropList);
EquipmentDropListOriginal = BackupDropList(run.availableEquipmentDropList);
NormalEquipmentDropListOriginal = BackupDropList(run.availableNormalEquipmentDropList);
LunarEquipmentDropListOriginal = BackupDropList(run.availableLunarEquipmentDropList);
BossDropListOriginal = BackupDropList(run.availableBossDropList);
/*
* foreach (var bossItem in Catalog.SpecialItems) {
* var pickupIndex = PickupCatalog.FindPickupIndex(bossItem);
* if (!BossDropListOriginal.Contains(pickupIndex)) {
* BossDropListOriginal.Add(pickupIndex);
* }
* }
*/
SpecialItemsOriginal.Clear();
foreach (var itemIndex in Catalog.SpecialItems)
{
if (run.availableItems.Contains(itemIndex))
{
SpecialItemsOriginal.Add(PickupCatalog.FindPickupIndex(itemIndex));
}
}
foreach (var itemIndex in Catalog.ScrapItems.Values)
{
if (run.availableItems.Contains(itemIndex))
{
SpecialItemsOriginal.Add(PickupCatalog.FindPickupIndex(itemIndex));
}
}
SpecialEquipmentOriginal.Clear();
foreach (var equipmentIndex in Catalog.EliteEquipment)
{
var sprite = EquipmentCatalog.GetEquipmentDef(equipmentIndex).pickupIconSprite;
if (sprite != null && !sprite.name.Contains(NullIconTextureName))
{
SpecialEquipmentOriginal.Add(PickupCatalog.FindPickupIndex(equipmentIndex));
}
}
OriginalListsSaved = true;
}
}
// Backs up all the original drop lists generated for this run.
public void DuplicateDropLists(Run run)
{
if (!OriginalListsSaved)
{
Tier1DropListOriginal = BackupDropList(run.availableTier1DropList);
Tier2DropListOriginal = BackupDropList(run.availableTier2DropList);
Tier3DropListOriginal = BackupDropList(run.availableTier3DropList);
LunarDropListOriginal = BackupDropList(run.availableLunarDropList);
EquipmentDropListOriginal = BackupDropList(run.availableEquipmentDropList);
NormalEquipmentDropListOriginal = BackupDropList(run.availableNormalEquipmentDropList);
LunarEquipmentDropListOriginal = BackupDropList(run.availableLunarEquipmentDropList);
BossDropListOriginal = BackupDropList(run.availableBossDropList);
/*
* foreach (var bossItem in Catalog.SpecialItems) {
* var pickupIndex = PickupCatalog.FindPickupIndex(bossItem);
* if (!BossDropListOriginal.Contains(pickupIndex)) {
* BossDropListOriginal.Add(pickupIndex);
* }
* }
*/
SpecialItemsOriginal.Clear();
foreach (var itemIndex in Catalog.SpecialItems)
{
if (run.availableItems.Contains(itemIndex))
{
SpecialItemsOriginal.Add(PickupCatalog.FindPickupIndex(itemIndex));
}
}
foreach (var itemIndex in Catalog.ScrapItems.Values)
{
if (run.availableItems.Contains(itemIndex))
{
SpecialItemsOriginal.Add(PickupCatalog.FindPickupIndex(itemIndex));
}
}
SpecialEquipmentOriginal.Clear();
foreach (var equipmentIndex in Catalog.EliteEquipment)
{
var equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
if (equipmentDef.unlockableDef == null || PreGameController.AnyUserHasUnlockable(equipmentDef.unlockableDef))
{
SpecialEquipmentOriginal.Add(PickupCatalog.FindPickupIndex(equipmentIndex));
}
}
OriginalListsSaved = true;
}
}
static List <string> DefaultBannedItemsList()
{
List <string> bannedItems = new List <string>();
bannedItems.Add("# Make sure each item id is on it's own line");
bannedItems.Add("# Do not paste item's full name, only paste the id provided below");
//Items
bannedItems.Add("# --Items--");
bannedItems.Add("I13"); //Brilliant Behemoth
bannedItems.Add("I85"); //N'kuhana's Opinion
bannedItems.Add("I105"); //Unstable Tesla Coil
bannedItems.Add("I112"); //Little Disciple
bannedItems.Add("I122"); //Razorwire
bannedItems.Add("I76"); //Strides of Heresy
//Equipment
bannedItems.Add("# --Equipments--");
bannedItems.Add("E39"); //Spinel Tonic
bannedItems.Add("E29"); //Glowing Meteorite
bannedItems.Add("E11"); //Helfire Tincture
bannedItems.Add("E9"); //Preon Accumulator
bannedItems.Add("E10"); //Primordial Cube
bannedItems.Add("E27"); //Royal Capacitor
bannedItems.Add("E13"); //Disposable Missile Launcher
bannedItems.Add("E19"); //Volcanic Egg
bannedItems.Add("E24"); //The Crowdfunder
bannedItems.Add("E17"); //The Back-up
bannedItems.Add("E16"); //Forgive Me Please
//Output all item names
bannedItems.Add("# -----------------------------------------------------------------------------------------");
bannedItems.Add("# List of item ids and it's full name");
bannedItems.Add("# -----------------------------------------------------------------------------------------");
List <ItemIndex> items = ItemCatalog.allItems.ToList();
for (int i = 0; i < items.Count; i++)
{
ItemDef itemDef = ItemCatalog.GetItemDef(items[i]);
bannedItems.Add("# ID: I" + itemDef.itemIndex + " FullName: " + Language.GetString(itemDef.nameToken));
}
//Output all equipment names
bannedItems.Add("# -----------------------------------------------------------------------------------------");
bannedItems.Add("# List of equipment ids and it's full name");
bannedItems.Add("# -----------------------------------------------------------------------------------------");
List <EquipmentIndex> equipments = EquipmentCatalog.allEquipment.ToList();
for (int i = 0; i < equipments.Count; i++)
{
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(equipments[i]);
bannedItems.Add("# ID: E" + equipmentDef.equipmentIndex + " FullName: " + Language.GetString(equipmentDef.nameToken));
}
return(bannedItems);
}
