public override void Draw()
{
using (new GUILayout.HorizontalScope())
{
if (GUILayout.Button("Import", GUILayout.Width(140), GUILayout.Height(28)))
{
MDEditorBase.UseCase.ImportTable <ItemTier>( // 1
(builder, list) =>
{
var excepts = GameDatabase.DB.ItemTierTable.All.Select(x => x.id).ToArray(); // 2
excepts = excepts.Except(list.Select(x => x.id).ToArray()).ToArray();
// 無いIdのものを削除
builder.RemoveItemTier(excepts); // 3
// データ差し替え
builder.ReplaceAll(list.ToArray());
},
() =>
{
current = null;
CreateList();
});
}
if (GUILayout.Button("Export", GUILayout.Width(140), GUILayout.Height(28)))
{
MDEditorBase.UseCase.ExportTable(GameDatabase.DB.ItemTierTable.All.ToList()); // 4
}
}
using (new GUILayout.HorizontalScope())
{
// 左側
using (new GUILayout.VerticalScope(GUILayout.Width(160)))
{
cardLeftScrollPos = EditorGUILayout.BeginScrollView(cardLeftScrollPos, GUI.skin.box);
if (itemList == null)
{
CreateList();
}
itemList?.DoLayoutList();
EditorGUILayout.EndScrollView();
}
if (current != null)
{
// 真ん中
using (new GUILayout.VerticalScope())
{
cardCenterScrollPos = EditorGUILayout.BeginScrollView(cardCenterScrollPos, GUI.skin.box);
using (new GUILayout.VerticalScope()) {
current?.Draw();
}
GUILayout.Space(10);
EditorGUILayout.EndScrollView();
}
}
}
}
public CustomItem(string name, string nameToken,
string descriptionToken, string loreToken,
string pickupToken,
Sprite pickupIconSprite, GameObject pickupModelPrefab,
ItemTier tier, ItemTag[] tags,
bool canRemove,
bool hidden,
UnlockableDef unlockableDef = null,
ItemDisplayRuleDict?itemDisplayRules = null)
{
ItemDef = ScriptableObject.CreateInstance <ItemDef>();
ItemDef.canRemove = canRemove;
ItemDef.descriptionToken = descriptionToken;
ItemDef.hidden = hidden;
ItemDef.loreToken = loreToken;
ItemDef.name = name;
ItemDef.nameToken = nameToken;
ItemDef.pickupIconSprite = pickupIconSprite;
ItemDef.pickupModelPrefab = pickupModelPrefab;
ItemDef.pickupToken = pickupToken;
ItemDef.tags = tags;
ItemDef.tier = tier;
ItemDef.unlockableDef = unlockableDef;
ItemDisplayRules = itemDisplayRules;
}
private static bool IsScrapable(ItemTier tier)
{
switch (tier)
{
case ItemTier.Tier1:
case ItemTier.Tier2:
case ItemTier.Tier3:
case ItemTier.Boss:
return(true);
case ItemTier.Lunar:
if (LunarScrapIndex != ItemIndex.None)
{
return(true);
}
else
{
return(false);
}
case ItemTier.VoidTier1:
case ItemTier.VoidTier2:
case ItemTier.VoidTier3:
case ItemTier.VoidBoss:
return(false);
default:
return(false);
}
}
void CreateList()
{
if (MDEditorBase.TempMD.ItemTierTable == null)
{
var builder = MDEditorBase.TempMD.ToDatabaseBuilder();
builder.Append(new [] { new ItemTier {
id = "100", name = "normal"
} });
MDEditorBase.TempMD = new MD.MemoryDatabase(builder.Build());
}
items = new List <ItemTier>(MDEditorBase.TempMD.ItemTierTable.All);
itemList = new ReorderableList(items, typeof(ItemTier), false, true, false, false);
// ヘッダーの描画設定
itemList.drawHeaderCallback = (Rect rect) =>
{
EditorGUI.LabelField(rect, "Item");
};
// エレメントの描画設定
itemList.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) =>
{
EditorGUI.LabelField(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), items[index].name);
};
// 要素を選択した時
itemList.onSelectCallback = (ReorderableList l) =>
{
current = items[itemList.index];
};
}
private void addItems(ItemTier item, int amount, RoR2.CharacterMaster localUser, System.Random rnd, int min, int max)
{
int amountOfItems;
if (min > max)
{
max = min;
}
if (min <= 0)
{
amountOfItems = rnd.Next(1, max + 1);
}
else
{
amountOfItems = rnd.Next(min, max + 1);
}
int itemsToGive = amount / amountOfItems;
int remainder = amount % amountOfItems;
ItemIndex itemRolled;
itemRolled = this.getRandomItem(item, localUser, rnd);
localUser.inventory.GiveItem(itemRolled, itemsToGive + remainder);
for (int i = 0; i < amountOfItems - 1; i++)
{
itemRolled = this.getRandomItem(item, localUser, rnd);
localUser.inventory.GiveItem(itemRolled, itemsToGive);
}
}
public static ItemDef[] ItemDefsFromTier(ItemTier itemTier, bool onlyUnlocked = false)
{
var itemDefs = new List <ItemDef>();
foreach (var itemDef in ItemCatalog.itemDefs)
{
if (itemDef.tier == itemTier)
{
if (!onlyUnlocked || (Run.instance && Run.instance.IsItemAvailable(itemDef.itemIndex)))
{
itemDefs.Add(itemDef);
}
else if (!Run.instance)
{
foreach (var userProfile in PlatformSystems.saveSystem.loggedInProfiles)
{
if (userProfile.HasUnlockable(itemDef.unlockableDef))
{
itemDefs.Add(itemDef);
}
continue;
}
}
}
}
return(itemDefs.ToArray());
}
private static void NotificationQueue_OnItemPickup(On.RoR2.UI.NotificationQueue.orig_OnItemPickup orig, RoR2.UI.NotificationQueue self, CharacterMaster characterMaster, ItemIndex itemIndex)
{
orig(self, characterMaster, itemIndex);
ItemTier itemTier = ItemTier.NoTier;
if (characterMaster && characterMaster.inventory)
{
int itemCount = characterMaster.inventory.GetItemCount(ExtraItemPickupItemIndex);
if (itemCount > 0 && Util.CheckRoll(ItemProcChance, characterMaster))
{
itemTier = SelectItemTier(characterMaster.inventory);
if (itemTier == ItemTier.NoTier)
{
return;
}
List <ItemIndex> currentItems = characterMaster.inventory.itemAcquisitionOrder;
ItemIndex itemIndexSelection = SelectItemFromTier(currentItems, itemTier);
if (itemIndexSelection == ItemIndex.None)
{
return;
}
var item = ItemCatalog.GetItemDef(itemIndexSelection);
characterMaster.inventory.GiveItem(itemIndexSelection);
Chat.AddMessage($"+1 to: {Language.GetString(item.nameToken)}");
}
}
}
private static ItemTier SelectItemTier(Inventory inv)
{
int itemCount = inv.GetItemCount(ExtraItemPickupItemIndex);
ItemTier itemTier = ItemTier.NoTier;
var tier1Chance = 0.8f;
var tier2Chance = 0.2f;
var tier3Chance = 0.01f;
if (itemCount > 0)
{
tier2Chance *= itemCount;
tier3Chance *= Mathf.Pow(itemCount, 2f);
WeightedSelection <ItemTier> weightedSelection = new WeightedSelection <ItemTier>(8);
if (inv.GetTotalItemCountOfTier(ItemTier.Tier1) > 0)
{
weightedSelection.AddChoice(ItemTier.Tier1, tier1Chance);
}
if (inv.GetTotalItemCountOfTier(ItemTier.Tier2) > 0)
{
weightedSelection.AddChoice(ItemTier.Tier2, tier2Chance);
}
if (inv.GetTotalItemCountOfTier(ItemTier.Tier3) > 0)
{
weightedSelection.AddChoice(ItemTier.Tier3, tier3Chance);
}
itemTier = weightedSelection.Evaluate(Run.instance.treasureRng.nextNormalizedFloat);
}
return(itemTier);
}
protected void Page_Load(object sender, EventArgs e)
{
ItemTier theTier = new ItemTier();
List <Item> products = theTier.getAllItems();
Table theTable = null;
if (products == null)
{
lblItem.Text = "No items to display.";
}
else
{
lblItem.Text = " ";
foreach (Item item in products)
{
if (item.quantity == 0)
{
theTable = outOfStockTable(item);
pnlOut.Controls.Add(theTable);
}
else
{
theTable = getItemTable(item);
pnlOut.Controls.Add(theTable);
}
}
}
}
void OnEnable()
{
_errorStyle = new GUIStyle
{
normal = { textColor = Color.red }, alignment = TextAnchor.MiddleCenter
};
_plus = Resources.Load("plus") as Texture2D;
_minus = Resources.Load("minus") as Texture2D;
_goalTiers = new ItemTier[3];
for (var i = 0; i < 3; i++)
{
_goalTiers[i] = new ItemTier();
}
_pendingAddGoal = new ItemAmount[3];
for (var i = 0; i < 3; i++)
{
_pendingAddGoal[i] = new ItemAmount(1);
}
_inventoryOnLoad = new List <ItemAmount>();
_showTiers = new bool[3] {
true, true, true
};
_fuelAmount = 0;
_previousFolder = "Assets/_project/Feed The Baby/Levels";
_levelObjectMap = Resources.Load("Level Object Data") as LevelObjectMap;
_terrainMap = Resources.Load("Terrain Data") as TerrainMap;
}
void LoadLevel(LevelData levelData)
{
_levelName = levelData.levelName;
_playerPosition = levelData.playerStartPosition;
_player.transform.position = _playerPosition;
_babyPosition = levelData.babyStartPosition;
_baby.transform.position = _babyPosition;
_inventoryOnLoad = levelData.initialInventory.ToList();
_levelTime = levelData.levelTime;
_playerStartTime = levelData.playerStartTime;
_fuelAmount = levelData.potatoAmount;
Array.Resize(ref _goalTiers, levelData.goals.Length);
for (var i = 0; i < levelData.goals.Length; i++)
{
_goalTiers[i] = ItemTier.Copy(levelData.goals[i]);
}
// Load ground and obstructions
_terrainTileMap.ClearAllTiles();
_terrainTileMap.SetTiles(levelData.terrainPositions, levelData.terrainTiles);
_obstructionsTileMap.ClearAllTiles();
_obstructionsTileMap.SetTiles(levelData.obstructionPositions, levelData.obstructionTiles);
LoadLevelObjects(levelData);
LoadHints(levelData);
}
/*
* public void PopulateTier1()
* {
* if(selector == null)
* selector = createSelector();
* setSelectorPos(0);
* //List<ItemIndex> tier1 = ItemCatalog.tier1ItemList;
* List<ItemIndex> tier1 = getAvaiableItems(ItemTier.Tier1);
*
* int line = 0;
* int itemIndex = 0;
* for (int i = 0; i < tier1.Count; i++)
* {
* ItemDef item = ItemCatalog.GetItemDef(tier1[i]);
* if (String.IsNullOrEmpty(item.pickupIconPath))
* return;
*
* //GenericNotification.gameObject
* IconCA icon = new IconCA(item, GenericNotification);
* iconsCA.Add(icon);
*
* if (i % ItemsInLine == 0)
* {
* line++;
* itemIndex = 0;
* }
* int x = (int)(-GenericNotification.GetComponent<RectTransform>().sizeDelta.x / 2 + 20 + itemIndex++ * 50);
* int y = (int)(-25 + (-line+3) * 50);
*
* icon.SetPos(x, y);
* }
* }
*
* public void PopulateTier2()
* {
* if (selector == null)
* selector = createSelector();
* setSelectorPos(0);
* //List<ItemIndex> tier2 = ItemCatalog.tier2ItemList;
* List<ItemIndex> tier2 = getAvaiableItems(ItemTier.Tier2);
*
* int line = 0;
* int itemIndex = 0;
* for (int i = 0; i < tier2.Count; i++)
* {
* ItemDef item = ItemCatalog.GetItemDef(tier2[i]);
* if (String.IsNullOrEmpty(item.pickupIconPath))
* return;
*
* //GenericNotification.gameObject
* IconCA icon = new IconCA(item, GenericNotification);
* iconsCA.Add(icon);
*
* if (i % ItemsInLine == 0)
* {
* line++;
* itemIndex = 0;
* }
* int x = (int)(-GenericNotification.GetComponent<RectTransform>().sizeDelta.x / 2 + 20 + itemIndex++ * 50);
* int y = (int)(-25 + (-line + 3) * 50);
*
* icon.SetPos(x, y);
* }
* }
*
* public void PopulateTier3()
* {
* if (selector == null)
* selector = createSelector();
* setSelectorPos(0);
* //List<ItemIndex> tier3 = ItemCatalog.tier3ItemList;
* List<ItemIndex> tier3 = getAvaiableItems(ItemTier.Tier3);
*
* int line = 0;
* int itemIndex = 0;
* for (int i = 0; i < tier3.Count; i++)
* {
* ItemDef item = ItemCatalog.GetItemDef(tier3[i]);
* if (String.IsNullOrEmpty(item.pickupIconPath))
* return;
*
* //GenericNotification.gameObject
* IconCA icon = new IconCA(item, GenericNotification);
* iconsCA.Add(icon);
*
* if (i % ItemsInLine == 0)
* {
* line++;
* itemIndex = 0;
* }
* int x = (int)(-GenericNotification.GetComponent<RectTransform>().sizeDelta.x / 2 + 20 + itemIndex++ * 50);
* int y = (int)(-25 + (-line + 3) * 50);
*
* icon.SetPos(x, y);
* }
* }
*/
private List <ItemIndex> getAvaiableItems(ItemTier itemTier)
{
List <ItemIndex> items = new List <ItemIndex>();
switch (itemTier)
{
case ItemTier.Tier1:
List <PickupIndex> tier1 = Run.instance.availableTier1DropList;
for (int i = 0; i < tier1.Count; i++)
{
items.Add(tier1[i].itemIndex);
}
break;
case ItemTier.Tier2:
List <PickupIndex> tier2 = Run.instance.availableTier2DropList;
for (int i = 0; i < tier2.Count; i++)
{
items.Add(tier2[i].itemIndex);
}
break;
case ItemTier.Tier3:
List <PickupIndex> tier3 = Run.instance.availableTier3DropList;
for (int i = 0; i < tier3.Count; i++)
{
items.Add(tier3[i].itemIndex);
}
break;
default:
break;
}
return(items);
}
protected void Page_Load(object sender, EventArgs e)
{
OrderTier theTier = new OrderTier();
List <Orders> orders = (List <Orders>)Session["Pending"];
orders = theTier.getPendingOrders();
if (orders == null)
{
lblOrd.Text = "No items to display.";
}
else
{
lblOrd.Text = " ";
Table theTable = null;
foreach (Orders order in orders)
{
orderno = order.order_no;
qty = order.qty_ordered;
}
ItemTier aTier = new ItemTier();
List <Item> items = aTier.getIncomingItems();
foreach (Item item in items)
{
theTable = getItemTable(item);
pnlOut.Controls.Add(theTable);
}
}
}
public List <PickupIndex> GetDropList(ItemTier itemTier)
{
if (itemTier == ItemTier.Tier1)
{
return(AvailableTier1DropList);
}
else if (itemTier == ItemTier.Tier2)
{
return(AvailableTier2DropList);
}
else if (itemTier == ItemTier.Tier3)
{
return(AvailableTier3DropList);
}
else if (itemTier == ItemTier.Boss)
{
return(AvailableBossDropList);
}
else if (itemTier == ItemTier.Lunar)
{
return(AvailableLunarDropList);
}
else
{
return(AvailableNormalEquipmentDropList);
}
}
public static void Init()
{
ItemTier Hbtier = ItemTier.Lunar;
if (Hbdbt.Value == false)
{
Hbtier = ItemTier.Tier3;
}
AddTokens();
HerRecluse = ScriptableObject.CreateInstance <ItemDef>();
HerRecluse.name = "HERRECLUSE";
HerRecluse.nameToken = "Her Recluse";
HerRecluse.pickupToken = HERRECLUSE_PICKUP;
HerRecluse.descriptionToken = HERRECLUSE_DESC;
HerRecluse.loreToken = HERRECLUSE_LORE;
HerRecluse.tier = Hbtier;
HerRecluse.pickupIconSprite = Her_Burden.bundle.LoadAsset <Sprite>(Hbiiv.Value + "lightishblueItemIcon");
HerRecluse.pickupModelPrefab = Her_Burden.bundle.LoadAsset <GameObject>(Hbiiv.Value + "lightishblueher_burden");
HerRecluse.canRemove = true;
HerRecluse.hidden = false;
var rules = new Items.CharacterItemDisplayRuleSet();
AddLocation(rules);
Items.Add(HerRecluse, rules);
}
void ClearLevel()
{
_levelName = "";
_player.transform.position = new Vector2(-1.5f, 0);
_baby.transform.position = new Vector3(1.5f, 0);
_inventoryOnLoad = new List <ItemAmount>();
_levelTime = 0;
_playerStartTime = 0;
for (var i = 0; i < _goalTiers.Length; i++)
{
_goalTiers[i] = new ItemTier();
}
_levelObjectsTileMap.ClearAllTiles();
var children = _levelObjectsTileMap.transform.Cast <Transform>().ToList();
foreach (var child in children)
{
DestroyImmediate(child.gameObject);
}
foreach (Transform child in _hintsContainer.transform)
{
DestroyImmediate(child.gameObject);
}
}
private static PickupIndex?GetRandomItemOfTier(ItemTier tier, PickupIndex orDefault)
{
switch (tier)
{
case ItemTier.Tier1:
return(PickRandomOf(Blacklist.AvailableTier1DropList));
case ItemTier.Tier2:
return(PickRandomOf(Blacklist.AvailableTier2DropList));
case ItemTier.Tier3:
return(PickRandomOf(Blacklist.AvailableTier3DropList));
case ItemTier.Lunar:
if (ShareSuite.LunarItemsRandomized.Value)
{
return(PickRandomOf(Blacklist.AvailableLunarDropList));
}
break;
case ItemTier.Boss:
if (ShareSuite.BossItemsRandomized.Value)
{
return(PickRandomOf(Blacklist.AvailableBossDropList));
}
break;
}
var pickupDef = PickupCatalog.GetPickupDef(orDefault);
if (Blacklist.HasItem(pickupDef.itemIndex))
{
return(null);
}
return(orDefault);
}
public static IEnumerable <PickupIndex> GetDropListForTier(ItemTier itemTier, bool addTierScrap = false)
{
IEnumerable <PickupIndex> HandleWithScrap(IEnumerable <PickupIndex> baseList, ItemDef scrap)
{
return(addTierScrap ? baseList.Append(PickupCatalog.FindPickupIndex(scrap.itemIndex)) : baseList);
}
switch (itemTier)
{
case ItemTier.Tier1:
return(HandleWithScrap(Run.instance.availableTier1DropList, RoR2Content.Items.ScrapWhite));
case ItemTier.Tier2:
return(HandleWithScrap(Run.instance.availableTier2DropList, RoR2Content.Items.ScrapGreen));
case ItemTier.Tier3:
return(HandleWithScrap(Run.instance.availableTier3DropList, RoR2Content.Items.ScrapRed));
case ItemTier.Boss:
return(HandleWithScrap(Run.instance.availableBossDropList, RoR2Content.Items.ScrapYellow));
case ItemTier.Lunar:
return(Run.instance.availableLunarItemDropList);
default:
throw new Exception($"ItemTier {itemTier} has not been handled");
}
}
private PickupIndex GetRandomTierItem(ItemTier tier)
{
List <PickupIndex> allItems;
PickupIndex item;
switch (tier)
{
case ItemTier.Tier1:
allItems = Run.instance.availableTier1DropList;
break;
case ItemTier.Tier2:
allItems = Run.instance.availableTier2DropList;
break;
case ItemTier.Tier3:
allItems = Run.instance.availableTier3DropList;
break;
default:
return(PickupIndex.none);
break;
}
int value = random.Next(0, allItems.Count);
item = allItems[value];
return(item);
}
//TODO: Add method to pick random item
private ItemDef RandomItem(ItemTier tier)
{
ItemDef[] array = (from item in ItemCatalog.allItems
where Run.instance.IsItemAvailable(item) && ItemCatalog.GetItemDef(item).tier == tier
select ItemCatalog.GetItemDef(item)).ToArray <ItemDef>();
return(array[random.Next(0, array.Length)]);
}
void GrantMonsterTeamItem(ILContext ilContext)
{
//https://github.com/risk-of-thunder/R2Wiki/wiki/Working-with-IL
System.Type type = typeof(RoR2.Artifacts.MonsterTeamGainsItemsArtifactManager);
System.Reflection.FieldInfo pattern = type.GetField("pattern", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
System.Reflection.FieldInfo currentItemIterator = type.GetField("currentItemIterator", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
ILCursor cursor = new ILCursor(ilContext);
cursor.GotoNext(
x => x.MatchLdsfld(pattern),
x => x.MatchLdsfld(currentItemIterator),
x => x.MatchDup(),
x => x.MatchLdcI4(1),
x => x.MatchAdd(),
x => x.MatchStsfld(currentItemIterator),
x => x.MatchLdsfld(pattern),
x => x.MatchLdlen(),
x => x.MatchConvI4(),
x => x.MatchRem(),
x => x.MatchLdelemI4(),
x => x.MatchStloc(0)
);
cursor.RemoveRange(11);
cursor.EmitDelegate <System.Func <ItemTier> >(() => {
int currentItemIteratorValue = int.Parse(currentItemIterator.GetValue(null).ToString());
ItemTier itemTier = patternAdjusted[currentItemIteratorValue % patternAdjusted.Length];
currentItemIterator.SetValue(null, currentItemIteratorValue + 1);
return(itemTier);
});
}
public static void Init()
{
ItemTier Hbtier = ItemTier.Lunar;
if (Hbdbt.Value == false)
{
Hbtier = ItemTier.Tier3;
}
AddTokens();
HerPanic = ScriptableObject.CreateInstance <ItemDef>();
HerPanic.name = "HERPANIC";
HerPanic.nameToken = "Her Panic";
HerPanic.pickupToken = HERPANIC_PICKUP;
HerPanic.descriptionToken = HERPANIC_DESC;
HerPanic.loreToken = HERPANIC_LORE;
HerPanic.tier = Hbtier;
HerPanic.pickupIconSprite = Her_Burden.bundle.LoadAsset <Sprite>(Hbiiv.Value + "violetItemIcon");
HerPanic.pickupModelPrefab = Her_Burden.bundle.LoadAsset <GameObject>(Hbiiv.Value + "violether_burden");
HerPanic.canRemove = true;
HerPanic.hidden = false;
var rules = new Items.CharacterItemDisplayRuleSet();
AddLocation(rules);
Items.Add(HerPanic, rules);
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
Item item = new Item();
ItemTier theTier = new ItemTier();
bool exists = theTier.itemExists(int.Parse(txtSKU.Text));
if (exists == true)
{
Response.Write("<script>alert('This SKU already exists')</script>");
//Response.Redirect("ProductList.aspx");
}
else
{
item.SKU = int.Parse(txtSKU.Text);
item.album_title = txtAlbum.Text;
item.artist = txtArtist.Text;
item.price = decimal.Parse(txtPrice.Text);
item.quantity = int.Parse(txtQty.Text);
Stream fs = flUpload.PostedFile.InputStream;
BinaryReader br = new BinaryReader(fs);
byte[] theImage = br.ReadBytes((Int32)fs.Length);
item.cover = theImage;
Session["NewItemInfo"] = item;
Response.Redirect("ConfirmAdd.aspx");
}
}
public static string TierToHexString(ItemTier tier)
{
switch (tier)
{
case ItemTier.Tier1:
return(ColorCatalog.GetColorHexString(ColorCatalog.ColorIndex.Tier1Item));
case ItemTier.Tier2:
return(ColorCatalog.GetColorHexString(ColorCatalog.ColorIndex.Tier2Item));
case ItemTier.Tier3:
return(ColorCatalog.GetColorHexString(ColorCatalog.ColorIndex.Tier3Item));
case ItemTier.Lunar:
return(ColorCatalog.GetColorHexString(ColorCatalog.ColorIndex.LunarItem));
case ItemTier.Boss:
return(ColorCatalog.GetColorHexString(ColorCatalog.ColorIndex.BossItem));
case ItemTier.NoTier:
return(ColorCatalog.GetColorHexString(ColorCatalog.ColorIndex.Unaffordable));
default:
return("FFF");
}
}
public static List <ItemIndex> GetDefaultDropList(ItemTier itemTier)
{
if (itemTier == ItemTier.NoTier)
{
return(null);
}
var list = new List <ItemIndex>();
for (var itemIndex = ItemIndex.Syringe; itemIndex < ItemIndex.Count; itemIndex++)
{
if (!Run.instance.availableItems.HasItem(itemIndex))
{
continue;
}
if (ItemCatalog.GetItemDef(itemIndex).tier == itemTier)
{
list.Add(itemIndex);
}
}
list.AddRange(AdditionalTierItems[itemTier]);
return(list);
}
public void SpawnItem(ItemTier tier)
{
ItemSettings settings = m_ItemTierSettings[tier];
int amountOfMachinesRequired = Random.Range(settings.MinAmountMachines, settings.MaxAmountMachines + 1);
List <int> machineIndexList = new List <int> {
1, 2, 3, 4
};
for (int i = 0; i < 4 - amountOfMachinesRequired; ++i)
{
int randIndex = Random.Range(0, machineIndexList.Count);
int machineIndex = machineIndexList[randIndex];
machineIndexList.RemoveAt(randIndex);
}
ItemRuntimeData runtimeData;
runtimeData.MachineOrderList = machineIndexList;
// Spawn the actual item
Spawn(runtimeData, settings);
}
public static ItemIndex GetScrapIndex(ItemTier itemTier)
{
if (ScrapItems.ContainsKey(itemTier))
{
return(ScrapItems[itemTier]);
}
return(ItemIndex.None);
}
private void AddItemType(ItemTier itemTier)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.ArenaMissionController::AddItemType(RoR2.ItemTier)' called on client");
return;
}
List <PickupIndex> list;
switch (itemTier)
{
case ItemTier.Tier1:
list = this.availableTier1DropList;
break;
case ItemTier.Tier2:
list = this.availableTier2DropList;
break;
case ItemTier.Tier3:
list = this.availableTier3DropList;
break;
default:
return;
}
if (list.Count == 0)
{
Debug.LogErrorFormat("No items remaining in arena for tier {0}. Aborting.", new object[]
{
itemTier
});
return;
}
PickupIndex pickupIndex = this.rng.NextElementUniform <PickupIndex>(list);
list.Remove(pickupIndex);
this.syncActivePickups.Add(pickupIndex.value);
for (int i = 0; i < this.pickupDisplays.Length; i++)
{
PickupDisplay pickupDisplay = this.pickupDisplays[i];
if (!pickupDisplay.enabled)
{
pickupDisplay.enabled = true;
pickupDisplay.SetPickupIndex(pickupIndex, false);
break;
}
}
PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
Chat.SendBroadcastChat(new Chat.PlayerPickupChatMessage
{
baseToken = "ARENA_ADD_ITEM",
pickupToken = pickupDef.nameToken,
pickupColor = pickupDef.baseColor
});
}
public static void RemoveFromDefaultByTier(ItemTier itemTier, params ItemIndex[] items)
{
if (itemTier == ItemTier.NoTier)
{
return;
}
AdditionalTierItems[itemTier].ExceptWith(items);
}
public static void AddToDefaultByTier(ItemTier itemTier, params ItemIndex[] items)
{
if (itemTier == ItemTier.NoTier)
{
return;
}
AdditionalTierItems[itemTier].UnionWith(items);
}
public void ArrangeArray()
{
itemTier = new List<ItemTier>();
foreach(ItemTierTemp temp in itemTierTemp)
{
if(temp.killStreak >= 0)//new tier
{
ItemTier newItemTier = new ItemTier();
newItemTier.killStreak = temp.killStreak;
newItemTier.points = temp.points;
newItemTier.chanceToSpawn = temp.chanceToSpawn;
newItemTier.itens = new List<ItemPercent>();
itemTier.Add(newItemTier);
}
ItemPercent itemPercent = new ItemPercent();
itemPercent.name = temp.name;
itemPercent.percent = temp.percent;
itemTier[itemTier.Count - 1].itens.Add(itemPercent);
}
}
