488 lines
18 KiB
C#
488 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using KernelPanic.Data;
|
|
using KernelPanic.Meta;
|
|
using UnityEngine;
|
|
using UnityEngine.TextCore.Text;
|
|
using UnityEngine.UIElements;
|
|
|
|
namespace KernelPanic.UI
|
|
{
|
|
/// <summary>
|
|
/// Renders banner selection and pull controls for the gacha screen.
|
|
/// </summary>
|
|
[Serializable]
|
|
public sealed class GachaScreenController
|
|
{
|
|
private const string SelectedClassName = "selected";
|
|
|
|
private readonly List<VisualElement> bannerRows = new();
|
|
private readonly string[] bannerIds =
|
|
{
|
|
GachaService.BeginnerBannerId,
|
|
GachaService.StandardBannerId,
|
|
GachaService.LimitedBannerId
|
|
};
|
|
|
|
private VisualElement bannerList;
|
|
private VisualElement bannerDetail;
|
|
private DistroDatabase distroDatabase;
|
|
private FontAsset monospaceFont;
|
|
private GachaService gachaService;
|
|
private PlayerCollection playerCollection;
|
|
private EntropyWallet wallet;
|
|
private Action onChanged;
|
|
private Action requestRootCreditExchange;
|
|
private int selectedBannerIndex;
|
|
private int pendingPullCount;
|
|
private int pendingMissingTokens;
|
|
private bool hasOpened;
|
|
private string resultBannerId;
|
|
private string resultText;
|
|
|
|
public void Bind(VisualElement root, DistroDatabase database, FontAsset artFont, GachaService service, PlayerCollection collection, EntropyWallet entropyWallet, Action changedCallback, Action rootCreditExchangeCallback)
|
|
{
|
|
distroDatabase = database;
|
|
monospaceFont = artFont;
|
|
gachaService = service;
|
|
playerCollection = collection;
|
|
wallet = entropyWallet;
|
|
onChanged = changedCallback;
|
|
requestRootCreditExchange = rootCreditExchangeCallback;
|
|
bannerList = root.Q<VisualElement>("GachaBannerList");
|
|
bannerDetail = root.Q<VisualElement>("GachaBannerDetail");
|
|
}
|
|
|
|
public void Open()
|
|
{
|
|
if (!hasOpened)
|
|
{
|
|
selectedBannerIndex = 0;
|
|
hasOpened = true;
|
|
}
|
|
|
|
Refresh();
|
|
}
|
|
|
|
public void Refresh()
|
|
{
|
|
if (bannerList == null || bannerDetail == null || gachaService == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bannerRows.Clear();
|
|
bannerList.Clear();
|
|
|
|
for (int i = 0; i < bannerIds.Length; i++)
|
|
{
|
|
int index = i;
|
|
VisualElement row = BuildBannerRow(bannerIds[i]);
|
|
row.RegisterCallback<ClickEvent>(_ => SelectBanner(index));
|
|
bannerList.Add(row);
|
|
bannerRows.Add(row);
|
|
}
|
|
|
|
selectedBannerIndex = Mathf.Clamp(selectedBannerIndex, 0, bannerRows.Count - 1);
|
|
ApplySelectedBanner();
|
|
}
|
|
|
|
public void HandleKeyDown(KeyDownEvent evt)
|
|
{
|
|
// Pulls are deliberately click-only to avoid accidental currency spend.
|
|
}
|
|
|
|
private VisualElement BuildBannerRow(string bannerId)
|
|
{
|
|
VisualElement row = new();
|
|
row.AddToClassList("gacha-banner-row");
|
|
|
|
row.Add(new Label(">") { name = $"GachaBannerCursor_{bannerId}" });
|
|
row.ElementAt(0).AddToClassList("command-cursor");
|
|
|
|
row.Add(new Label(GetBannerTitle(bannerId)) { name = $"GachaBannerName_{bannerId}" });
|
|
row.ElementAt(1).AddToClassList("command-text");
|
|
|
|
row.Add(new Label(GetBannerStatus(bannerId)) { name = $"GachaBannerStatus_{bannerId}" });
|
|
row.ElementAt(2).AddToClassList("command-description");
|
|
|
|
return row;
|
|
}
|
|
|
|
private void SelectBanner(int index)
|
|
{
|
|
if (bannerRows.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
selectedBannerIndex = (index + bannerRows.Count) % bannerRows.Count;
|
|
ApplySelectedBanner();
|
|
}
|
|
|
|
private void ApplySelectedBanner()
|
|
{
|
|
for (int i = 0; i < bannerRows.Count; i++)
|
|
{
|
|
bool selected = i == selectedBannerIndex;
|
|
bannerRows[i].EnableInClassList(SelectedClassName, selected);
|
|
bannerRows[i].Q<Label>(className: "command-cursor").visible = selected;
|
|
}
|
|
|
|
RenderSelectedBanner();
|
|
}
|
|
|
|
private void RenderSelectedBanner()
|
|
{
|
|
bannerDetail.Clear();
|
|
string bannerId = bannerIds[selectedBannerIndex];
|
|
if (bannerId == GachaService.BeginnerBannerId)
|
|
{
|
|
RenderBeginnerBanner();
|
|
return;
|
|
}
|
|
|
|
RenderFutureBanner(bannerId);
|
|
}
|
|
|
|
private void RenderBeginnerBanner()
|
|
{
|
|
GachaBannerState state = gachaService.BeginnerState;
|
|
bannerDetail.Add(BuildBannerHero("beginner install media"));
|
|
|
|
Label title = new("beginner install media");
|
|
title.AddToClassList("gacha-detail-title");
|
|
bannerDetail.Add(title);
|
|
|
|
bannerDetail.Add(BuildInfoLine("entropy", wallet == null ? "--" : wallet.Balance.ToString()));
|
|
bannerDetail.Add(BuildInfoLine("pulls", $"{state.totalPulls}/{GachaService.BeginnerMaxPulls}"));
|
|
bannerDetail.Add(BuildInfoLine("4-star pity", $"{state.pityCounter}/{GachaService.FourStarHardPity}"));
|
|
bannerDetail.Add(BuildInfoLine("ten pull", $"{GachaService.BeginnerTenPullCost} stable-pull-tokens for 10 pulls"));
|
|
bannerDetail.Add(BuildInfoLine("guarantees", FormatBeginnerGuarantees()));
|
|
|
|
Label rules = new("Base result is a 3-star equipment cache. A 4-star equipment cache or starter distro can appear early, with one 4-star+ result guaranteed every 10 pulls.");
|
|
rules.AddToClassList("gacha-rules");
|
|
bannerDetail.Add(rules);
|
|
|
|
VisualElement actions = new();
|
|
actions.AddToClassList("gacha-actions");
|
|
|
|
Button singleButton = new(() => RequestPullSelectedBanner(1))
|
|
{
|
|
text = $"git pull --single\n1x {GachaService.FormatCurrencyName(GachaCurrencyType.StandardPull)}"
|
|
};
|
|
singleButton.AddToClassList("terminal-button");
|
|
singleButton.AddToClassList("gacha-action-button");
|
|
singleButton.SetEnabled(CanAttemptBeginnerPull(1));
|
|
actions.Add(singleButton);
|
|
|
|
Button tenButton = new(() => RequestPullSelectedBanner(10))
|
|
{
|
|
text = $"git pull --ten\n8x {GachaService.FormatCurrencyName(GachaCurrencyType.StandardPull)}"
|
|
};
|
|
tenButton.AddToClassList("terminal-button");
|
|
tenButton.AddToClassList("gacha-action-button");
|
|
tenButton.SetEnabled(CanAttemptBeginnerPull(10));
|
|
actions.Add(tenButton);
|
|
|
|
bannerDetail.Add(actions);
|
|
|
|
if (pendingPullCount > 0)
|
|
{
|
|
bannerDetail.Add(BuildEntropyPrompt());
|
|
}
|
|
|
|
if (resultBannerId == GachaService.BeginnerBannerId && !string.IsNullOrWhiteSpace(resultText))
|
|
{
|
|
Label result = new(resultText);
|
|
result.AddToClassList("gacha-result");
|
|
bannerDetail.Add(result);
|
|
}
|
|
}
|
|
|
|
private void RenderFutureBanner(string bannerId)
|
|
{
|
|
bannerDetail.Add(BuildBannerHero(GetBannerTitle(bannerId)));
|
|
|
|
Label title = new(GetBannerTitle(bannerId));
|
|
title.AddToClassList("gacha-detail-title");
|
|
bannerDetail.Add(title);
|
|
|
|
string currency = bannerId == GachaService.StandardBannerId
|
|
? GachaService.FormatCurrencyName(GachaCurrencyType.StandardPull)
|
|
: GachaService.FormatCurrencyName(GachaCurrencyType.LimitedPull);
|
|
bannerDetail.Add(BuildInfoLine("pull currency", currency));
|
|
bannerDetail.Add(BuildInfoLine("status", "not implemented yet"));
|
|
bannerDetail.Add(BuildInfoLine("pity", "own counter, 10-pull 4-star+ guarantee"));
|
|
bannerDetail.Add(new Label("Use the beginner implementation as the template: define the banner pool, persist a separate GachaBannerState, then route single/ten pulls through GachaService.") { name = "FutureBannerHint" });
|
|
bannerDetail.ElementAt(bannerDetail.childCount - 1).AddToClassList("gacha-rules");
|
|
|
|
if (resultBannerId == bannerId && !string.IsNullOrWhiteSpace(resultText))
|
|
{
|
|
Label result = new(resultText);
|
|
result.AddToClassList("gacha-result");
|
|
bannerDetail.Add(result);
|
|
}
|
|
}
|
|
|
|
private void PullSelectedBanner(int pullCount, int entropyTokenCount)
|
|
{
|
|
string bannerId = bannerIds[selectedBannerIndex];
|
|
if (bannerId != GachaService.BeginnerBannerId)
|
|
{
|
|
resultBannerId = bannerId;
|
|
resultText = $"git pull origin {bannerId}: remote not implemented yet";
|
|
RenderSelectedBanner();
|
|
return;
|
|
}
|
|
|
|
GachaPullResult result = gachaService.PerformBeginnerPull(pullCount, wallet, entropyTokenCount);
|
|
if (!result.Success)
|
|
{
|
|
resultBannerId = bannerId;
|
|
resultText = $"git pull failed: {result.FailureReason}";
|
|
RenderSelectedBanner();
|
|
return;
|
|
}
|
|
|
|
List<string> lines = new();
|
|
lines.Add($"git pull complete: spent {result.CurrencySpent} {GachaService.FormatCurrencyName(result.CurrencyType)}");
|
|
if (result.EntropySpent > 0)
|
|
{
|
|
lines.Add($"entropy fallback: spent {result.EntropySpent} entropy");
|
|
}
|
|
|
|
for (int i = 0; i < result.Rewards.Count; i++)
|
|
{
|
|
GachaReward reward = result.Rewards[i];
|
|
bool duplicate = reward.Distro != null && playerCollection.GetOwnedCount(reward.Distro.Id) > 0;
|
|
if (reward.Distro != null)
|
|
{
|
|
playerCollection.Add(reward.Distro);
|
|
}
|
|
|
|
string suffix = reward.Guaranteed ? " guaranteed" : reward.PityTriggered ? " pity" : string.Empty;
|
|
string duplicateText = duplicate ? " duplicate" : string.Empty;
|
|
lines.Add($"{i + 1:00}: {reward.StarRating}-star {reward.DisplayName}{suffix}{duplicateText}");
|
|
}
|
|
|
|
resultBannerId = bannerId;
|
|
resultText = string.Join("\n", lines);
|
|
onChanged?.Invoke();
|
|
Refresh();
|
|
}
|
|
|
|
private void RequestPullSelectedBanner(int pullCount)
|
|
{
|
|
string bannerId = bannerIds[selectedBannerIndex];
|
|
if (bannerId != GachaService.BeginnerBannerId)
|
|
{
|
|
PullSelectedBanner(pullCount, 0);
|
|
return;
|
|
}
|
|
|
|
int cost = gachaService.GetBeginnerPullCost(pullCount);
|
|
int missingTokens = gachaService.GetMissingPullTokens(GachaCurrencyType.StandardPull, cost);
|
|
if (missingTokens <= 0)
|
|
{
|
|
ClearEntropyPrompt();
|
|
PullSelectedBanner(pullCount, 0);
|
|
return;
|
|
}
|
|
|
|
if (!gachaService.CanCoverMissingPullTokensWithEntropy(wallet, missingTokens))
|
|
{
|
|
if (gachaService.RootCredits > 0)
|
|
{
|
|
requestRootCreditExchange?.Invoke();
|
|
return;
|
|
}
|
|
|
|
resultBannerId = bannerId;
|
|
resultText = $"git pull failed: need {missingTokens} {GachaService.FormatCurrencyName(GachaCurrencyType.StandardPull)} or {missingTokens * GachaService.EntropyPerPullToken} entropy";
|
|
RenderSelectedBanner();
|
|
return;
|
|
}
|
|
|
|
pendingPullCount = pullCount;
|
|
pendingMissingTokens = missingTokens;
|
|
resultBannerId = bannerId;
|
|
resultText = null;
|
|
RenderSelectedBanner();
|
|
}
|
|
|
|
private VisualElement BuildEntropyPrompt()
|
|
{
|
|
VisualElement prompt = new();
|
|
prompt.AddToClassList("gacha-entropy-prompt");
|
|
|
|
int entropyCost = pendingMissingTokens * GachaService.EntropyPerPullToken;
|
|
Label copy = new($"missing {pendingMissingTokens} stable-pull-token(s). spend {entropyCost} entropy to complete git pull?");
|
|
copy.AddToClassList("gacha-result");
|
|
prompt.Add(copy);
|
|
|
|
VisualElement actions = new();
|
|
actions.AddToClassList("gacha-actions");
|
|
|
|
Button cancel = new(() =>
|
|
{
|
|
ClearEntropyPrompt();
|
|
RenderSelectedBanner();
|
|
})
|
|
{
|
|
text = "git pull --abort"
|
|
};
|
|
cancel.AddToClassList("terminal-button");
|
|
cancel.AddToClassList("gacha-action-button");
|
|
actions.Add(cancel);
|
|
|
|
Button confirm = new(() =>
|
|
{
|
|
int pullCount = pendingPullCount;
|
|
int missingTokens = pendingMissingTokens;
|
|
ClearEntropyPrompt();
|
|
PullSelectedBanner(pullCount, missingTokens);
|
|
})
|
|
{
|
|
text = $"git pull --use-entropy={entropyCost}"
|
|
};
|
|
confirm.AddToClassList("terminal-button");
|
|
confirm.AddToClassList("gacha-action-button");
|
|
actions.Add(confirm);
|
|
|
|
prompt.Add(actions);
|
|
return prompt;
|
|
}
|
|
|
|
private bool CanAttemptBeginnerPull(int pullCount)
|
|
{
|
|
if (gachaService.CanPullBeginner(pullCount, out _))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (!gachaService.IsBeginnerBannerAvailable || pullCount > GachaService.BeginnerMaxPulls - gachaService.BeginnerState.totalPulls)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int missingTokens = gachaService.GetMissingPullTokens(GachaCurrencyType.StandardPull, gachaService.GetBeginnerPullCost(pullCount));
|
|
return missingTokens > 0 &&
|
|
(gachaService.CanCoverMissingPullTokensWithEntropy(wallet, missingTokens) ||
|
|
gachaService.RootCredits > 0);
|
|
}
|
|
|
|
private void ClearEntropyPrompt()
|
|
{
|
|
pendingPullCount = 0;
|
|
pendingMissingTokens = 0;
|
|
}
|
|
|
|
private VisualElement BuildBannerHero(string bannerTitle)
|
|
{
|
|
VisualElement hero = new();
|
|
hero.AddToClassList("gacha-hero");
|
|
|
|
VisualElement artRow = new();
|
|
artRow.AddToClassList("gacha-hero-art-row");
|
|
|
|
IReadOnlyList<DistroDefinition> distros = distroDatabase == null ? Array.Empty<DistroDefinition>() : distroDatabase.AllDistros;
|
|
int artCount = Mathf.Min(3, distros.Count);
|
|
for (int i = 0; i < artCount; i++)
|
|
{
|
|
artRow.Add(BuildDistroArtCard(distros[i]));
|
|
}
|
|
|
|
if (artCount == 0)
|
|
{
|
|
Label empty = new("ascii art unavailable");
|
|
empty.AddToClassList("gacha-rules");
|
|
artRow.Add(empty);
|
|
}
|
|
|
|
Label title = new(bannerTitle);
|
|
title.AddToClassList("gacha-hero-title");
|
|
|
|
hero.Add(artRow);
|
|
hero.Add(title);
|
|
return hero;
|
|
}
|
|
|
|
private VisualElement BuildDistroArtCard(DistroDefinition distro)
|
|
{
|
|
VisualElement card = new();
|
|
card.AddToClassList("gacha-art-card");
|
|
|
|
VisualElement artShell = new();
|
|
artShell.AddToClassList("gacha-art-shell");
|
|
|
|
Label artLabel = new();
|
|
DistroArtPresenter.ConfigureArtLabel(artLabel, monospaceFont);
|
|
artLabel.AddToClassList("gacha-ascii-art");
|
|
VisualElement placeholder = DistroArtPresenter.CreatePlaceholder();
|
|
placeholder.AddToClassList("gacha-ascii-placeholder");
|
|
AsciiArtFitter artFitter = new(artLabel, monospaceFont);
|
|
artFitter.SetArt(DistroArtPresenter.Render(artLabel, placeholder, distro));
|
|
if (distro != null)
|
|
{
|
|
artLabel.style.color = new StyleColor(distro.AccentColor);
|
|
}
|
|
|
|
artShell.Add(placeholder);
|
|
artShell.Add(artLabel);
|
|
card.Add(artShell);
|
|
|
|
Label name = new(distro == null ? "--" : DistroPresentation.DisplayName(distro));
|
|
name.AddToClassList("gacha-art-name");
|
|
if (distro != null)
|
|
{
|
|
name.style.color = new StyleColor(distro.AccentColor);
|
|
}
|
|
|
|
card.Add(name);
|
|
return card;
|
|
}
|
|
|
|
private string FormatBeginnerGuarantees()
|
|
{
|
|
IReadOnlyList<string> ids = gachaService.BeginnerState.guaranteedDistroIds;
|
|
string first = ids.Count > 0 ? ids[0] : "--";
|
|
string second = ids.Count > 1 ? ids[1] : "--";
|
|
return $"20={first}, 40={second}, 50=future standard 5-star";
|
|
}
|
|
|
|
private static VisualElement BuildInfoLine(string key, string value)
|
|
{
|
|
VisualElement row = new();
|
|
row.AddToClassList("kv-row");
|
|
row.Add(new Label(key) { name = $"Gacha{key}Key" });
|
|
row.ElementAt(0).AddToClassList("kv-key");
|
|
row.Add(new Label(value) { name = $"Gacha{key}Value" });
|
|
row.ElementAt(1).AddToClassList("kv-value");
|
|
return row;
|
|
}
|
|
|
|
private string GetBannerStatus(string bannerId)
|
|
{
|
|
return bannerId switch
|
|
{
|
|
GachaService.BeginnerBannerId => gachaService.IsBeginnerBannerAvailable ? $"{gachaService.BeginnerState.totalPulls}/{GachaService.BeginnerMaxPulls}" : "closed",
|
|
GachaService.StandardBannerId => "soon",
|
|
GachaService.LimitedBannerId => "soon",
|
|
_ => "--"
|
|
};
|
|
}
|
|
|
|
private static string GetBannerTitle(string bannerId)
|
|
{
|
|
return bannerId switch
|
|
{
|
|
GachaService.BeginnerBannerId => "beginner install media",
|
|
GachaService.StandardBannerId => "stable branch",
|
|
GachaService.LimitedBannerId => "feature branch",
|
|
_ => bannerId
|
|
};
|
|
}
|
|
}
|
|
}
|