2134 lines
85 KiB
C#
2134 lines
85 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using KernelPanic.Core;
|
|
using KernelPanic.Data;
|
|
using KernelPanic.Meta;
|
|
using KernelPanic.Run;
|
|
using UnityEngine;
|
|
using UnityEngine.TextCore.Text;
|
|
using UnityEngine.UIElements;
|
|
|
|
namespace KernelPanic.UI
|
|
{
|
|
/// <summary>
|
|
/// Renders Collection tabs and the pushed read-only card subview.
|
|
/// </summary>
|
|
[Serializable]
|
|
public sealed class CollectionScreenController
|
|
{
|
|
private readonly List<VisualElement> _rows = new();
|
|
|
|
private VisualElement _list;
|
|
private ScrollView _detailScroll;
|
|
private VisualElement _detail;
|
|
private VisualElement _root;
|
|
private VisualElement _packageEquipOverlay;
|
|
private VisualElement _packageEquipDialog;
|
|
private FontAsset _monospaceFont;
|
|
private LanguageDeckDatabase _languageDeckDatabase;
|
|
private CardDatabase _cardDatabase;
|
|
private PlayerCollection _playerCollection;
|
|
private PackageDatabase _packageDatabase;
|
|
private PackageLoadout _packageLoadout;
|
|
private Action _packageLoadoutChanged;
|
|
private Func<SaveData> _getSaveData;
|
|
private Func<OwnedPackageInstance, PackageUpgradeResult> _tryUpgradePackage;
|
|
private Func<OwnedPackageInstance, PackageScrapResult> _tryScrapPackage;
|
|
private Func<DistroDefinition, int> _getMergesBalance;
|
|
private Func<DistroDefinition, VersionUpgradeResult> _tryUpgradeUnit;
|
|
private IReadOnlyList<DistroDefinition> _units = Array.Empty<DistroDefinition>();
|
|
private IReadOnlyList<LanguageCatalogEntry> _languages = LanguageCatalog.All;
|
|
private IReadOnlyList<CardEntry> _cards = Array.Empty<CardEntry>();
|
|
private CollectionMode _mode;
|
|
private CollectionMode _returnMode;
|
|
private UnitDetailTab _unitDetailTab = UnitDetailTab.Overview;
|
|
private PackageSlot? _packagePickerSlot;
|
|
private bool _unitDetailReturnsToOverview = true;
|
|
private DistroDefinition _equipWindowUnit;
|
|
private PackageSlot _equipWindowSlot;
|
|
private int _selectedUnitIndex;
|
|
private int _selectedLanguageIndex;
|
|
private int _selectedCardIndex;
|
|
private string _emptyCardMessage = "no cards installed";
|
|
private string _pendingScrapPackageId;
|
|
private string _packageSlotNotice;
|
|
private IReadOnlyList<OwnedPackageInstance> _packageInventory = Array.Empty<OwnedPackageInstance>();
|
|
private int _selectedPackageInventoryIndex;
|
|
private PackageSlot? _packageInventoryFilter;
|
|
|
|
public event Action ViewChanged;
|
|
|
|
public void Bind(VisualElement root, FontAsset artFont, LanguageDeckDatabase deckDatabase, CardDatabase cardsDatabase, PlayerCollection collection, Func<DistroDefinition, int> getMergesBalance = null, Func<DistroDefinition, VersionUpgradeResult> tryUpgradeUnit = null, PackageDatabase packageDatabase = null, PackageLoadout packageLoadout = null, Action packageLoadoutChanged = null, Func<SaveData> getSaveData = null, Func<OwnedPackageInstance, PackageUpgradeResult> tryUpgradePackage = null, Func<OwnedPackageInstance, PackageScrapResult> tryScrapPackage = null)
|
|
{
|
|
_monospaceFont = artFont;
|
|
_root = root;
|
|
_languageDeckDatabase = deckDatabase;
|
|
_cardDatabase = cardsDatabase;
|
|
_playerCollection = collection;
|
|
_getMergesBalance = getMergesBalance;
|
|
_tryUpgradeUnit = tryUpgradeUnit;
|
|
_packageDatabase = packageDatabase;
|
|
_packageLoadout = packageLoadout;
|
|
_packageLoadoutChanged = packageLoadoutChanged;
|
|
_getSaveData = getSaveData;
|
|
_tryUpgradePackage = tryUpgradePackage;
|
|
_tryScrapPackage = tryScrapPackage;
|
|
_list = root.Q<VisualElement>("CollectionList");
|
|
_detailScroll = root.Q<ScrollView>("CollectionDetail");
|
|
_detail = _detailScroll?.contentContainer;
|
|
EnsurePackageEquipOverlay();
|
|
}
|
|
|
|
public bool IsCardSubview => _mode == CollectionMode.CardSubview;
|
|
public bool IsUnitDetail => _mode == CollectionMode.UnitDetail;
|
|
public bool IsPushedSubview => _mode == CollectionMode.UnitDetail || _mode == CollectionMode.CardSubview;
|
|
|
|
public string CurrentTitle { get; private set; } = "$ ls ~/collection";
|
|
public string CurrentHint { get; private set; } = "[esc] back [left/right] tabs [tab] tabs [arrows] navigate [enter] select";
|
|
|
|
public void RefreshUnits(IReadOnlyList<DistroDefinition> ownedUnits)
|
|
{
|
|
_units = ownedUnits ?? Array.Empty<DistroDefinition>();
|
|
ShowUnits();
|
|
}
|
|
|
|
public void ShowUnits()
|
|
{
|
|
ClosePackageEquipWindow();
|
|
_mode = CollectionMode.Units;
|
|
CurrentTitle = "$ ls ~/collection";
|
|
CurrentHint = "[esc] back [left/right] tabs [tab] tabs [arrows] navigate [enter] select";
|
|
RenderUnits();
|
|
ViewChanged?.Invoke();
|
|
}
|
|
|
|
public void ShowLanguages()
|
|
{
|
|
ClosePackageEquipWindow();
|
|
_mode = CollectionMode.Languages;
|
|
CurrentTitle = "$ ls ~/collection/languages";
|
|
CurrentHint = "[esc] back [left/right] tabs [tab] tabs [arrows] navigate [enter] select";
|
|
RenderLanguages();
|
|
ViewChanged?.Invoke();
|
|
}
|
|
|
|
public void ShowPackages()
|
|
{
|
|
ClosePackageEquipWindow();
|
|
_mode = CollectionMode.Packages;
|
|
_pendingScrapPackageId = null;
|
|
CurrentTitle = "$ ls ~/packages";
|
|
CurrentHint = "[esc] back [left/right] tabs [tab] tabs [arrows] navigate [click] upgrade/scrap";
|
|
RenderPackages();
|
|
ViewChanged?.Invoke();
|
|
}
|
|
|
|
public bool BackFromSubview()
|
|
{
|
|
if (_packageEquipOverlay != null && !_packageEquipOverlay.ClassListContains("hidden"))
|
|
{
|
|
ClosePackageEquipWindow();
|
|
return true;
|
|
}
|
|
|
|
if (_mode == CollectionMode.UnitDetail)
|
|
{
|
|
_packagePickerSlot = null;
|
|
_packageSlotNotice = null;
|
|
if (_unitDetailReturnsToOverview)
|
|
{
|
|
ShowUnits();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (_mode != CollectionMode.CardSubview)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (_returnMode == CollectionMode.Languages)
|
|
{
|
|
ShowLanguages();
|
|
}
|
|
else if (_returnMode == CollectionMode.UnitDetail)
|
|
{
|
|
OpenUnitDetail(_units[_selectedUnitIndex], false, _unitDetailReturnsToOverview);
|
|
}
|
|
else
|
|
{
|
|
ShowUnits();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void SelectRelative(int delta)
|
|
{
|
|
if (_mode == CollectionMode.Units)
|
|
{
|
|
SelectUnit(_selectedUnitIndex + delta);
|
|
return;
|
|
}
|
|
|
|
if (_mode == CollectionMode.Languages)
|
|
{
|
|
SelectLanguage(_selectedLanguageIndex + delta);
|
|
return;
|
|
}
|
|
|
|
if (_mode == CollectionMode.Packages)
|
|
{
|
|
SelectPackageInventory(_selectedPackageInventoryIndex + delta);
|
|
return;
|
|
}
|
|
|
|
if (_mode == CollectionMode.UnitDetail)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SelectCard(_selectedCardIndex + delta);
|
|
}
|
|
|
|
public void ActivateSelected()
|
|
{
|
|
if (_mode == CollectionMode.Units && _units.Count > 0)
|
|
{
|
|
OpenUnitDetail(_units[_selectedUnitIndex], true);
|
|
return;
|
|
}
|
|
|
|
if (_mode == CollectionMode.Languages && _languages.Count > 0)
|
|
{
|
|
LanguageCatalogEntry language = _languages[_selectedLanguageIndex];
|
|
if (LanguageUnlock.IsUnlocked(language.Language, _playerCollection))
|
|
{
|
|
OpenLanguageDeck(language);
|
|
}
|
|
}
|
|
|
|
if (_mode == CollectionMode.UnitDetail && _units.Count > 0)
|
|
{
|
|
DistroDefinition unit = _units[_selectedUnitIndex];
|
|
switch (_unitDetailTab)
|
|
{
|
|
case UnitDetailTab.Upgrade:
|
|
UpgradeUnit(unit);
|
|
break;
|
|
case UnitDetailTab.Packages:
|
|
_packagePickerSlot ??= PackageSlot.Kernel;
|
|
OpenPackageEquipWindow(unit, _packagePickerSlot.Value);
|
|
break;
|
|
case UnitDetailTab.Cards:
|
|
OpenUnitCards(unit);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SwitchUnitDetailTabRelative(int delta)
|
|
{
|
|
if (_mode != CollectionMode.UnitDetail || _units.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int count = Enum.GetValues(typeof(UnitDetailTab)).Length;
|
|
_unitDetailTab = (UnitDetailTab)(((int)_unitDetailTab + delta + count) % count);
|
|
_packagePickerSlot = null;
|
|
_packageSlotNotice = null;
|
|
RenderUnitDetail(_units[_selectedUnitIndex]);
|
|
ViewChanged?.Invoke();
|
|
}
|
|
|
|
public void ShowUnitDetail(DistroDefinition unit, bool returnToOverview)
|
|
{
|
|
SelectUnitById(unit?.Id);
|
|
OpenUnitDetail(unit, true, returnToOverview);
|
|
}
|
|
|
|
private void RenderUnits()
|
|
{
|
|
if (_list == null || _detail == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_rows.Clear();
|
|
_list.Clear();
|
|
_list.AddToClassList("hidden");
|
|
_detailScroll?.AddToClassList("collection-detail-full");
|
|
if (_detailScroll != null)
|
|
{
|
|
_detailScroll.verticalScrollerVisibility = ScrollerVisibility.Auto;
|
|
}
|
|
|
|
_detail.Clear();
|
|
|
|
if (_units.Count == 0)
|
|
{
|
|
_detail.Add(new Label("no units installed") { name = "CollectionEmptyTitle" });
|
|
_detail.Add(new Label("run: curl gacha.sh | sh") { name = "CollectionEmptyHint" });
|
|
return;
|
|
}
|
|
|
|
Label title = new("installed units");
|
|
title.AddToClassList("detail-section-title");
|
|
_detail.Add(title);
|
|
|
|
VisualElement roster = new();
|
|
roster.AddToClassList("unit-overview-roster");
|
|
_detail.Add(roster);
|
|
|
|
_selectedUnitIndex = Mathf.Clamp(_selectedUnitIndex, 0, _units.Count - 1);
|
|
for (int i = 0; i < _units.Count; i++)
|
|
{
|
|
int index = i;
|
|
DistroDefinition unit = _units[i];
|
|
VisualElement row = BuildUnitOverviewRow(unit);
|
|
row.RegisterCallback<PointerEnterEvent>(_ => SelectUnit(index));
|
|
row.RegisterCallback<ClickEvent>(_ =>
|
|
{
|
|
SelectUnit(index);
|
|
OpenUnitDetail(unit, true, true);
|
|
});
|
|
roster.Add(row);
|
|
_rows.Add(row);
|
|
}
|
|
|
|
ApplySelection(_selectedUnitIndex);
|
|
}
|
|
|
|
private void RenderLanguages()
|
|
{
|
|
if (_list == null || _detail == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_rows.Clear();
|
|
_list.Clear();
|
|
_detail.Clear();
|
|
_list.RemoveFromClassList("hidden");
|
|
_detailScroll?.RemoveFromClassList("collection-detail-full");
|
|
if (_detailScroll != null)
|
|
{
|
|
_detailScroll.verticalScrollerVisibility = ScrollerVisibility.Auto;
|
|
}
|
|
|
|
_selectedLanguageIndex = Mathf.Clamp(_selectedLanguageIndex, 0, _languages.Count - 1);
|
|
|
|
for (int i = 0; i < _languages.Count; i++)
|
|
{
|
|
int index = i;
|
|
LanguageCatalogEntry language = _languages[i];
|
|
bool unlocked = LanguageUnlock.IsUnlocked(language.Language, _playerCollection);
|
|
VisualElement row = new();
|
|
row.AddToClassList("collection-row");
|
|
row.EnableInClassList("locked", !unlocked);
|
|
row.RegisterCallback<PointerEnterEvent>(_ => SelectLanguage(index));
|
|
row.RegisterCallback<ClickEvent>(_ => SelectLanguage(index));
|
|
|
|
Label name = new(unlocked ? language.DisplayName : $"{language.DisplayName} [locked]");
|
|
name.AddToClassList("collection-row-name");
|
|
|
|
Label tag = new(language.IdentityTag);
|
|
tag.AddToClassList("collection-row-languages");
|
|
|
|
row.Add(name);
|
|
row.Add(tag);
|
|
_list.Add(row);
|
|
_rows.Add(row);
|
|
}
|
|
|
|
SelectLanguage(_selectedLanguageIndex);
|
|
}
|
|
|
|
private void RenderPackages()
|
|
{
|
|
if (_list == null || _detail == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_rows.Clear();
|
|
_list.Clear();
|
|
_detail.Clear();
|
|
_list.RemoveFromClassList("hidden");
|
|
_detailScroll?.RemoveFromClassList("collection-detail-full");
|
|
if (_detailScroll != null)
|
|
{
|
|
_detailScroll.verticalScrollerVisibility = ScrollerVisibility.Auto;
|
|
}
|
|
|
|
SaveData saveData = _getSaveData?.Invoke();
|
|
int cache = Math.Max(0, saveData?.cacheBalance ?? 0);
|
|
int bandwidth = Math.Max(0, saveData?.bandwidthBalance ?? 0);
|
|
|
|
VisualElement filterBar = new();
|
|
filterBar.AddToClassList("collection-actions");
|
|
AddPackageFilterButton(filterBar, null, "all");
|
|
AddPackageFilterButton(filterBar, PackageSlot.Kernel, "kernel");
|
|
AddPackageFilterButton(filterBar, PackageSlot.Runtime, "runtime");
|
|
AddPackageFilterButton(filterBar, PackageSlot.Daemon, "daemon");
|
|
_list.Add(filterBar);
|
|
_list.Add(BuildDetailLine("wallet", $"Cache={cache} Bandwidth={bandwidth}"));
|
|
|
|
List<OwnedPackageInstance> packages = BuildSortedOwnedPackages(_packageInventoryFilter);
|
|
_packageInventory = packages;
|
|
|
|
if (packages.Count == 0)
|
|
{
|
|
_detail.Add(new Label("no packages owned") { name = "CollectionEmptyTitle" });
|
|
_detail.Add(new Label("pull packages via gacha, or check a different slot filter") { name = "CollectionEmptyHint" });
|
|
return;
|
|
}
|
|
|
|
_selectedPackageInventoryIndex = Mathf.Clamp(_selectedPackageInventoryIndex, 0, packages.Count - 1);
|
|
PackageSlot? lastSlot = null;
|
|
for (int i = 0; i < packages.Count; i++)
|
|
{
|
|
int index = i;
|
|
OwnedPackageInstance owned = packages[i];
|
|
if (!_packageInventoryFilter.HasValue && owned.Definition.Slot != lastSlot)
|
|
{
|
|
lastSlot = owned.Definition.Slot;
|
|
Label header = new(lastSlot.Value.ToString().ToUpperInvariant());
|
|
header.AddToClassList("detail-section-title");
|
|
_list.Add(header);
|
|
}
|
|
|
|
VisualElement row = BuildPackageInventoryRow(owned, cache, bandwidth);
|
|
row.RegisterCallback<PointerEnterEvent>(_ => SelectPackageInventory(index));
|
|
row.RegisterCallback<ClickEvent>(_ => SelectPackageInventory(index));
|
|
_list.Add(row);
|
|
_rows.Add(row);
|
|
}
|
|
|
|
SelectPackageInventory(_selectedPackageInventoryIndex);
|
|
}
|
|
|
|
private void AddPackageFilterButton(VisualElement target, PackageSlot? slot, string label)
|
|
{
|
|
Button button = new(() =>
|
|
{
|
|
_packageInventoryFilter = slot;
|
|
_selectedPackageInventoryIndex = 0;
|
|
RenderPackages();
|
|
ViewChanged?.Invoke();
|
|
})
|
|
{
|
|
text = label,
|
|
focusable = false
|
|
};
|
|
button.AddToClassList("collection-tab");
|
|
button.EnableInClassList("selected", _packageInventoryFilter == slot);
|
|
target.Add(button);
|
|
}
|
|
|
|
private List<OwnedPackageInstance> BuildSortedOwnedPackages(PackageSlot? filter)
|
|
{
|
|
List<OwnedPackageInstance> packages = new();
|
|
if (_playerCollection == null)
|
|
{
|
|
return packages;
|
|
}
|
|
|
|
for (int i = 0; i < _playerCollection.OwnedPackageInstances.Count; i++)
|
|
{
|
|
OwnedPackageInstance owned = _playerCollection.OwnedPackageInstances[i];
|
|
if (owned?.Definition == null || (filter.HasValue && owned.Definition.Slot != filter.Value))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
packages.Add(owned);
|
|
}
|
|
|
|
packages.Sort((a, b) =>
|
|
{
|
|
int slotCompare = ((int)a.Definition.Slot).CompareTo((int)b.Definition.Slot);
|
|
if (slotCompare != 0)
|
|
{
|
|
return slotCompare;
|
|
}
|
|
|
|
int rarityCompare = b.Definition.Rarity.CompareTo(a.Definition.Rarity);
|
|
return rarityCompare != 0 ? rarityCompare : string.Compare(PackageName(a.Definition), PackageName(b.Definition), StringComparison.OrdinalIgnoreCase);
|
|
});
|
|
|
|
return packages;
|
|
}
|
|
|
|
private VisualElement BuildPackageInventoryRow(OwnedPackageInstance owned, int cache, int bandwidth)
|
|
{
|
|
PackageDefinition package = owned.Definition;
|
|
VisualElement row = new();
|
|
row.AddToClassList("collection-row");
|
|
row.AddToClassList("package-slot-row");
|
|
|
|
Label name = new(PackageName(package));
|
|
name.AddToClassList("package-slot-name");
|
|
name.style.color = new StyleColor(RarityPresentation.ForStars(package.Rarity).Color);
|
|
row.Add(name);
|
|
|
|
Label slot = new(package.Slot.ToString().ToUpperInvariant());
|
|
slot.AddToClassList("package-slot-label");
|
|
row.Add(slot);
|
|
|
|
RarityStyle rarity = RarityPresentation.ForStars(package.Rarity);
|
|
Label rarityLabel = new(rarity.Badge);
|
|
rarityLabel.AddToClassList("package-slot-rarity");
|
|
rarityLabel.AddToClassList(rarity.ClassName);
|
|
row.Add(rarityLabel);
|
|
|
|
Label level = new($"Lv {owned.UpgradeLevel}/{PackageTuning.MaxPackageLevel}");
|
|
level.AddToClassList("package-slot-level");
|
|
row.Add(level);
|
|
|
|
Label effect = new(OneLineEffect(package, owned.UpgradeLevel, null));
|
|
effect.AddToClassList("package-slot-effect");
|
|
row.Add(effect);
|
|
|
|
string equippedOn = FindEquippedDistroName(package.Id);
|
|
if (equippedOn != null)
|
|
{
|
|
Label tag = new($"@ {equippedOn}");
|
|
tag.AddToClassList("package-notice");
|
|
row.Add(tag);
|
|
}
|
|
|
|
if (CanAffordNextUpgrade(owned, cache, bandwidth))
|
|
{
|
|
Label hint = new("upgrade");
|
|
hint.AddToClassList("unit-overview-upgrade");
|
|
row.Add(hint);
|
|
}
|
|
|
|
return row;
|
|
}
|
|
|
|
private static bool CanAffordNextUpgrade(OwnedPackageInstance owned, int cache, int bandwidth)
|
|
{
|
|
if (owned.UpgradeLevel >= PackageTuning.MaxPackageLevel)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int nextLevel = owned.UpgradeLevel + 1;
|
|
int rarity = owned.Definition.Rarity;
|
|
return cache >= PackageTuning.GetUpgradeCacheCost(nextLevel, rarity) && bandwidth >= PackageTuning.GetUpgradeBandwidthCost(nextLevel, rarity);
|
|
}
|
|
|
|
private string FindEquippedDistroName(string packageId)
|
|
{
|
|
if (_packageLoadout == null || string.IsNullOrWhiteSpace(packageId))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
for (int i = 0; i < _units.Count; i++)
|
|
{
|
|
DistroDefinition unit = _units[i];
|
|
if (unit == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
foreach (KeyValuePair<PackageSlot, string> equipped in _packageLoadout.GetEquippedPackageIds(unit.Id))
|
|
{
|
|
if (string.Equals(equipped.Value, packageId, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return DistroPresentation.DisplayName(unit);
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void SelectPackageInventory(int index)
|
|
{
|
|
if (_packageInventory.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_selectedPackageInventoryIndex = Mathf.Clamp(index, 0, _packageInventory.Count - 1);
|
|
ApplySelection(_selectedPackageInventoryIndex);
|
|
RenderPackageInventoryDetail(_packageInventory[_selectedPackageInventoryIndex]);
|
|
}
|
|
|
|
private void RenderPackageInventoryDetail(OwnedPackageInstance owned)
|
|
{
|
|
_detail.Clear();
|
|
if (owned?.Definition == null)
|
|
{
|
|
_detail.Add(new Label("no packages owned") { name = "CollectionEmptyTitle" });
|
|
return;
|
|
}
|
|
|
|
PackageDefinition package = owned.Definition;
|
|
SaveData saveData = _getSaveData?.Invoke();
|
|
int cache = Math.Max(0, saveData?.cacheBalance ?? 0);
|
|
int bandwidth = Math.Max(0, saveData?.bandwidthBalance ?? 0);
|
|
|
|
Label name = new(PackageName(package));
|
|
name.AddToClassList("collection-detail-name");
|
|
name.style.color = new StyleColor(RarityPresentation.ForStars(package.Rarity).Color);
|
|
_detail.Add(name);
|
|
|
|
_detail.Add(BuildDetailLine("wallet", $"Cache={cache} Bandwidth={bandwidth}"));
|
|
_detail.Add(BuildDetailLine("slot", package.Slot.ToString()));
|
|
_detail.Add(BuildDetailLine("rarity", RarityPresentation.ForStars(package.Rarity).Stars));
|
|
_detail.Add(BuildDetailLine("level", $"Lv {owned.UpgradeLevel}/{PackageTuning.MaxPackageLevel}"));
|
|
_detail.Add(BuildDetailLine("equipped", FindEquippedDistroName(package.Id) ?? "not equipped"));
|
|
_detail.Add(BuildDetailLine("current", FormatPackageEffect(package, owned.UpgradeLevel, null)));
|
|
|
|
int nextLevel = owned.UpgradeLevel + 1;
|
|
bool maxLevel = owned.UpgradeLevel >= PackageTuning.MaxPackageLevel;
|
|
int upgradeCacheCost = maxLevel ? 0 : PackageTuning.GetUpgradeCacheCost(nextLevel, package.Rarity);
|
|
int upgradeBandwidthCost = maxLevel ? 0 : PackageTuning.GetUpgradeBandwidthCost(nextLevel, package.Rarity);
|
|
bool canUpgrade = !maxLevel && cache >= upgradeCacheCost && bandwidth >= upgradeBandwidthCost && _tryUpgradePackage != null;
|
|
string upgradeState = maxLevel ? "max level" : cache < upgradeCacheCost ? "insufficient cache" : bandwidth < upgradeBandwidthCost ? "insufficient bandwidth" : "ready";
|
|
string nextPreview = maxLevel
|
|
? "max level reached"
|
|
: $"{FormatPackageEffect(package, owned.UpgradeLevel, null)} -> {FormatPackageEffect(package, nextLevel, null)}";
|
|
_detail.Add(BuildDetailLine("next", nextPreview));
|
|
_detail.Add(BuildCompactUpgradeCommand($"> make upgrade (Cache {upgradeCacheCost} / Bandwidth {upgradeBandwidthCost})", upgradeState, canUpgrade, () => UpgradePackage(owned)));
|
|
|
|
bool equipped = _packageLoadout != null && _packageLoadout.IsEquipped(package.Id);
|
|
int scrapCache = PackageTuning.GetCacheForRarity(package.Rarity) + PackageTuning.GetRefundedInvestedCache(owned.UpgradeLevel, package.Rarity);
|
|
int scrapBandwidth = PackageTuning.GetRefundedInvestedBandwidth(owned.UpgradeLevel, package.Rarity);
|
|
bool confirming = string.Equals(_pendingScrapPackageId, package.Id, StringComparison.OrdinalIgnoreCase);
|
|
string scrapCommand = confirming ? $"> rm --purge --yes (+{scrapCache} cache/+{scrapBandwidth} bandwidth)" : $"> rm --purge (+{scrapCache} cache)";
|
|
string scrapState = equipped ? "equipped: unequip first" : confirming ? "confirm permanent scrap" : "requires confirm";
|
|
_detail.Add(BuildCompactUpgradeCommand(scrapCommand, scrapState, !equipped && _tryScrapPackage != null, () => ScrapPackage(owned)));
|
|
}
|
|
|
|
private VisualElement BuildUnitOverviewRow(DistroDefinition unit)
|
|
{
|
|
VisualElement row = new();
|
|
row.AddToClassList("collection-row");
|
|
row.AddToClassList("unit-overview-row");
|
|
|
|
VisualElement top = new();
|
|
top.AddToClassList("unit-overview-top");
|
|
|
|
Label name = new(DistroPresentation.DisplayName(unit));
|
|
name.AddToClassList("collection-row-name");
|
|
name.style.color = new StyleColor(unit.AccentColor);
|
|
top.Add(name);
|
|
|
|
RarityStyle rarity = RarityPresentation.ForStars(GetDistroStars(unit));
|
|
Label rarityLabel = new(rarity.Badge);
|
|
rarityLabel.AddToClassList("unit-overview-rarity");
|
|
rarityLabel.AddToClassList(rarity.ClassName);
|
|
top.Add(rarityLabel);
|
|
|
|
if (CanUpgradeUnit(unit))
|
|
{
|
|
Label upgrade = new("upgrade");
|
|
upgrade.AddToClassList("unit-overview-upgrade");
|
|
top.Add(upgrade);
|
|
}
|
|
|
|
row.Add(top);
|
|
|
|
VisualElement meta = new();
|
|
meta.AddToClassList("unit-overview-meta");
|
|
AddLanguageTag(meta, unit.PrimaryLanguage);
|
|
AddLanguageTag(meta, unit.SecondaryLanguage);
|
|
row.Add(meta);
|
|
|
|
int version = GetUnitVersion(unit);
|
|
Label release = new($"{DistroPresentation.DisplayName(unit)} {DistroVersionCatalog.GetReleaseLabel(unit.Id, version)} · v{version}/{GachaTuning.MaxVersion}");
|
|
release.AddToClassList("unit-overview-release");
|
|
row.Add(release);
|
|
|
|
VisualElement slots = new();
|
|
slots.AddToClassList("unit-overview-slots");
|
|
AddPackageSlotDot(slots, unit, PackageSlot.Kernel);
|
|
AddPackageSlotDot(slots, unit, PackageSlot.Runtime);
|
|
AddPackageSlotDot(slots, unit, PackageSlot.Daemon);
|
|
row.Add(slots);
|
|
|
|
return row;
|
|
}
|
|
|
|
private void AddLanguageTag(VisualElement target, Language language)
|
|
{
|
|
Label tag = new(language.ToString());
|
|
tag.AddToClassList("unit-language-tag");
|
|
tag.style.color = new StyleColor(GetLanguageColor(language));
|
|
target.Add(tag);
|
|
}
|
|
|
|
private void AddPackageSlotDot(VisualElement target, DistroDefinition unit, PackageSlot slot)
|
|
{
|
|
PackageDefinition package = _packageLoadout == null || unit == null ? null : _packageLoadout.GetEquippedPackage(unit.Id, slot);
|
|
VisualElement dot = new();
|
|
dot.AddToClassList("unit-package-dot");
|
|
dot.EnableInClassList("empty", package == null);
|
|
if (package != null)
|
|
{
|
|
RarityStyle rarity = RarityPresentation.ForStars(package.Rarity);
|
|
dot.AddToClassList(rarity.ClassName);
|
|
dot.style.backgroundColor = new StyleColor(rarity.Color);
|
|
}
|
|
|
|
target.Add(dot);
|
|
}
|
|
|
|
private bool CanUpgradeUnit(DistroDefinition unit)
|
|
{
|
|
if (unit == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int version = GetUnitVersion(unit);
|
|
if (version >= GachaTuning.MaxVersion)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int merges = _getMergesBalance?.Invoke(unit) ?? 0;
|
|
return merges >= GachaTuning.GetVersionUpgradeCost(version + 1);
|
|
}
|
|
|
|
private int GetUnitVersion(DistroDefinition unit)
|
|
{
|
|
return unit == null || _playerCollection == null ? 1 : Mathf.Clamp(_playerCollection.GetVersion(unit.Id), 1, GachaTuning.MaxVersion);
|
|
}
|
|
|
|
private static int GetDistroStars(DistroDefinition unit)
|
|
{
|
|
return unit != null && string.Equals(unit.Id, "arch", StringComparison.OrdinalIgnoreCase) ? 5 : 4;
|
|
}
|
|
|
|
private static Color GetLanguageColor(Language language)
|
|
{
|
|
return language switch
|
|
{
|
|
Language.C => new Color(0.55f, 0.85f, 1f),
|
|
Language.CPlusPlus => new Color(0.48f, 0.72f, 1f),
|
|
Language.Rust => new Color(1f, 0.55f, 0.35f),
|
|
Language.Python => new Color(1f, 0.82f, 0.35f),
|
|
Language.JavaScript => new Color(1f, 0.9f, 0.28f),
|
|
Language.TypeScript => new Color(0.4f, 0.72f, 1f),
|
|
Language.Haskell => new Color(0.75f, 0.55f, 1f),
|
|
Language.Assembly => new Color(0.85f, 0.85f, 0.85f),
|
|
Language.Java => new Color(1f, 0.58f, 0.42f),
|
|
Language.Go => new Color(0.35f, 0.95f, 1f),
|
|
Language.Ruby => new Color(1f, 0.35f, 0.45f),
|
|
Language.Php => new Color(0.68f, 0.68f, 1f),
|
|
_ => new Color(0.5f, 0.62f, 0.54f)
|
|
};
|
|
}
|
|
|
|
private void SelectUnit(int index)
|
|
{
|
|
if (_units.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_selectedUnitIndex = Mathf.Clamp(index, 0, _units.Count - 1);
|
|
ApplySelection(_selectedUnitIndex);
|
|
}
|
|
|
|
private void SelectUnitById(string unitId)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(unitId))
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < _units.Count; i++)
|
|
{
|
|
DistroDefinition unit = _units[i];
|
|
if (unit != null && string.Equals(unit.Id, unitId, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
_selectedUnitIndex = i;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SelectLanguage(int index)
|
|
{
|
|
_selectedLanguageIndex = Mathf.Clamp(index, 0, _languages.Count - 1);
|
|
ApplySelection(_selectedLanguageIndex);
|
|
RenderLanguageDetail(_languages[_selectedLanguageIndex]);
|
|
}
|
|
|
|
private void SelectCard(int index)
|
|
{
|
|
if (_cards.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_selectedCardIndex = Mathf.Clamp(index, 0, _cards.Count - 1);
|
|
ApplySelection(_selectedCardIndex);
|
|
RenderCardDetail(_cards[_selectedCardIndex]);
|
|
}
|
|
|
|
private void ApplySelection(int selectedIndex)
|
|
{
|
|
for (int i = 0; i < _rows.Count; i++)
|
|
{
|
|
_rows[i].EnableInClassList("selected", i == selectedIndex);
|
|
}
|
|
}
|
|
|
|
private void OpenUnitDetail(DistroDefinition unit, bool notify, bool returnToOverview = true)
|
|
{
|
|
if (unit == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_mode != CollectionMode.UnitDetail)
|
|
{
|
|
_unitDetailTab = UnitDetailTab.Overview;
|
|
_packagePickerSlot = null;
|
|
_packageSlotNotice = null;
|
|
}
|
|
|
|
_unitDetailReturnsToOverview = returnToOverview;
|
|
_mode = CollectionMode.UnitDetail;
|
|
CurrentTitle = $"$ cat ~/units/{unit.Id}";
|
|
CurrentHint = GetUnitDetailHint();
|
|
RenderUnitDetail(unit);
|
|
if (notify)
|
|
{
|
|
ViewChanged?.Invoke();
|
|
}
|
|
}
|
|
|
|
private void RenderUnitDetail(DistroDefinition unit)
|
|
{
|
|
_list.AddToClassList("hidden");
|
|
_detailScroll?.AddToClassList("collection-detail-full");
|
|
if (_detailScroll != null)
|
|
{
|
|
_detailScroll.verticalScrollerVisibility = ScrollerVisibility.Hidden;
|
|
}
|
|
|
|
_detail.Clear();
|
|
CurrentHint = GetUnitDetailHint();
|
|
|
|
_detail.Add(BuildUnitDetailHeader(unit));
|
|
_detail.Add(BuildUnitDetailTabs(unit));
|
|
|
|
ScrollView bodyScroll = new();
|
|
bodyScroll.AddToClassList("unit-detail-tab-body");
|
|
VisualElement body = bodyScroll.contentContainer;
|
|
switch (_unitDetailTab)
|
|
{
|
|
case UnitDetailTab.Upgrade:
|
|
AddUnitUpgradeTab(body, unit);
|
|
break;
|
|
case UnitDetailTab.Packages:
|
|
AddUnitPackagesTab(body, unit);
|
|
break;
|
|
case UnitDetailTab.Cards:
|
|
AddUnitCardsTab(body, unit);
|
|
break;
|
|
default:
|
|
AddUnitOverviewTab(body, unit);
|
|
break;
|
|
}
|
|
|
|
_detail.Add(bodyScroll);
|
|
}
|
|
|
|
private VisualElement BuildUnitDetailHeader(DistroDefinition unit)
|
|
{
|
|
VisualElement header = new();
|
|
header.AddToClassList("unit-detail-header");
|
|
VisualElement nameBlock = new();
|
|
nameBlock.AddToClassList("unit-detail-header-copy");
|
|
int version = GetUnitVersion(unit);
|
|
Label name = new($"{DistroPresentation.DisplayName(unit)} {DistroVersionCatalog.GetReleaseLabel(unit.Id, version)} · v{version}/{GachaTuning.MaxVersion}");
|
|
name.AddToClassList("collection-detail-name");
|
|
name.style.color = new StyleColor(unit.AccentColor);
|
|
nameBlock.Add(name);
|
|
|
|
VisualElement languages = new();
|
|
languages.AddToClassList("unit-overview-meta");
|
|
AddLanguageTag(languages, unit.PrimaryLanguage);
|
|
AddLanguageTag(languages, unit.SecondaryLanguage);
|
|
nameBlock.Add(languages);
|
|
header.Add(nameBlock);
|
|
|
|
RarityStyle rarity = RarityPresentation.ForStars(GetDistroStars(unit));
|
|
Label rarityLabel = new(rarity.Stars);
|
|
rarityLabel.AddToClassList("unit-overview-rarity");
|
|
rarityLabel.AddToClassList(rarity.ClassName);
|
|
header.Add(rarityLabel);
|
|
return header;
|
|
}
|
|
|
|
private VisualElement BuildUnitDetailTabs(DistroDefinition unit)
|
|
{
|
|
VisualElement tabs = new();
|
|
tabs.AddToClassList("unit-detail-tabs");
|
|
AddUnitDetailTabButton(tabs, UnitDetailTab.Overview, "overview", unit);
|
|
AddUnitDetailTabButton(tabs, UnitDetailTab.Upgrade, "upgrade", unit);
|
|
AddUnitDetailTabButton(tabs, UnitDetailTab.Packages, "packages", unit);
|
|
AddUnitDetailTabButton(tabs, UnitDetailTab.Cards, "cards", unit);
|
|
return tabs;
|
|
}
|
|
|
|
private void AddUnitDetailTabButton(VisualElement tabs, UnitDetailTab tab, string label, DistroDefinition unit)
|
|
{
|
|
Button button = new(() =>
|
|
{
|
|
_unitDetailTab = tab;
|
|
_packagePickerSlot = null;
|
|
_packageSlotNotice = null;
|
|
RenderUnitDetail(unit);
|
|
ViewChanged?.Invoke();
|
|
})
|
|
{
|
|
text = label,
|
|
focusable = false
|
|
};
|
|
button.AddToClassList("collection-tab");
|
|
button.EnableInClassList("selected", _unitDetailTab == tab);
|
|
tabs.Add(button);
|
|
}
|
|
|
|
private void AddUnitOverviewTab(VisualElement target, DistroDefinition unit)
|
|
{
|
|
Label identityTitle = new("identity");
|
|
identityTitle.AddToClassList("detail-section-title");
|
|
target.Add(identityTitle);
|
|
target.Add(BuildDetailLine("lang", DistroPresentation.FormatLanguages(unit)));
|
|
|
|
Label description = new(string.IsNullOrWhiteSpace(unit.Description) ? "--" : unit.Description);
|
|
description.AddToClassList("collection-detail-description");
|
|
target.Add(description);
|
|
AddPassiveDetails(target, unit);
|
|
|
|
VisualElement readout = new();
|
|
readout.AddToClassList("collection-detail-readout");
|
|
|
|
Label artLabel = new();
|
|
DistroArtPresenter.ConfigureArtLabel(artLabel, _monospaceFont);
|
|
AsciiArtFitter artFitter = new(artLabel, _monospaceFont);
|
|
VisualElement artPlaceholder = DistroArtPresenter.CreatePlaceholder();
|
|
artFitter.SetArt(DistroArtPresenter.Render(artLabel, artPlaceholder, unit));
|
|
readout.Add(artPlaceholder);
|
|
readout.Add(artLabel);
|
|
|
|
VisualElement details = new();
|
|
details.AddToClassList("collection-detail-values");
|
|
details.Add(BuildDetailLine("lang", DistroPresentation.FormatLanguages(unit)));
|
|
details.Add(BuildDetailLine("uptime", unit.BaseUptime.ToString()));
|
|
details.Add(BuildDetailLine("ram", unit.BaseRam.ToString()));
|
|
details.Add(BuildDetailLine("cycles", unit.BaseCyclesPerTurn.ToString()));
|
|
|
|
readout.Add(details);
|
|
target.Add(readout);
|
|
}
|
|
|
|
private void AddUnitUpgradeTab(VisualElement target, DistroDefinition unit)
|
|
{
|
|
Label title = new("version upgrade");
|
|
title.AddToClassList("detail-section-title");
|
|
target.Add(title);
|
|
AddVersionUpgradePanel(target, unit);
|
|
}
|
|
|
|
private void AddUnitCardsTab(VisualElement target, DistroDefinition unit)
|
|
{
|
|
Label title = new("core package cards");
|
|
title.AddToClassList("detail-section-title");
|
|
target.Add(title);
|
|
target.Add(BuildSubviewCommand($"cat ~/units/{unit.Id}/cards", "exclusive packages", HasListableCards(unit), () => OpenUnitCards(unit), "no packages installed"));
|
|
}
|
|
|
|
private void AddUnitPackagesTab(VisualElement target, DistroDefinition unit)
|
|
{
|
|
if (unit == null || _packageLoadout == null || _playerCollection == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Label title = new("packages");
|
|
title.AddToClassList("detail-section-title");
|
|
target.Add(title);
|
|
_packagePickerSlot ??= PackageSlot.Kernel;
|
|
|
|
VisualElement layout = new();
|
|
layout.AddToClassList("packages-summary-layout");
|
|
|
|
VisualElement slots = new();
|
|
slots.AddToClassList("packages-slot-list");
|
|
AddPackageSlotSummaryRow(slots, unit, PackageSlot.Kernel);
|
|
AddPackageSlotSummaryRow(slots, unit, PackageSlot.Runtime);
|
|
AddPackageSlotSummaryRow(slots, unit, PackageSlot.Daemon);
|
|
layout.Add(slots);
|
|
|
|
VisualElement impact = new();
|
|
impact.AddToClassList("packages-impact-panel");
|
|
AddPackageStatImpactPanel(impact, unit);
|
|
layout.Add(impact);
|
|
target.Add(layout);
|
|
}
|
|
|
|
private void AddPackageSlotSummaryRow(VisualElement target, DistroDefinition unit, PackageSlot slot)
|
|
{
|
|
PackageDefinition equipped = _packageLoadout.GetEquippedPackage(unit.Id, slot);
|
|
OwnedPackageInstance owned = equipped == null ? null : _playerCollection.GetOwnedPackage(equipped.Id);
|
|
VisualElement row = new();
|
|
row.AddToClassList("package-slot-row");
|
|
row.EnableInClassList("selected", _packagePickerSlot == slot);
|
|
row.RegisterCallback<ClickEvent>(_ =>
|
|
{
|
|
_packagePickerSlot = slot;
|
|
_packageSlotNotice = null;
|
|
OpenPackageEquipWindow(unit, slot);
|
|
});
|
|
row.RegisterCallback<KeyDownEvent>(evt =>
|
|
{
|
|
if (evt.keyCode == KeyCode.Return || evt.keyCode == KeyCode.KeypadEnter)
|
|
{
|
|
_packagePickerSlot = slot;
|
|
_packageSlotNotice = null;
|
|
OpenPackageEquipWindow(unit, slot);
|
|
evt.StopPropagation();
|
|
}
|
|
});
|
|
row.focusable = true;
|
|
|
|
Label slotLabel = new(slot.ToString().ToUpperInvariant());
|
|
slotLabel.AddToClassList("package-slot-label");
|
|
row.Add(slotLabel);
|
|
|
|
Label name = new(equipped == null ? "[ empty ]" : $"[{PackageName(equipped)}]");
|
|
name.AddToClassList("package-slot-name");
|
|
if (equipped != null)
|
|
{
|
|
name.style.color = new StyleColor(RarityPresentation.ForStars(equipped.Rarity).Color);
|
|
}
|
|
|
|
row.Add(name);
|
|
|
|
Label rarity = new(equipped == null ? string.Empty : RarityPresentation.ForStars(equipped.Rarity).Badge);
|
|
rarity.AddToClassList("package-slot-rarity");
|
|
if (equipped != null)
|
|
{
|
|
rarity.AddToClassList(RarityPresentation.ForStars(equipped.Rarity).ClassName);
|
|
}
|
|
|
|
row.Add(rarity);
|
|
|
|
Label level = new(owned == null ? string.Empty : $"Lv {owned.UpgradeLevel}/{PackageTuning.MaxPackageLevel}");
|
|
level.AddToClassList("package-slot-level");
|
|
row.Add(level);
|
|
|
|
Label effect = new(equipped == null ? string.Empty : OneLineEffect(equipped, owned?.UpgradeLevel ?? 0, unit.Id));
|
|
effect.AddToClassList("package-slot-effect");
|
|
row.Add(effect);
|
|
|
|
Label action = new("[enter] equip");
|
|
action.AddToClassList("package-slot-action");
|
|
row.Add(action);
|
|
target.Add(row);
|
|
}
|
|
|
|
private void AddPackageStatImpactPanel(VisualElement target, DistroDefinition unit)
|
|
{
|
|
Label title = new("stat impact");
|
|
title.AddToClassList("detail-section-title");
|
|
target.Add(title);
|
|
|
|
IReadOnlyList<PackageInstance> packages = _packageLoadout.GetEquippedPackageInstances(unit.Id);
|
|
PackageStatImpact impact = RunManager.CalculatePackageStatImpact(unit, packages);
|
|
target.Add(BuildStatImpactLine("Uptime", impact.BaseUptime, impact.FinalUptime, impact.UptimeBonus, impact.UptimeSources));
|
|
target.Add(BuildStatImpactLine("RAM", impact.BaseRam, impact.FinalRam, impact.RamBonus, impact.RamSources));
|
|
target.Add(BuildStatImpactLine("Cycles", impact.BaseCycles, impact.FinalCycles, impact.CyclesBonus, impact.CyclesSources));
|
|
|
|
VisualElement active = new();
|
|
active.AddToClassList("packages-active-effects");
|
|
Label activeTitle = new("active effects");
|
|
activeTitle.AddToClassList("detail-section-title");
|
|
active.Add(activeTitle);
|
|
|
|
int count = 0;
|
|
AddActivePackageEffect(active, unit, PackageSlot.Kernel, ref count);
|
|
AddActivePackageEffect(active, unit, PackageSlot.Runtime, ref count);
|
|
AddActivePackageEffect(active, unit, PackageSlot.Daemon, ref count);
|
|
if (count == 0)
|
|
{
|
|
Label empty = new("none");
|
|
empty.AddToClassList("collection-detail-muted");
|
|
active.Add(empty);
|
|
}
|
|
|
|
target.Add(active);
|
|
}
|
|
|
|
private VisualElement BuildStatImpactLine(string label, int before, int after, int delta, IReadOnlyList<string> sources)
|
|
{
|
|
VisualElement row = new();
|
|
row.AddToClassList("package-stat-line");
|
|
Label key = new(label);
|
|
key.AddToClassList("package-stat-key");
|
|
Label values = new($"{before} -> {after}");
|
|
values.AddToClassList("package-stat-value");
|
|
Label bonus = new(delta > 0 ? $"(+{delta}{FormatSources(sources)})" : string.Empty);
|
|
bonus.AddToClassList("package-stat-bonus");
|
|
row.Add(key);
|
|
row.Add(values);
|
|
row.Add(bonus);
|
|
return row;
|
|
}
|
|
|
|
private void AddActivePackageEffect(VisualElement target, DistroDefinition unit, PackageSlot slot, ref int count)
|
|
{
|
|
PackageDefinition package = _packageLoadout.GetEquippedPackage(unit.Id, slot);
|
|
OwnedPackageInstance owned = package == null ? null : _playerCollection.GetOwnedPackage(package.Id);
|
|
if (package == null || owned == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
PackageEffectData effect = package.EffectFor(unit.Id);
|
|
if (package.Slot == PackageSlot.Kernel && IsStatPackageEffect(effect.Kind))
|
|
{
|
|
return;
|
|
}
|
|
|
|
string summary = OneLineEffect(package, owned.UpgradeLevel, unit.Id);
|
|
if (string.IsNullOrWhiteSpace(summary))
|
|
{
|
|
return;
|
|
}
|
|
|
|
Label line = new($"{PackageName(package)}: {summary}");
|
|
line.AddToClassList("package-active-effect");
|
|
target.Add(line);
|
|
count++;
|
|
}
|
|
|
|
private static bool IsStatPackageEffect(PackageEffectKind kind)
|
|
{
|
|
return kind == PackageEffectKind.MaxUptime
|
|
|| kind == PackageEffectKind.MaxRam
|
|
|| kind == PackageEffectKind.MaxCycles;
|
|
}
|
|
|
|
private static string FormatSources(IReadOnlyList<string> sources)
|
|
{
|
|
return sources == null || sources.Count == 0 ? string.Empty : $", {string.Join(", ", sources)}";
|
|
}
|
|
|
|
private void AddSelectedPackageSlotActions(VisualElement target, DistroDefinition unit, PackageSlot slot, int cache, int bandwidth)
|
|
{
|
|
PackageDefinition equipped = _packageLoadout.GetEquippedPackage(unit.Id, slot);
|
|
OwnedPackageInstance owned = equipped == null ? null : _playerCollection.GetOwnedPackage(equipped.Id);
|
|
Label title = new($"{slot.ToString().ToLowerInvariant()} actions");
|
|
title.AddToClassList("detail-section-title");
|
|
target.Add(title);
|
|
if (!string.IsNullOrWhiteSpace(_packageSlotNotice))
|
|
{
|
|
Label notice = new(_packageSlotNotice);
|
|
notice.AddToClassList("package-notice");
|
|
notice.AddToClassList("package-slot-notice");
|
|
target.Add(notice);
|
|
}
|
|
|
|
if (owned == null || equipped == null)
|
|
{
|
|
target.Add(BuildDetailLine("status", "empty slot"));
|
|
target.Add(BuildDetailLine("equip", "select an owned package below"));
|
|
return;
|
|
}
|
|
|
|
target.Add(BuildDetailLine("level", $"Lv {owned.UpgradeLevel}/{PackageTuning.MaxPackageLevel}"));
|
|
|
|
int nextLevel = owned.UpgradeLevel + 1;
|
|
bool maxLevel = owned.UpgradeLevel >= PackageTuning.MaxPackageLevel;
|
|
int cacheCost = maxLevel ? 0 : PackageTuning.GetUpgradeCacheCost(nextLevel, equipped.Rarity);
|
|
int bandwidthCost = maxLevel ? 0 : PackageTuning.GetUpgradeBandwidthCost(nextLevel, equipped.Rarity);
|
|
bool canUpgrade = !maxLevel && cache >= cacheCost && bandwidth >= bandwidthCost && _tryUpgradePackage != null;
|
|
string upgradeState = maxLevel ? "max level" : cache < cacheCost ? "insufficient cache" : bandwidth < bandwidthCost ? "insufficient bandwidth" : "ready";
|
|
string currentEffect = FormatPackageEffect(equipped, owned.UpgradeLevel, unit.Id);
|
|
string nextPreview = maxLevel ? "max level reached" : $"{currentEffect} -> {FormatPackageEffect(equipped, nextLevel, unit.Id)}";
|
|
target.Add(BuildPackagePreviewLine("current", currentEffect));
|
|
target.Add(BuildPackagePreviewLine("next", nextPreview));
|
|
target.Add(BuildCompactUpgradeCommand($"> make upgrade (Cache {cacheCost} / Bandwidth {bandwidthCost})", upgradeState, canUpgrade, () => UpgradePackage(owned)));
|
|
}
|
|
|
|
private void AddPackagePicker(VisualElement target, DistroDefinition unit, PackageSlot slot)
|
|
{
|
|
Label title = new($"select {slot.ToString().ToLowerInvariant()} package");
|
|
title.AddToClassList("detail-section-title");
|
|
target.Add(title);
|
|
|
|
PackageDefinition equipped = _packageLoadout.GetEquippedPackage(unit.Id, slot);
|
|
for (int i = 0; i < _playerCollection.OwnedPackages.Count; i++)
|
|
{
|
|
PackageDefinition package = _playerCollection.OwnedPackages[i];
|
|
if (package == null || package.Slot != slot)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
bool isEquipped = equipped != null && string.Equals(equipped.Id, package.Id, StringComparison.OrdinalIgnoreCase);
|
|
int packageLevel = _playerCollection.GetOwnedPackage(package.Id)?.UpgradeLevel ?? 0;
|
|
VisualElement row = new();
|
|
row.AddToClassList("package-row");
|
|
row.AddToClassList("package-picker-row");
|
|
row.EnableInClassList("equipped", isEquipped);
|
|
row.EnableInClassList($"rarity-{package.Rarity}", true);
|
|
row.RegisterCallback<ClickEvent>(_ => TogglePackage(unit, slot, package, isEquipped));
|
|
|
|
VisualElement summary = new();
|
|
summary.AddToClassList("package-summary");
|
|
Label marker = new(isEquipped ? "[x]" : "[ ]");
|
|
marker.AddToClassList("package-marker");
|
|
Label name = new(PackageName(package));
|
|
name.AddToClassList("package-name");
|
|
Label effect = new(OneLineEffect(package, packageLevel, unit.Id));
|
|
effect.AddToClassList("package-picker-effect");
|
|
Label meta = new(package.IsIntendedFor(unit.Id) ? $"{package.Rarity}* on" : $"{package.Rarity}*");
|
|
meta.AddToClassList("package-meta");
|
|
summary.Add(marker);
|
|
summary.Add(name);
|
|
summary.Add(effect);
|
|
summary.Add(meta);
|
|
row.Add(summary);
|
|
|
|
target.Add(row);
|
|
}
|
|
}
|
|
|
|
private bool TogglePackage(DistroDefinition unit, PackageSlot slot, PackageDefinition package, bool isEquipped)
|
|
{
|
|
if (unit == null || package == null || _packageLoadout == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
PackageLoadoutFailureReason reason;
|
|
bool changed = isEquipped
|
|
? _packageLoadout.TryUnequip(unit.Id, slot, out reason)
|
|
: _packageLoadout.TryEquip(unit.Id, slot, package.Id, out reason);
|
|
|
|
if (changed)
|
|
{
|
|
_packageSlotNotice = null;
|
|
_packageLoadoutChanged?.Invoke();
|
|
}
|
|
|
|
if (!changed)
|
|
{
|
|
_packageSlotNotice = FormatPackageFailure(reason);
|
|
}
|
|
|
|
RenderUnitDetail(unit);
|
|
return changed;
|
|
}
|
|
|
|
private void EnsurePackageEquipOverlay()
|
|
{
|
|
if (_root == null || _packageEquipOverlay != null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_packageEquipOverlay = new VisualElement();
|
|
_packageEquipOverlay.AddToClassList("modal-overlay");
|
|
_packageEquipOverlay.AddToClassList("package-equip-overlay");
|
|
_packageEquipOverlay.AddToClassList("hidden");
|
|
_packageEquipDialog = new VisualElement();
|
|
_packageEquipDialog.AddToClassList("package-equip-dialog");
|
|
_packageEquipOverlay.Add(_packageEquipDialog);
|
|
_root.Add(_packageEquipOverlay);
|
|
}
|
|
|
|
private void OpenPackageEquipWindow(DistroDefinition unit, PackageSlot slot)
|
|
{
|
|
if (unit == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
EnsurePackageEquipOverlay();
|
|
_equipWindowUnit = unit;
|
|
_equipWindowSlot = slot;
|
|
_packageSlotNotice = null;
|
|
RenderPackageEquipWindow();
|
|
_packageEquipOverlay.RemoveFromClassList("hidden");
|
|
_packageEquipOverlay.AddToClassList("modal-open");
|
|
}
|
|
|
|
private void ClosePackageEquipWindow()
|
|
{
|
|
_packageEquipOverlay?.RemoveFromClassList("modal-open");
|
|
_packageEquipOverlay?.AddToClassList("hidden");
|
|
_equipWindowUnit = null;
|
|
_packageSlotNotice = null;
|
|
}
|
|
|
|
private void RenderPackageEquipWindow()
|
|
{
|
|
if (_packageEquipDialog == null || _equipWindowUnit == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_packageEquipDialog.Clear();
|
|
PackageDefinition equipped = _packageLoadout.GetEquippedPackage(_equipWindowUnit.Id, _equipWindowSlot);
|
|
|
|
VisualElement header = new();
|
|
header.AddToClassList("package-equip-header");
|
|
Label title = new($"equip: {_equipWindowSlot.ToString().ToLowerInvariant()} - {DistroPresentation.DisplayName(_equipWindowUnit)}");
|
|
title.AddToClassList("collection-detail-name");
|
|
title.style.color = new StyleColor(_equipWindowUnit.AccentColor);
|
|
header.Add(title);
|
|
Button close = new(ClosePackageEquipWindow) { text = "x", focusable = false };
|
|
close.AddToClassList("modal-close-button");
|
|
header.Add(close);
|
|
_packageEquipDialog.Add(header);
|
|
|
|
if (!string.IsNullOrWhiteSpace(_packageSlotNotice))
|
|
{
|
|
Label notice = new(_packageSlotNotice);
|
|
notice.AddToClassList("package-notice");
|
|
_packageEquipDialog.Add(notice);
|
|
}
|
|
|
|
string equippedName = equipped == null ? "empty" : PackageName(equipped);
|
|
_packageEquipDialog.Add(BuildDetailLine("current", equippedName));
|
|
if (equipped != null)
|
|
{
|
|
_packageEquipDialog.Add(BuildCompactUpgradeCommand("> unlink current", "unequip", true, () => UnequipPackageFromWindow(_equipWindowUnit, _equipWindowSlot)));
|
|
}
|
|
|
|
ScrollView list = new(ScrollViewMode.Vertical);
|
|
list.AddToClassList("package-equip-list");
|
|
int count = 0;
|
|
for (int i = 0; i < _playerCollection.OwnedPackageInstances.Count; i++)
|
|
{
|
|
OwnedPackageInstance owned = _playerCollection.OwnedPackageInstances[i];
|
|
PackageDefinition package = owned?.Definition;
|
|
if (package == null || package.Slot != _equipWindowSlot)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
list.Add(BuildEquipWindowPackageRow(owned, equipped));
|
|
count++;
|
|
}
|
|
|
|
if (count == 0)
|
|
{
|
|
Label empty = new($"no owned {_equipWindowSlot.ToString().ToLowerInvariant()} packages");
|
|
empty.AddToClassList("package-empty");
|
|
list.Add(empty);
|
|
}
|
|
|
|
_packageEquipDialog.Add(list);
|
|
_packageEquipDialog.Add(BuildCompactUpgradeCommand("> cancel", "back", true, ClosePackageEquipWindow));
|
|
}
|
|
|
|
private VisualElement BuildEquipWindowPackageRow(OwnedPackageInstance owned, PackageDefinition equipped)
|
|
{
|
|
PackageDefinition package = owned.Definition;
|
|
bool isEquippedHere = equipped != null && string.Equals(equipped.Id, package.Id, StringComparison.OrdinalIgnoreCase);
|
|
VisualElement row = new();
|
|
row.AddToClassList("package-row");
|
|
row.AddToClassList("package-equip-row");
|
|
row.EnableInClassList("equipped", isEquippedHere);
|
|
row.EnableInClassList($"rarity-{package.Rarity}", true);
|
|
row.EnableInClassList("on-distro", package.IsIntendedFor(_equipWindowUnit.Id));
|
|
row.RegisterCallback<ClickEvent>(_ => EquipPackageFromWindow(_equipWindowUnit, _equipWindowSlot, package, isEquippedHere));
|
|
|
|
VisualElement summary = new();
|
|
summary.AddToClassList("package-summary");
|
|
Label marker = new(isEquippedHere ? "[x]" : "[ ]");
|
|
marker.AddToClassList("package-marker");
|
|
Label name = new(PackageName(package));
|
|
name.AddToClassList("package-name");
|
|
Label meta = new($"{RarityPresentation.ForStars(package.Rarity).Badge} Lv {owned.UpgradeLevel}/{PackageTuning.MaxPackageLevel}");
|
|
meta.AddToClassList("package-meta");
|
|
summary.Add(marker);
|
|
summary.Add(name);
|
|
summary.Add(meta);
|
|
row.Add(summary);
|
|
|
|
Label effect = new(FormatPackageEffect(package, owned.UpgradeLevel, _equipWindowUnit.Id));
|
|
effect.AddToClassList("package-description");
|
|
row.Add(effect);
|
|
|
|
VisualElement tags = new();
|
|
tags.AddToClassList("package-equip-tags");
|
|
string equippedOn = FindEquippedDistroName(package.Id);
|
|
if (!string.IsNullOrWhiteSpace(equippedOn))
|
|
{
|
|
Label equippedTag = new($"equipped on {equippedOn}");
|
|
equippedTag.AddToClassList("package-notice");
|
|
tags.Add(equippedTag);
|
|
}
|
|
|
|
if (package.IsIntendedFor(_equipWindowUnit.Id))
|
|
{
|
|
Label intended = new("on-distro");
|
|
intended.AddToClassList("package-notice");
|
|
tags.Add(intended);
|
|
}
|
|
|
|
if (tags.childCount > 0)
|
|
{
|
|
row.Add(tags);
|
|
}
|
|
|
|
return row;
|
|
}
|
|
|
|
private void EquipPackageFromWindow(DistroDefinition unit, PackageSlot slot, PackageDefinition package, bool isEquipped)
|
|
{
|
|
if (isEquipped)
|
|
{
|
|
UnequipPackageFromWindow(unit, slot);
|
|
return;
|
|
}
|
|
|
|
if (EquipOrSwapPackage(unit, slot, package))
|
|
{
|
|
ClosePackageEquipWindow();
|
|
RenderUnitDetail(unit);
|
|
ViewChanged?.Invoke();
|
|
return;
|
|
}
|
|
|
|
RenderPackageEquipWindow();
|
|
}
|
|
|
|
private bool EquipOrSwapPackage(DistroDefinition unit, PackageSlot slot, PackageDefinition package)
|
|
{
|
|
if (unit == null || package == null || _packageLoadout == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
PackageDefinition currentlyEquipped = _packageLoadout.GetEquippedPackage(unit.Id, slot);
|
|
if (currentlyEquipped != null && !string.Equals(currentlyEquipped.Id, package.Id, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
if (!_packageLoadout.TryUnequip(unit.Id, slot, out PackageLoadoutFailureReason unequipReason))
|
|
{
|
|
_packageSlotNotice = FormatPackageFailure(unequipReason);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!_packageLoadout.TryEquip(unit.Id, slot, package.Id, out PackageLoadoutFailureReason equipReason))
|
|
{
|
|
_packageSlotNotice = FormatPackageFailure(equipReason);
|
|
return false;
|
|
}
|
|
|
|
_packageSlotNotice = null;
|
|
_packageLoadoutChanged?.Invoke();
|
|
return true;
|
|
}
|
|
|
|
private void UnequipPackageFromWindow(DistroDefinition unit, PackageSlot slot)
|
|
{
|
|
PackageDefinition equipped = _packageLoadout.GetEquippedPackage(unit.Id, slot);
|
|
if (equipped == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (TogglePackage(unit, slot, equipped, true))
|
|
{
|
|
ClosePackageEquipWindow();
|
|
RenderUnitDetail(unit);
|
|
ViewChanged?.Invoke();
|
|
return;
|
|
}
|
|
|
|
RenderPackageEquipWindow();
|
|
}
|
|
|
|
private void AddVersionUpgradePanel(VisualElement target, DistroDefinition unit)
|
|
{
|
|
int version = _playerCollection == null ? 1 : Mathf.Clamp(_playerCollection.GetVersion(unit.Id), 1, GachaTuning.MaxVersion);
|
|
string release = DistroVersionCatalog.GetReleaseLabel(unit.Id, version);
|
|
int merges = _getMergesBalance?.Invoke(unit) ?? 0;
|
|
|
|
VisualElement panel = new();
|
|
panel.AddToClassList("version-upgrade-panel");
|
|
|
|
VisualElement summary = new();
|
|
summary.AddToClassList("version-upgrade-summary");
|
|
|
|
Label current = new($"{DistroPresentation.DisplayName(unit)} {release} v{version}/{GachaTuning.MaxVersion}");
|
|
current.AddToClassList("version-upgrade-current");
|
|
summary.Add(current);
|
|
|
|
Label wallet = new(version < GachaTuning.MaxVersion ? $"{unit.DisplayName} merges {merges} / {GachaTuning.GetVersionUpgradeCost(version + 1)}" : $"{unit.DisplayName} merges {merges}");
|
|
wallet.AddToClassList("version-upgrade-wallet");
|
|
summary.Add(wallet);
|
|
panel.Add(summary);
|
|
|
|
if (version < GachaTuning.MaxVersion)
|
|
{
|
|
int targetVersion = version + 1;
|
|
int cost = GachaTuning.GetVersionUpgradeCost(targetVersion);
|
|
Label next = new($"next {DistroVersionCatalog.GetReleaseLabel(unit.Id, targetVersion)} - {DistroVersionCatalog.GetEffectSummary(unit.Id, targetVersion)}");
|
|
next.AddToClassList("version-upgrade-next");
|
|
panel.Add(next);
|
|
|
|
bool affordable = merges >= cost;
|
|
wallet.EnableInClassList(affordable ? "version-upgrade-wallet-affordable" : "version-upgrade-wallet-warning", true);
|
|
panel.Add(BuildCompactUpgradeCommand($"> apt full-upgrade ({cost} merges)", affordable ? "ready" : "insufficient merges", affordable && _tryUpgradeUnit != null, () => UpgradeUnit(unit)));
|
|
}
|
|
else
|
|
{
|
|
Label next = new("latest release installed");
|
|
next.AddToClassList("version-upgrade-next");
|
|
panel.Add(next);
|
|
panel.Add(BuildCompactUpgradeCommand("> apt full-upgrade", "latest release", false, null));
|
|
}
|
|
|
|
VisualElement path = new();
|
|
path.AddToClassList("version-roadmap");
|
|
for (int i = 1; i <= GachaTuning.MaxVersion; i++)
|
|
{
|
|
bool owned = i <= version;
|
|
bool next = i == version + 1;
|
|
int cost = i <= 1 ? 0 : GachaTuning.GetVersionUpgradeCost(i);
|
|
string className = owned ? "version-path-owned" : next ? "version-path-next" : "version-path-locked";
|
|
string costText = owned || i <= 1 ? string.Empty : $" ({cost} merges)";
|
|
Label step = new($"v{i} {DistroVersionCatalog.GetReleaseLabel(unit.Id, i)} - {DistroVersionCatalog.GetEffectSummary(unit.Id, i)}{costText}");
|
|
step.AddToClassList("version-roadmap-step");
|
|
step.AddToClassList(className);
|
|
path.Add(step);
|
|
}
|
|
|
|
panel.Add(path);
|
|
target.Add(panel);
|
|
}
|
|
|
|
private void UpgradeUnit(DistroDefinition unit)
|
|
{
|
|
if (unit == null || _tryUpgradeUnit == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
VersionUpgradeResult result = _tryUpgradeUnit(unit);
|
|
RenderUnitDetail(unit);
|
|
if (!result.Success)
|
|
{
|
|
_detail.Add(BuildDetailLine("upgrade", FormatUpgradeFailure(result.FailureReason)));
|
|
}
|
|
}
|
|
|
|
private void UpgradePackage(OwnedPackageInstance package)
|
|
{
|
|
bool inventoryMode = _mode == CollectionMode.Packages;
|
|
PackageUpgradeResult result = _tryUpgradePackage == null ? new PackageUpgradeResult(false, PackageUpgradeFailureReason.NotOwned, 0, 0, 0) : _tryUpgradePackage(package);
|
|
RefreshAfterPackageAction(inventoryMode);
|
|
if (!result.Success)
|
|
{
|
|
_detail.Add(BuildDetailLine("package upgrade", FormatPackageUpgradeFailure(result.FailureReason)));
|
|
}
|
|
}
|
|
|
|
private void ScrapPackage(OwnedPackageInstance package)
|
|
{
|
|
if (package == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool inventoryMode = _mode == CollectionMode.Packages;
|
|
if (!string.Equals(_pendingScrapPackageId, package.PackageId, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
_pendingScrapPackageId = package.PackageId;
|
|
RefreshAfterPackageAction(inventoryMode);
|
|
return;
|
|
}
|
|
|
|
PackageScrapResult result = _tryScrapPackage == null ? new PackageScrapResult(false, PackageScrapFailureReason.NotOwned, 0, 0) : _tryScrapPackage(package);
|
|
_pendingScrapPackageId = null;
|
|
RefreshAfterPackageAction(inventoryMode);
|
|
if (!result.Success)
|
|
{
|
|
_detail.Add(BuildDetailLine("package scrap", FormatPackageScrapFailure(result.FailureReason)));
|
|
}
|
|
}
|
|
|
|
// Wired upgrade/scrap callbacks (MainMenuController) may call RefreshUnits() internally,
|
|
// which forces CollectionMode.Units and re-renders. Restore the caller's actual view so
|
|
// the Packages inventory screen (and its keyboard navigation) don't get bumped to Units.
|
|
private void RefreshAfterPackageAction(bool inventoryMode)
|
|
{
|
|
if (inventoryMode)
|
|
{
|
|
_mode = CollectionMode.Packages;
|
|
RenderPackages();
|
|
return;
|
|
}
|
|
|
|
if (_units.Count > 0)
|
|
{
|
|
RenderUnitDetail(_units[_selectedUnitIndex]);
|
|
}
|
|
}
|
|
|
|
private void RenderLanguageDetail(LanguageCatalogEntry language)
|
|
{
|
|
_detail.Clear();
|
|
bool unlocked = LanguageUnlock.IsUnlocked(language.Language, _playerCollection);
|
|
|
|
Label name = new(language.DisplayName);
|
|
name.AddToClassList("collection-detail-name");
|
|
_detail.Add(name);
|
|
_detail.Add(BuildDetailLine("track", language.ResolutionTrack.ToString()));
|
|
|
|
Label how = new(language.HowItWorks);
|
|
how.AddToClassList("collection-detail-description");
|
|
_detail.Add(how);
|
|
|
|
if (!unlocked)
|
|
{
|
|
string hintText = string.IsNullOrWhiteSpace(language.UnlockHint)
|
|
? $"unlock: own a distro that speaks {language.DisplayName} ({FormatSupportingDistros(language)})"
|
|
: language.UnlockHint;
|
|
Label hint = new(hintText);
|
|
hint.AddToClassList("package-notice");
|
|
_detail.Add(hint);
|
|
return;
|
|
}
|
|
|
|
_detail.Add(BuildSubviewCommand($"cat ~/lang/{GetLanguageId(language.Language)}/deck", "starter deck", true, () => OpenLanguageDeck(language), null));
|
|
}
|
|
|
|
private void OpenUnitCards(DistroDefinition unit)
|
|
{
|
|
if (!HasListableCards(unit))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_returnMode = _mode == CollectionMode.UnitDetail ? CollectionMode.UnitDetail : CollectionMode.Units;
|
|
_cards = BuildUnitCardEntries(unit);
|
|
_emptyCardMessage = "no packages installed";
|
|
CurrentTitle = $"$ cat ~/units/{unit.Id}/cards";
|
|
CurrentHint = "[esc] back [arrows] navigate";
|
|
RenderCardSubview();
|
|
ViewChanged?.Invoke();
|
|
}
|
|
|
|
private void OpenLanguageDeck(LanguageCatalogEntry language)
|
|
{
|
|
_returnMode = CollectionMode.Languages;
|
|
_cards = BuildStarterDeckEntries(language);
|
|
_emptyCardMessage = "starter deck not yet available";
|
|
CurrentTitle = $"$ cat ~/lang/{GetLanguageId(language.Language)}/deck";
|
|
CurrentHint = "[esc] back [arrows] navigate";
|
|
RenderCardSubview();
|
|
ViewChanged?.Invoke();
|
|
}
|
|
|
|
private void RenderCardSubview()
|
|
{
|
|
_mode = CollectionMode.CardSubview;
|
|
_rows.Clear();
|
|
_list.Clear();
|
|
_detail.Clear();
|
|
_list.RemoveFromClassList("hidden");
|
|
_detailScroll?.RemoveFromClassList("collection-detail-full");
|
|
if (_detailScroll != null)
|
|
{
|
|
_detailScroll.verticalScrollerVisibility = ScrollerVisibility.Auto;
|
|
}
|
|
|
|
_selectedCardIndex = Mathf.Clamp(_selectedCardIndex, 0, Math.Max(0, _cards.Count - 1));
|
|
|
|
if (_cards.Count == 0)
|
|
{
|
|
_detail.Add(new Label(_emptyCardMessage) { name = "CollectionEmptyTitle" });
|
|
_detail.Add(new Label("check back after deck data is installed") { name = "CollectionEmptyHint" });
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < _cards.Count; i++)
|
|
{
|
|
int index = i;
|
|
CardEntry entry = _cards[i];
|
|
VisualElement row = BuildCardRow(entry);
|
|
row.RegisterCallback<PointerEnterEvent>(_ => SelectCard(index));
|
|
row.RegisterCallback<ClickEvent>(_ => SelectCard(index));
|
|
_list.Add(row);
|
|
_rows.Add(row);
|
|
}
|
|
|
|
SelectCard(_selectedCardIndex);
|
|
}
|
|
|
|
private VisualElement BuildCardRow(CardEntry entry)
|
|
{
|
|
VisualElement row = new();
|
|
row.AddToClassList("package-row");
|
|
row.AddToClassList("collection-card-row");
|
|
|
|
VisualElement summary = new();
|
|
summary.AddToClassList("package-summary");
|
|
|
|
Label count = new(entry.Count > 1 ? $"x{entry.Count}" : string.Empty);
|
|
count.AddToClassList("package-marker");
|
|
Label name = new(GetCardDisplayName(entry.Card));
|
|
name.AddToClassList("package-name");
|
|
Label meta = new(FormatCardMeta(entry.Card));
|
|
meta.AddToClassList("package-meta");
|
|
|
|
summary.Add(count);
|
|
summary.Add(name);
|
|
summary.Add(meta);
|
|
row.Add(summary);
|
|
|
|
Label description = new(entry.Card == null || string.IsNullOrWhiteSpace(entry.Card.Description) ? "--" : entry.Card.Description);
|
|
description.AddToClassList("package-description");
|
|
row.Add(description);
|
|
return row;
|
|
}
|
|
|
|
private void RenderCardDetail(CardEntry entry)
|
|
{
|
|
_detail.Clear();
|
|
|
|
CardDefinition card = entry.Card;
|
|
Label name = new(GetCardDisplayName(card));
|
|
name.AddToClassList("collection-detail-name");
|
|
_detail.Add(name);
|
|
|
|
Label description = new(card == null || string.IsNullOrWhiteSpace(card.Description) ? "--" : card.Description);
|
|
description.AddToClassList("collection-detail-description");
|
|
_detail.Add(description);
|
|
|
|
if (card != null && !string.IsNullOrWhiteSpace(card.FlavorText))
|
|
{
|
|
Label flavor = new(card.FlavorText);
|
|
flavor.AddToClassList("flavor-text");
|
|
_detail.Add(flavor);
|
|
}
|
|
|
|
_detail.Add(BuildDetailLine("lang", card == null ? "--" : card.Language.ToString()));
|
|
_detail.Add(BuildDetailLine("rarity", card == null ? "--" : card.Rarity.ToString()));
|
|
_detail.Add(BuildDetailLine("cost", card == null ? "--" : card.CycleCost.ToString()));
|
|
_detail.Add(BuildDetailLine("track", card == null ? "--" : card.ResolutionTrack.ToString()));
|
|
}
|
|
|
|
private static VisualElement BuildDetailLine(string key, string value)
|
|
{
|
|
VisualElement row = new();
|
|
row.AddToClassList("kv-row");
|
|
|
|
Label keyLabel = new(key);
|
|
keyLabel.AddToClassList("kv-key");
|
|
Label valueLabel = new(value);
|
|
valueLabel.AddToClassList("kv-value");
|
|
|
|
row.Add(keyLabel);
|
|
row.Add(valueLabel);
|
|
return row;
|
|
}
|
|
|
|
private static VisualElement BuildPackagePreviewLine(string key, string value)
|
|
{
|
|
VisualElement row = new();
|
|
row.AddToClassList("package-preview-line");
|
|
|
|
Label keyLabel = new(key);
|
|
keyLabel.AddToClassList("package-preview-key");
|
|
Label valueLabel = new(value);
|
|
valueLabel.AddToClassList("package-preview-value");
|
|
|
|
row.Add(keyLabel);
|
|
row.Add(valueLabel);
|
|
return row;
|
|
}
|
|
|
|
private VisualElement BuildSubviewCommand(string command, string description, bool enabled, Action action, string disabledDescription)
|
|
{
|
|
VisualElement row = new();
|
|
row.AddToClassList("command-row");
|
|
row.AddToClassList("collection-command-row");
|
|
row.EnableInClassList("disabled-row", !enabled);
|
|
|
|
Label cursor = new(">");
|
|
cursor.AddToClassList("command-cursor");
|
|
Label commandLabel = new(command);
|
|
commandLabel.AddToClassList("command-text");
|
|
Label descriptionLabel = new(enabled ? description : disabledDescription);
|
|
descriptionLabel.AddToClassList("command-description");
|
|
|
|
row.Add(cursor);
|
|
row.Add(commandLabel);
|
|
row.Add(descriptionLabel);
|
|
|
|
if (enabled)
|
|
{
|
|
row.RegisterCallback<ClickEvent>(_ => action?.Invoke());
|
|
}
|
|
|
|
return row;
|
|
}
|
|
|
|
private static VisualElement BuildCompactUpgradeCommand(string command, string state, bool enabled, Action action)
|
|
{
|
|
VisualElement row = new();
|
|
row.AddToClassList("version-upgrade-command");
|
|
row.EnableInClassList("disabled-row", !enabled);
|
|
|
|
Label commandLabel = new(command);
|
|
commandLabel.AddToClassList("version-upgrade-command-text");
|
|
Label stateLabel = new(state);
|
|
stateLabel.AddToClassList("version-upgrade-command-state");
|
|
|
|
row.Add(commandLabel);
|
|
row.Add(stateLabel);
|
|
|
|
if (enabled)
|
|
{
|
|
row.RegisterCallback<ClickEvent>(_ => action?.Invoke());
|
|
}
|
|
|
|
return row;
|
|
}
|
|
|
|
private static void AddPassiveDetails(VisualElement target, DistroDefinition unit)
|
|
{
|
|
if (unit.Passive == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Label passiveTitle = new(unit.Passive.Name);
|
|
passiveTitle.AddToClassList("detail-section-title");
|
|
target.Add(passiveTitle);
|
|
|
|
Label passiveRules = new(unit.Passive.RulesText);
|
|
passiveRules.AddToClassList("collection-detail-description");
|
|
target.Add(passiveRules);
|
|
|
|
if (!string.IsNullOrWhiteSpace(unit.Passive.FlavorText))
|
|
{
|
|
Label passiveFlavor = new(unit.Passive.FlavorText);
|
|
passiveFlavor.AddToClassList("flavor-text");
|
|
target.Add(passiveFlavor);
|
|
}
|
|
}
|
|
|
|
private static IReadOnlyList<CardEntry> BuildUnitCardEntries(DistroDefinition unit)
|
|
{
|
|
List<CardEntry> entries = new();
|
|
if (unit == null)
|
|
{
|
|
return entries;
|
|
}
|
|
|
|
for (int cardIndex = 0; cardIndex < unit.ExclusiveCards.Count; cardIndex++)
|
|
{
|
|
CardDefinition card = unit.ExclusiveCards[cardIndex];
|
|
if (card == null || card.IsToken || card.IsRunOnly)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
entries.Add(new CardEntry(unit, card, 1));
|
|
}
|
|
|
|
return entries;
|
|
}
|
|
|
|
private IReadOnlyList<CardEntry> BuildStarterDeckEntries(LanguageCatalogEntry language)
|
|
{
|
|
LanguageDeckDefinition deck = _languageDeckDatabase == null ? null : _languageDeckDatabase.FindByLanguage(language.Language);
|
|
if (deck == null)
|
|
{
|
|
return BuildRegisteredStarterDeckEntries(language.Language);
|
|
}
|
|
|
|
List<CardEntry> entries = new();
|
|
for (int i = 0; i < deck.Entries.Count; i++)
|
|
{
|
|
LanguageDeckDefinition.LanguageDeckEntry deckEntry = deck.Entries[i];
|
|
if (deckEntry.Card == null || deckEntry.Card.IsRunOnly || deckEntry.Count <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
entries.Add(new CardEntry(null, deckEntry.Card, deckEntry.Count));
|
|
}
|
|
|
|
return entries;
|
|
}
|
|
|
|
private IReadOnlyList<CardEntry> BuildRegisteredStarterDeckEntries(Language language)
|
|
{
|
|
if (_cardDatabase == null)
|
|
{
|
|
return Array.Empty<CardEntry>();
|
|
}
|
|
|
|
return language switch
|
|
{
|
|
Language.Python => BuildRegisteredStarterDeckEntries(
|
|
("lang_py_print", 2),
|
|
("lang_py_import_antigravity", 1),
|
|
("lang_py_for_loop", 1)),
|
|
Language.JavaScript => BuildRegisteredStarterDeckEntries(
|
|
("lang_js_console_log", 2),
|
|
("lang_js_fetch", 1),
|
|
("lang_js_typeof", 1)),
|
|
_ => Array.Empty<CardEntry>()
|
|
};
|
|
}
|
|
|
|
private IReadOnlyList<CardEntry> BuildRegisteredStarterDeckEntries(params (string Id, int Count)[] cardRefs)
|
|
{
|
|
List<CardEntry> entries = new();
|
|
for (int i = 0; i < cardRefs.Length; i++)
|
|
{
|
|
CardDefinition card = _cardDatabase.FindById(cardRefs[i].Id);
|
|
if (card == null || card.IsRunOnly)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
entries.Add(new CardEntry(null, card, cardRefs[i].Count));
|
|
}
|
|
|
|
return entries;
|
|
}
|
|
|
|
private static bool HasListableCards(DistroDefinition unit)
|
|
{
|
|
return BuildUnitCardEntries(unit).Count > 0;
|
|
}
|
|
|
|
private string FormatSupportingDistros(LanguageCatalogEntry language)
|
|
{
|
|
List<string> names = new();
|
|
for (int i = 0; i < language.SupportingDistros.Count; i++)
|
|
{
|
|
names.Add(language.SupportingDistros[i].DisplayName);
|
|
}
|
|
|
|
return string.Join(", ", names);
|
|
}
|
|
|
|
private static string GetCardDisplayName(CardDefinition card)
|
|
{
|
|
if (card == null)
|
|
{
|
|
return "--";
|
|
}
|
|
|
|
return string.IsNullOrWhiteSpace(card.DisplayName) ? card.Id : card.DisplayName;
|
|
}
|
|
|
|
private static string FormatCardMeta(CardDefinition card)
|
|
{
|
|
return card == null ? "--" : $"{card.Language} / {card.CycleCost}c";
|
|
}
|
|
|
|
private static string PackageName(PackageDefinition package)
|
|
{
|
|
return package == null ? "--" : string.IsNullOrWhiteSpace(package.DisplayName) ? package.Id : package.DisplayName;
|
|
}
|
|
|
|
private static string FormatPackageEffect(PackageDefinition package, int upgradeLevel, string distroId)
|
|
{
|
|
if (package == null)
|
|
{
|
|
return "--";
|
|
}
|
|
|
|
string summary = FormatEffectSummary(package.EffectFor(distroId), upgradeLevel);
|
|
if (!string.IsNullOrWhiteSpace(summary))
|
|
{
|
|
return summary;
|
|
}
|
|
|
|
return string.IsNullOrWhiteSpace(package.Description) ? "--" : package.Description;
|
|
}
|
|
|
|
private static string OneLineEffect(PackageDefinition package, int upgradeLevel, string distroId)
|
|
{
|
|
if (package == null)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
string text = FormatEffectSummary(package.EffectFor(distroId), upgradeLevel);
|
|
if (string.IsNullOrWhiteSpace(text) && !string.IsNullOrWhiteSpace(package.Description))
|
|
{
|
|
text = package.Description.Trim();
|
|
}
|
|
|
|
int stop = text.IndexOf('.');
|
|
if (stop >= 0)
|
|
{
|
|
text = text.Substring(0, stop + 1);
|
|
}
|
|
|
|
return text.Length > 54 ? $"{text.Substring(0, 51)}..." : text;
|
|
}
|
|
|
|
private static string FormatEffectSummary(PackageEffectData baseEffect, int upgradeLevel)
|
|
{
|
|
PackageEffectData effect = PackageEffectScaling.Scale(baseEffect, upgradeLevel);
|
|
int amount = Math.Max(0, effect.Amount);
|
|
return effect.Kind switch
|
|
{
|
|
PackageEffectKind.None => string.Empty,
|
|
PackageEffectKind.MaxUptime => $"+{amount} max Uptime",
|
|
PackageEffectKind.MaxCycles => $"+{amount} max Cycles",
|
|
PackageEffectKind.MaxRam => $"+{amount} max RAM",
|
|
PackageEffectKind.WaveStartShield => $"+{amount} Shield at wave start",
|
|
PackageEffectKind.FirstTurnEachWaveShield => $"+{amount} Shield on first turn",
|
|
PackageEffectKind.FirstTurnFirstWaveDraw => $"draw {amount} on first turn",
|
|
PackageEffectKind.WaveDraw => $"draw {amount} at wave start",
|
|
PackageEffectKind.FirstTurnEachWaveCycle => $"+{amount} Cycle on first turn",
|
|
PackageEffectKind.WaveGenerateBasicCard => $"generate {amount} basic card(s) at wave start",
|
|
PackageEffectKind.FirstCardEachWaveCostReduction => $"first card each wave costs {amount} less",
|
|
PackageEffectKind.FirstCardsEachTurnCostReduction => $"first card each turn costs {amount} less",
|
|
PackageEffectKind.ThirdCardEachTurnGenerate => $"third card each turn generates {amount} card(s)",
|
|
PackageEffectKind.FirstNativeCardEachWaveFlatDamage => $"first Native card +{amount} damage",
|
|
PackageEffectKind.ExhaustShield => $"+{amount} Shield when exhausting",
|
|
PackageEffectKind.EveryNthTurnShield => $"+{amount} Shield every {effect.Threshold} turns",
|
|
PackageEffectKind.EveryNthTurnDraw => $"draw {amount} every {effect.Threshold} turns",
|
|
PackageEffectKind.FirstInterpreterQueueCardEachWaveShield => $"+{amount} Shield on queued card",
|
|
PackageEffectKind.FirstShieldEachTurnBonus => $"+{amount} extra Shield once/turn",
|
|
PackageEffectKind.EveryNthCardEachWaveFree => $"every {effect.Threshold}th card costs 0",
|
|
PackageEffectKind.EveryNthCardEachWaveCycle => $"+{amount} Cycle every {effect.Threshold} cards",
|
|
PackageEffectKind.StartTurnNoDebuffShield => $"+{amount} Shield if no debuffs",
|
|
PackageEffectKind.JavaScriptFlatDamage => $"+{amount} JavaScript damage",
|
|
PackageEffectKind.WaveThresholdRestore => $"restore {amount} Uptime after wave {effect.Threshold}",
|
|
PackageEffectKind.DnfFedoraPassive => "Fedora passive can trigger twice",
|
|
PackageEffectKind.FirstCThisTurnDamageMultiplier => $"first C card each turn deals {amount}% damage",
|
|
PackageEffectKind.TurnStartGenerateLanguageCard => amount > 0 ? "turn start: generate C/Rust card at -1c" : "turn start: generate common C/Rust card",
|
|
_ => amount > 0 ? $"+{amount} package effect" : "package effect"
|
|
};
|
|
}
|
|
|
|
private string GetUnitDetailHint()
|
|
{
|
|
string action = _unitDetailTab switch
|
|
{
|
|
UnitDetailTab.Upgrade => "[enter/click] upgrade",
|
|
UnitDetailTab.Packages => "[enter/click] select/equip",
|
|
UnitDetailTab.Cards => "[enter] open cards",
|
|
_ => "[read-only]"
|
|
};
|
|
|
|
return $"[esc] back [left/right/tab] tabs {action}";
|
|
}
|
|
|
|
private static string FormatPackageFailure(PackageLoadoutFailureReason reason)
|
|
{
|
|
return reason switch
|
|
{
|
|
PackageLoadoutFailureReason.WrongSlot => "wrong slot",
|
|
PackageLoadoutFailureReason.NotOwned => "package not owned",
|
|
PackageLoadoutFailureReason.SlotOccupied => "slot occupied: unequip current package first",
|
|
PackageLoadoutFailureReason.NotEquipped => "package not equipped",
|
|
_ => "package change failed"
|
|
};
|
|
}
|
|
|
|
private static string FormatUpgradeFailure(VersionUpgradeFailureReason reason)
|
|
{
|
|
return reason switch
|
|
{
|
|
VersionUpgradeFailureReason.NotOwned => "not owned",
|
|
VersionUpgradeFailureReason.MaxVersion => "latest release",
|
|
VersionUpgradeFailureReason.InsufficientMerges => "insufficient merges",
|
|
_ => "upgrade failed"
|
|
};
|
|
}
|
|
|
|
private static string FormatPackageUpgradeFailure(PackageUpgradeFailureReason reason)
|
|
{
|
|
return reason switch
|
|
{
|
|
PackageUpgradeFailureReason.MaxLevel => "max level",
|
|
PackageUpgradeFailureReason.InsufficientCache => "insufficient cache",
|
|
PackageUpgradeFailureReason.InsufficientBandwidth => "insufficient bandwidth",
|
|
PackageUpgradeFailureReason.NotOwned => "not owned",
|
|
_ => "upgrade failed"
|
|
};
|
|
}
|
|
|
|
private static string FormatPackageScrapFailure(PackageScrapFailureReason reason)
|
|
{
|
|
return reason switch
|
|
{
|
|
PackageScrapFailureReason.Equipped => "equipped: unequip first",
|
|
PackageScrapFailureReason.NotOwned => "not owned",
|
|
_ => "scrap failed"
|
|
};
|
|
}
|
|
|
|
private static string GetLanguageId(Language language)
|
|
{
|
|
return language switch
|
|
{
|
|
Language.CPlusPlus => "cpp",
|
|
Language.JavaScript => "javascript",
|
|
Language.TypeScript => "typescript",
|
|
_ => language.ToString().ToLowerInvariant()
|
|
};
|
|
}
|
|
|
|
private enum CollectionMode
|
|
{
|
|
Units,
|
|
Languages,
|
|
Packages,
|
|
UnitDetail,
|
|
CardSubview
|
|
}
|
|
|
|
private enum UnitDetailTab
|
|
{
|
|
Overview,
|
|
Upgrade,
|
|
Packages,
|
|
Cards
|
|
}
|
|
|
|
private readonly struct CardEntry
|
|
{
|
|
public CardEntry(DistroDefinition owner, CardDefinition card, int count)
|
|
{
|
|
Owner = owner;
|
|
Card = card;
|
|
Count = count;
|
|
}
|
|
|
|
public DistroDefinition Owner { get; }
|
|
public CardDefinition Card { get; }
|
|
public int Count { get; }
|
|
}
|
|
}
|
|
}
|