public UpgradeEntry RollEntryFromSubList(UpgradeEntry[] list, NetworkRandom nr, int min, DateTime date, ref string log, float linkRerollChance) { UpgradeEntry r = null; CalculateLimit(list, date); float rand = nr.Float(min < 0 ? 0f : list[min].RandomLimit, 1f); for (int i = 0; i < list.Length; i++) { UpgradeEntry u = list[i]; if (rand <= u.RandomLimit && CheckUpgradeCond(u, date)) { r = u; break; } } log += $" -> {r.ID} ({rand}, {min}, {list[0].Name})"; if (r.ListLink && nr.Float(0f, 1f) <= linkRerollChance) { UpgradeEntry li = RollEntryFromMatchingSubList(r.ID, nr, date, ref log, linkRerollChance); if (li != null) { r = li; } } return(r); }
private static bool CheckUpgradeCond(UpgradeEntry u, DateTime d) { if (u.MinDate > d) { return(false); } return(true); }
/// <summary> /// Fills the entry with the data of the character. /// </summary> /// <param name="statsCon"></param> public void FillData(int index, UpgradeEntry upgrade, bool done, int totalScrap, int totalMoney) { entryName.text = upgrade.entryName; icon.color = upgrade.repColor; upgradeType.text = upgrade.item.weaponType.ToString(); this.index = index; this.upgrade = upgrade; this.done = done; affordable = (!done && totalMoney >= upgrade.cost && totalScrap >= upgrade.scrap); doneIcon.enabled = done; }
private void SetupDevelopInfo() { if (entryList.GetEntry() == null) { upgradeName.text = ""; itemIcon.sprite = null; costMoney.text = "Cost:"; costScrap.text = "Scrap:"; relatedItem.text = "Item:"; invPwrText.text = ""; invRangeText.text = ""; invHitText.text = ""; invCritText.text = ""; invReqText.text = ""; return; } UpgradeEntry upgrade = entryList.GetEntry().upgrade; upgradeName.text = upgrade.entryName; relatedItem.text = "Item: " + upgrade.item.entryName; itemIcon.sprite = upgrade.item.icon; itemIcon.color = upgrade.repColor; if (entryList.GetEntry().done) { costMoney.text = ""; costScrap.text = ""; alreadyResearched.SetActive(true); } else { costMoney.text = "Cost: " + upgrade.cost; costScrap.text = "Scrap: " + upgrade.scrap; alreadyResearched.SetActive(false); } for (int i = 0; i < levelStars.Length; i++) { levelStars[i].enabled = i < upgrade.rank; } invPwrText.text = "Power: " + upgrade.item.power; invRangeText.text = "Range: " + upgrade.item.range.ToString(); invHitText.text = "Hit Rate: " + upgrade.item.hitRate; invCritText.text = "Crit Rate: " + upgrade.item.critRate; invReqText.text = "Req: " + upgrade.item.skillReq.ToString(); return; }
public UpgradeEntry RollEntryFromMatchingSubList(string baseid, NetworkRandom nr, DateTime date, ref string log, float linkRerollChance) { UpgradeEntry[] sublist = GetUpgradeArrayAndOffset(baseid, out int min); UpgradeEntry r = null; if (sublist != null) { r = RollEntryFromSubList(sublist, nr, min, date, ref log, linkRerollChance); } else { log += " no sublist found"; } return(r); }
public UpgradeEntry[] GetUpgradeArrayAndOffset(string comp, out int min) { foreach (UpgradeEntry[] list in Upgrades) { for (int i = 0; i < list.Length; i++) { UpgradeEntry u = list[i]; if (u.ID.Equals(comp) && !u.ListLink) { min = (u.AllowDowngrade || this.AllowDowngrade) ? -1 : i; return(list); } } } min = -1; return(null); }
public override void CopyValues(ScrObjLibraryEntry other) { base.CopyValues(other); UpgradeEntry up = (UpgradeEntry)other; item = up.item; type = up.type; rank = up.rank; cost = up.cost; scrap = up.scrap; power = up.power; hit = up.hit; crit = up.crit; charges = up.charges; costValue = up.costValue; }
protected override void DrawContentWindow() { UpgradeEntry upgradeEntry = (UpgradeEntry)entryValues; upgradeEntry.entryName = EditorGUILayout.TextField("Name", upgradeEntry.entryName); upgradeEntry.type = (UpgradeType)EditorGUILayout.EnumPopup("Upgrade Type", upgradeEntry.type); upgradeEntry.item = (ItemEntry)EditorGUILayout.ObjectField("Related item", upgradeEntry.item, typeof(ItemEntry), false); upgradeEntry.rank = Mathf.Clamp(EditorGUILayout.IntField("Upgrade Rank", upgradeEntry.rank), 1, 5); upgradeEntry.cost = EditorGUILayout.IntField("Money Cost", upgradeEntry.cost); upgradeEntry.scrap = EditorGUILayout.IntField("Scrap Cost", upgradeEntry.scrap); GUILayout.Space(10); if (upgradeEntry.type == UpgradeType.UPGRADE) { upgradeEntry.costValue = EditorGUILayout.IntField("Value increase", upgradeEntry.costValue); GUILayout.Label("Improvements", EditorStyles.boldLabel); upgradeEntry.power = EditorGUILayout.IntField("Power", upgradeEntry.power); upgradeEntry.hit = EditorGUILayout.IntField("Hit Rate", upgradeEntry.hit); upgradeEntry.crit = EditorGUILayout.IntField("Crit Rate", upgradeEntry.crit); upgradeEntry.charges = EditorGUILayout.IntField("Max Charges", upgradeEntry.charges); } }
/// <summary> /// Constructor /// </summary> /// <param name="entries"></param> /// <param name="container"></param> public UpgradeEditorWindow(ScrObjLibraryVariable entries, UpgradeEntry container) { entryLibrary = entries; entryValues = container; LoadLibrary(); }
void _optimizer_EvaluateUpgradeCompleted(object sender, EvaluateUpgradeCompletedEventArgs e) { switch (currentOperation) { case AsyncOperation.BuildUpgradeList: upgradeListEnumerator.Current.Value += e.UpgradeValue * CurrentBatchCharacter.Weight; upgradeListEnumerator.Current.ValueList.Add(e.UpgradeValue); if (upgradeListEnumerator.MoveNext()) { EvaluateUpgradeCurrentBatchCharacter(false); } else { do { batchIndex++; } while (batchIndex < BatchCharacterList.Count && CurrentBatchCharacter.Character == null); if (batchIndex < BatchCharacterList.Count) { upgradeListEnumerator = GetUpgradeListEnumerator(); upgradeListEnumerator.MoveNext(); EvaluateUpgradeCurrentBatchCharacter(true); } else { currentOperation = AsyncOperation.None; UpdateStatusLabel(); if (OperationCompleted != null) { OperationCompleted(this, EventArgs.Empty); } float totalValue = 0f; foreach (BatchCharacter batchCharacter in BatchCharacterList) { if (batchCharacter.Character != null) { totalValue += batchCharacter.Weight; } } Dictionary<CharacterSlot, List<ComparisonCalculationUpgrades>> upgrades = new Dictionary<CharacterSlot, List<ComparisonCalculationUpgrades>>(); foreach (var kvp in upgradeList) { Dictionary<string, UpgradeEntry> filtered = new Dictionary<string, UpgradeEntry>(); foreach (UpgradeEntry entry in kvp.Value.Values) { UpgradeEntry existingEntry; filtered.TryGetValue(entry.Item.SuffixId, out existingEntry); if (entry.Value > 0 && (existingEntry == null || entry.Value > existingEntry.Value)) { filtered[entry.Item.SuffixId] = entry; } } upgrades[kvp.Key] = new List<ComparisonCalculationUpgrades>(); foreach (UpgradeEntry entry in filtered.Values) { ComparisonCalculationUpgrades itemCalc = new ComparisonCalculationUpgrades(); itemCalc.ItemInstance = entry.Item; itemCalc.CharacterItems = null; itemCalc.Name = entry.Item.Name; itemCalc.Equipped = false; itemCalc.OverallPoints = entry.Value / totalValue; itemCalc.SubPoints = entry.ValueList.ToArray(); upgrades[kvp.Key].Add(itemCalc); } } List<string> customSubpoints = new List<string>(); foreach (BatchCharacter batchCharacter in BatchCharacterList) { customSubpoints.Add(batchCharacter.Name); } Upgrades = upgrades; CustomSubpoints = customSubpoints.ToArray(); if (UpgradeListCompleted != null) { UpgradeListCompleted(this, EventArgs.Empty); } } } break; case AsyncOperation.BuildProgressiveUpgradeList: if (e.Cancelled || e.Error != null) { currentOperation = AsyncOperation.None; UpdateStatusLabel(); if (OperationCompleted != null) { OperationCompleted(this, EventArgs.Empty); } break; } CharacterSlot slot = Character.GetCharacterSlotByItemSlot(optimizedItemInstance.Slot); Dictionary<string, UpgradeEntry> map; if (!upgradeList.TryGetValue(slot, out map)) { map = new Dictionary<string, UpgradeEntry>(); upgradeList[slot] = map; } string key = optimizedItemInstance.SuffixId; UpgradeEntry upgradeEntry; if (!map.TryGetValue(key, out upgradeEntry)) { upgradeEntry = new UpgradeEntry(); upgradeEntry.Item = optimizedItemInstance; map[key] = upgradeEntry; } if (e.UpgradeValue > 0) { // make item restrictions based on best character itemGenerator.AddItemRestrictions(e.Upgrade.CharacterItems, workingCharacter.CurrentCalculations.IncludeOffHandInCalculations(workingCharacter)); upgradeEntry.Value += e.UpgradeValue * CurrentBatchCharacter.Weight; upgradeEntry.ValueList.Add(e.UpgradeValue); } else { // make item restrictions based on best character without using the item itemGenerator.AddItemRestrictions(workingCharacter); upgradeEntry.ValueList.Add(0.0f); } // move to next character do { batchIndex++; } while (batchIndex < BatchCharacterList.Count && CurrentBatchCharacter.Character == null); if (batchIndex < BatchCharacterList.Count) { // we made item restrictions, first we have to optimize character without the item int _thoroughness = Thoroughness; workingCharacter = CurrentBatchCharacter.Character.Clone(); // regularize character with current item restrictions itemGenerator.RegularizeCharacter(workingCharacter); optimizer.InitializeItemCache(workingCharacter, CurrentBatchCharacter.Model, itemGenerator); optimizer.OptimizeCharacterAsync(workingCharacter, _thoroughness, true); } else { // we finished all characters for this item // move to next item itemIndex++; if (itemIndex < itemList.Length) { batchIndex = 0; upgradeListPhase = 0; int _thoroughness = Thoroughness; // we have to reinitialize item generator because of the restrictions we made //CreateBatchItemGenerator(); itemGenerator.RestoreAvailabilityInformation(); optimizer.InitializeItemCache(CurrentBatchCharacter.Character, CurrentBatchCharacter.Model, itemGenerator); workingCharacter = CurrentBatchCharacter.Character; optimizer.ComputeUpgradesAsync(CurrentBatchCharacter.Character, _thoroughness, itemList[itemIndex]); } else { // we're done WrapUpProgressiveUpgradeList(); } } break; } }
void _optimizer_ComputeUpgradesCompleted(object sender, ComputeUpgradesCompletedEventArgs e) { switch (currentOperation) { case AsyncOperation.BuildUpgradeList: if (e.Cancelled || e.Error != null) { currentOperation = AsyncOperation.None; UpdateStatusLabel(); if (OperationCompleted != null) { OperationCompleted(this, EventArgs.Empty); } break; } if (upgradeListPhase == 0) { foreach (KeyValuePair<CharacterSlot, List<ComparisonCalculationUpgrades>> kvp in e.Upgrades) { Dictionary<string, UpgradeEntry> map; if (!upgradeList.TryGetValue(kvp.Key, out map)) { map = new Dictionary<string, UpgradeEntry>(); upgradeList[kvp.Key] = map; } foreach (ComparisonCalculationBase comp in kvp.Value) { string key = comp.ItemInstance.GemmedId; UpgradeEntry upgradeEntry; if (!map.TryGetValue(key, out upgradeEntry)) { upgradeEntry = new UpgradeEntry(); upgradeEntry.Item = comp.ItemInstance; map[key] = upgradeEntry; } } } do { batchIndex++; } while (batchIndex < BatchCharacterList.Count && CurrentBatchCharacter.Character == null); if (batchIndex < BatchCharacterList.Count) { ComputeUpgradesCurrentBatchCharacter(); } else { upgradeListPhase = 1; batchIndex = 0; upgradeListEnumerator = GetUpgradeListEnumerator(); if (upgradeListEnumerator.MoveNext()) { EvaluateUpgradeCurrentBatchCharacter(true); } else { // upgrade list is empty, abort currentOperation = AsyncOperation.None; UpdateStatusLabel(); if (OperationCompleted != null) { OperationCompleted(this, EventArgs.Empty); } break; } } } break; case AsyncOperation.BuildProgressiveUpgradeList: { if (e.Cancelled || e.Error != null) { currentOperation = AsyncOperation.None; UpdateStatusLabel(); if (OperationCompleted != null) { OperationCompleted(this, EventArgs.Empty); } break; } ComparisonCalculationUpgrades bestComp = null; foreach (KeyValuePair<CharacterSlot, List<ComparisonCalculationUpgrades>> kvp in e.Upgrades) { if (kvp.Value.Count > 0 && kvp.Value[0].OverallPoints > (bestComp != null ? bestComp.OverallPoints : 0)) { bestComp = kvp.Value[0]; } } SuffixItem item = itemList[itemIndex]; CharacterSlot slot = Character.GetCharacterSlotByItemSlot(item.Item.Slot); Dictionary<string, UpgradeEntry> map; if (!upgradeList.TryGetValue(slot, out map)) { map = new Dictionary<string, UpgradeEntry>(); upgradeList[slot] = map; } string key = item.SuffixId; UpgradeEntry upgradeEntry; if (!map.TryGetValue(key, out upgradeEntry)) { upgradeEntry = new UpgradeEntry(); map[key] = upgradeEntry; } if (bestComp != null) { upgradeListPhase = 1; // item was used, from now on we do evaluate upgrade on specific item instance only optimizedItemInstance = bestComp.ItemInstance; // make item restrictions based on best character itemGenerator.AddItemRestrictions(bestComp.CharacterItems, workingCharacter.CurrentCalculations.IncludeOffHandInCalculations(workingCharacter)); upgradeEntry.Item = bestComp.ItemInstance; upgradeEntry.Value += bestComp.OverallPoints * CurrentBatchCharacter.Weight; upgradeEntry.ValueList.Add(bestComp.OverallPoints); } else { // make item restrictions based on best character without using the item itemGenerator.AddItemRestrictions(workingCharacter); // with the addition of support for multiples of the same item the semantics of this changes // we now treat the upgrade as completely separate item, so no need to restrict to it if it is used // as that one is a separate instance if (upgradeListPhase == 1) { upgradeEntry.Item = optimizedItemInstance; } upgradeEntry.ValueList.Add(0.0f); } // move to next character do { batchIndex++; } while (batchIndex < BatchCharacterList.Count && CurrentBatchCharacter.Character == null); if (batchIndex < BatchCharacterList.Count) { if (upgradeListPhase == 0) { // so far we haven't made any changes yet // we're working under assumption that the starting batch is valid i.e. an item will have the same gemming in all characters int _thoroughness = Thoroughness; workingCharacter = CurrentBatchCharacter.Character; optimizer.InitializeItemCache(workingCharacter, CurrentBatchCharacter.Model, itemGenerator); optimizer.ComputeUpgradesAsync(workingCharacter, _thoroughness, itemList[itemIndex]); } else { // we made item restrictions, first we have to optimize character without the item int _thoroughness = Thoroughness; workingCharacter = CurrentBatchCharacter.Character.Clone(); // regularize character with current item restrictions itemGenerator.RegularizeCharacter(workingCharacter); optimizer.InitializeItemCache(workingCharacter, CurrentBatchCharacter.Model, itemGenerator); if (ConsiderMultipleNewItems) { optimizer.ComputeUpgradesAsync(workingCharacter, _thoroughness, itemList[itemIndex]); } else { optimizer.OptimizeCharacterAsync(workingCharacter, _thoroughness, true); } } } else { // we finished all characters for this item // move to next item itemIndex++; if (itemIndex < itemList.Length) { batchIndex = 0; upgradeListPhase = 0; int _thoroughness = Thoroughness; // we have to reinitialize item generator because of the restrictions we made //CreateBatchItemGenerator(); itemGenerator.RestoreAvailabilityInformation(); optimizer.InitializeItemCache(CurrentBatchCharacter.Character, CurrentBatchCharacter.Model, itemGenerator); workingCharacter = CurrentBatchCharacter.Character; optimizer.ComputeUpgradesAsync(CurrentBatchCharacter.Character, _thoroughness, itemList[itemIndex]); } else { // we're done WrapUpProgressiveUpgradeList(); } } } break; } }
private void SetupUpgradeInfo() { if (entryList.GetEntry(0) == null) { upgradeName.text = ""; itemIcon.sprite = null; costMoney.text = "Cost:"; costScrap.text = "Scrap:"; relatedItem.text = "Item:"; for (int i = 0; i < levelStars.Length; i++) { levelStars[i].enabled = false; } pwrText.gameObject.SetActive(false); hitText.gameObject.SetActive(false); critText.gameObject.SetActive(false); chargesText.gameObject.SetActive(false); costValueText.gameObject.SetActive(false); return; } UpgradeEntry upgrade = entryList.GetEntry().upgrade; upgradeName.text = upgrade.entryName; InventoryTuple tuple = new InventoryTuple(upgrade.item); tuple.UpdateUpgrades(playerData.upgrader); relatedItem.text = "Item: " + tuple.entryName; itemIcon.sprite = tuple.icon; itemIcon.color = upgrade.repColor; if (entryList.GetEntry().done) { costMoney.text = ""; costScrap.text = ""; alreadyResearched.SetActive(true); pwrText.text = "Power: " + tuple.power; hitText.text = "Hit Rate: " + tuple.hitRate; critText.text = "Crit Rate: " + tuple.critRate; chargesText.text = "Max Charges: " + tuple.maxCharge; costValueText.text = "Item Value: " + tuple.cost; } else { costMoney.text = "Cost: " + upgrade.cost; costScrap.text = "Scrap: " + upgrade.scrap; alreadyResearched.SetActive(false); pwrText.text = "Power: " + tuple.power + " -> " + (tuple.power + upgrade.power); hitText.text = "Hit Rate: " + tuple.hitRate + " -> " + (tuple.hitRate + upgrade.hit); critText.text = "Crit Rate: " + tuple.critRate + " -> " + (tuple.critRate + upgrade.crit); chargesText.text = "Max Charges: " + tuple.maxCharge + " -> " + (tuple.maxCharge + upgrade.charges); costValueText.text = "Item Value: " + tuple.cost + " -> " + (tuple.cost + upgrade.costValue); } for (int i = 0; i < levelStars.Length; i++) { levelStars[i].enabled = i < upgrade.rank; } pwrText.gameObject.SetActive(upgrade.power != 0); hitText.gameObject.SetActive(upgrade.hit != 0); critText.gameObject.SetActive(upgrade.crit != 0); chargesText.gameObject.SetActive(upgrade.charges != 0); costValueText.gameObject.SetActive(upgrade.costValue != 0); }
void _optimizer_ComputeUpgradesCompleted(object sender, ComputeUpgradesCompletedEventArgs e) { switch (currentOperation) { case AsyncOperation.BuildUpgradeList: if (e.Cancelled || e.Error != null) { currentOperation = AsyncOperation.None; buttonCancel.Enabled = false; statusLabel.Text = ""; statusProgressBar.Value = 0; break; } if (upgradeListPhase == 0) { foreach (KeyValuePair <Character.CharacterSlot, List <ComparisonCalculationBase> > kvp in e.Upgrades) { Dictionary <string, UpgradeEntry> map; if (!upgradeList.TryGetValue(kvp.Key, out map)) { map = new Dictionary <string, UpgradeEntry>(); upgradeList[kvp.Key] = map; } foreach (ComparisonCalculationBase comp in kvp.Value) { string key = comp.Item.GemmedId + "." + ((comp.Enchant == null) ? "0" : comp.Enchant.Id.ToString()); UpgradeEntry upgradeEntry; if (!map.TryGetValue(key, out upgradeEntry)) { upgradeEntry = new UpgradeEntry(); upgradeEntry.Item = comp.Item; upgradeEntry.Enchant = comp.Enchant; map[key] = upgradeEntry; } } } do { batchIndex++; } while (batchIndex < BatchCharacterList.Count && CurrentBatchCharacter.Character == null); if (batchIndex < BatchCharacterList.Count) { ComputeUpgradesCurrentBatchCharacter(); } else { upgradeListPhase = 1; batchIndex = 0; upgradeListEnumerator = GetUpgradeListEnumerator(); if (upgradeListEnumerator.MoveNext()) { EvaluateUpgradeCurrentBatchCharacter(true); } else { // upgrade list is empty, abort currentOperation = AsyncOperation.None; buttonCancel.Enabled = false; statusLabel.Text = ""; statusProgressBar.Value = 0; break; } } } break; } }
public UpgradeItem(UpgradeEntry entry, bool researched = false) { upgrade = entry; this.researched = researched; }
/// <summary> /// Does the actual loading of all the data and puts it into the game. /// </summary> public void Load() { if (saveFileData == null) { Debug.LogError("There's no file to read!"); return; } // Read simple data currentTotalDays.value = simpleTotalDays[saveIndex.value].value; currentPlayTime.value = simplePlayTimes[saveIndex.value].value; // Read data in save file SaveData loadedData = saveFileData.saveFiles[saveIndex.value]; currentMoney.value = loadedData.money; currentScrap.value = loadedData.scrap; // Read map data currentMission.value = missionLibrary.GetEntry(loadedData.mapData.missionString); mapIndex.value = loadedData.mapData.mapIndex; loadMapID.value = (currentMission.value != null) ? ((MissionEntry)currentMission.value).maps[mapIndex.value].uuid : ""; squad1.values.Clear(); for (int i = 0; i < loadedData.mapData.squad1.Count; i++) { squad1.values.Add(new PrepCharacter(loadedData.mapData.squad1[i])); } squad2.values.Clear(); for (int i = 0; i < loadedData.mapData.squad2.Count; i++) { squad2.values.Add(new PrepCharacter(loadedData.mapData.squad2[i])); } // Read player data playerData.ResetData(); for (int i = 0; i < loadedData.upgrade.Count; i++) { UpgradeEntry upgrade = (UpgradeEntry)upgradeLibrary.GetEntry(loadedData.upgrade[i].id); playerData.upgrader.upgrades.Add(new UpgradeItem(upgrade, loadedData.upgrade[i].researched)); } for (int i = 0; i < loadedData.characters.Count; i++) { CharEntry cStats = (CharEntry)characterLibrary.GetEntry(loadedData.characters[i].id); ClassEntry cClass = (ClassEntry)classLibrary.GetEntry(loadedData.characters[i].currentClass); playerData.stats.Add(new StatsContainer(loadedData.characters[i], cStats, cClass)); playerData.inventory.Add(new InventoryContainer(itemLibrary, loadedData.characters[i], playerData.upgrader)); playerData.skills.Add(new SkillsContainer(skillLibrary, loadedData.characters[i])); playerData.baseInfo.Add(new SupportContainer(loadedData.characters[i])); } for (int i = 0; i < loadedData.items.Count; i++) { ItemEntry item = (ItemEntry)itemLibrary.GetEntry(loadedData.items[i].id); playerData.items.Add(new InventoryItem(item, loadedData.items[i].charges)); } for (int i = 0; i < loadedData.missions.Count; i++) { playerData.missions.Add(new MissionProgress(loadedData.missions[i].id, loadedData.missions[i].cleared)); } playerData.upgrader.CalculateResearch(); Debug.Log("Successfully loaded the save data!"); loadFinishedEvent.Invoke(); }