445 lines
20 KiB
C#
445 lines
20 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using UnityEngine;
|
||
using UnityEngine.InputSystem;
|
||
using UnityEngine.UIElements;
|
||
|
||
namespace Ironspore
|
||
{
|
||
// Owns a settings draft and its UI. It does not write files or mutate gameplay state.
|
||
public sealed class SettingsScreen
|
||
{
|
||
readonly SettingsService settings;
|
||
readonly Func<bool> backPressed;
|
||
readonly List<VisualElement> focusOrder = new List<VisualElement>();
|
||
readonly Dictionary<Button, Action> buttonActions = new Dictionary<Button, Action>();
|
||
VisualElement parent, screen;
|
||
ScrollView scroll;
|
||
Label countdown;
|
||
Action closed;
|
||
GameSettingsData draft;
|
||
BindingSlot capture;
|
||
string messageKey;
|
||
object[] messageArgs = Array.Empty<object>();
|
||
int tab, lastKeyFrame = -1;
|
||
bool open;
|
||
static string L(string key, params object[] args) => GameLocalization.Text(key, args);
|
||
|
||
public SettingsScreen(SettingsService settings, Func<bool> backPressed)
|
||
{
|
||
this.settings = settings;
|
||
this.backPressed = backPressed;
|
||
}
|
||
|
||
public void Open(VisualElement parent, Action closed)
|
||
{
|
||
this.parent = parent;
|
||
this.closed = closed;
|
||
draft = settings.Current;
|
||
messageKey = null;
|
||
open = true;
|
||
Draw();
|
||
}
|
||
|
||
public void Close()
|
||
{
|
||
if (!open)
|
||
return;
|
||
open = false;
|
||
capture = null;
|
||
settings.DiscardDraft();
|
||
screen?.RemoveFromHierarchy();
|
||
screen = null;
|
||
scroll = null;
|
||
closed = null;
|
||
focusOrder.Clear();
|
||
buttonActions.Clear();
|
||
}
|
||
|
||
public void RefreshLocale()
|
||
{
|
||
if (!open) return;
|
||
string focusedName = (screen.focusController.focusedElement as VisualElement)?.name;
|
||
Draw();
|
||
if (!string.IsNullOrEmpty(focusedName)) FocusAfterDispatch(screen.Q(focusedName));
|
||
}
|
||
public void CancelInput() => settings.Bindings.Cancel();
|
||
|
||
void Draw()
|
||
{
|
||
Vector2 offset = scroll?.scrollOffset ?? Vector2.zero;
|
||
screen?.RemoveFromHierarchy();
|
||
focusOrder.Clear();
|
||
buttonActions.Clear();
|
||
screen = Element(parent, "settings-screen", "settings-screen");
|
||
screen.RegisterCallback<KeyDownEvent>(evt =>
|
||
{
|
||
if (HandleKey(evt.keyCode, evt.shiftKey))
|
||
evt.StopImmediatePropagation();
|
||
}, TrickleDown.TrickleDown);
|
||
screen.RegisterCallback<PointerDownEvent>(CapturePointer, TrickleDown.TrickleDown);
|
||
var panel = Element(screen, "settings-panel");
|
||
var header = Element(panel, "settings-header");
|
||
var title = Element(header, "settings-title-group");
|
||
Text(title, L("settings.title"), "heading");
|
||
Text(title, L("settings.help"), "settings-help");
|
||
var locales = GameLocalization.Catalog.locales;
|
||
var names = new List<string>();
|
||
foreach (var locale in locales)
|
||
names.Add(locale.nativeName);
|
||
int languageIndex = Array.FindIndex(locales, x => x.code == GameLocalization.CurrentCode);
|
||
var language = Dropdown(header, "settings.language", names, languageIndex, index => GameLocalization.SelectLocale(locales[index].code));
|
||
language.name = "settings-language";
|
||
language.AddToClassList("settings-language");
|
||
var body = Element(panel, "settings-body");
|
||
var navigation = Element(body, "settings-navigation");
|
||
string[] tabs = { "settings.audio", "settings.display", "settings.controls" };
|
||
for (int i = 0; i < tabs.Length; i++)
|
||
{
|
||
int choice = i;
|
||
var button = AddButton(navigation, L(tabs[i]), () => { tab = choice; scroll = null; Draw(); }, "settings-tab");
|
||
button.name = "settings-tab-" + i;
|
||
if (tab == i)
|
||
button.AddToClassList("selected");
|
||
}
|
||
scroll = new ScrollView(ScrollViewMode.Vertical) { horizontalScrollerVisibility = ScrollerVisibility.Hidden };
|
||
scroll.AddToClassList("settings-scroll");
|
||
body.Add(scroll);
|
||
if (tab == 0)
|
||
Audio(scroll);
|
||
else if (tab == 1)
|
||
Display(scroll);
|
||
else
|
||
Controls(scroll);
|
||
var renderedScroll = scroll;
|
||
renderedScroll.schedule.Execute(() => { if (renderedScroll.panel != null) renderedScroll.scrollOffset = offset; });
|
||
var status = Text(panel, string.IsNullOrEmpty(messageKey) ? "" : L(messageKey, messageArgs), "settings-status");
|
||
status.name = "settings-status";
|
||
var footer = Element(panel, "settings-footer");
|
||
var reset = AddButton(footer, L("settings.reset"), Reset, "button");
|
||
reset.name = "settings-reset";
|
||
var footerActions = Element(footer, "settings-footer-actions");
|
||
AddButton(footerActions, L("settings.back"), Back, "button").name = "settings-back";
|
||
AddButton(footerActions, L("settings.apply"), Apply, "primary").name = "settings-apply";
|
||
if (settings.ConfirmingDisplay)
|
||
{
|
||
header.SetEnabled(false);
|
||
body.SetEnabled(false);
|
||
footer.SetEnabled(false);
|
||
var dialog = Dialog("settings.display.confirm");
|
||
countdown = Text(dialog, L("settings.display.countdown", settings.ConfirmationSeconds), "body");
|
||
FocusAfterDispatch(AddButton(dialog, L("settings.display.keep"), ConfirmDisplay, "primary"));
|
||
AddButton(dialog, L("settings.display.revert"), RevertDisplay, "button");
|
||
}
|
||
else if (capture != null)
|
||
{
|
||
header.SetEnabled(false);
|
||
body.SetEnabled(false);
|
||
footer.SetEnabled(false);
|
||
var dialog = Dialog("settings.bind.waiting");
|
||
Text(dialog, L("settings.bind.prompt", L(capture.LabelKey)), "body");
|
||
var cancel = AddButton(dialog, L("settings.bind.cancel"), settings.Bindings.Cancel, "button");
|
||
cancel.name = "settings-capture-cancel";
|
||
FocusAfterDispatch(cancel);
|
||
}
|
||
else
|
||
FocusAfterDispatch(navigation.Q<Button>("settings-tab-" + tab));
|
||
}
|
||
|
||
static void FocusAfterDispatch(VisualElement element)
|
||
{
|
||
// Popup and button dispatch may restore focus to the old, detached control afterwards.
|
||
if (element != null)
|
||
element.schedule.Execute(() => { if (element.panel != null && element.enabledInHierarchy) element.Focus(); });
|
||
}
|
||
|
||
void Audio(VisualElement content)
|
||
{
|
||
Text(content, L("settings.audio"), "section");
|
||
Slider(content, "settings.volume", draft.masterVolume, 0, 1, .01f,
|
||
value => draft.masterVolume = value, value => L("settings.percent", Mathf.RoundToInt(value * 100)));
|
||
Text(content, L("settings.volumeHelp"), "hint");
|
||
}
|
||
|
||
void Display(VisualElement content)
|
||
{
|
||
Text(content, L("settings.display"), "section");
|
||
string[] tiers = QualitySettings.names;
|
||
var qualityNames = new List<string>();
|
||
foreach (string tier in tiers)
|
||
{
|
||
switch (tier)
|
||
{
|
||
case "Very Low": qualityNames.Add(L("settings.quality.veryLow")); break;
|
||
case "Low": qualityNames.Add(L("settings.quality.low")); break;
|
||
case "Medium": qualityNames.Add(L("settings.quality.medium")); break;
|
||
case "High": qualityNames.Add(L("settings.quality.high")); break;
|
||
case "Very High": qualityNames.Add(L("settings.quality.veryHigh")); break;
|
||
case "Ultra": qualityNames.Add(L("settings.quality.ultra")); break;
|
||
default: qualityNames.Add(tier); break;
|
||
}
|
||
}
|
||
Dropdown(content, "settings.quality", qualityNames, draft.qualityLevel, index => draft.qualityLevel = index).name = "settings-quality";
|
||
var resolutions = settings.Resolutions();
|
||
var choices = new List<string>();
|
||
int selected = 0;
|
||
for (int i = 0; i < resolutions.Count; i++)
|
||
{
|
||
var size = resolutions[i];
|
||
choices.Add(size.x + " × " + size.y);
|
||
if (size.x == draft.resolutionWidth && size.y == draft.resolutionHeight)
|
||
selected = i;
|
||
}
|
||
Dropdown(content, "settings.resolution", choices, selected, index =>
|
||
{
|
||
draft.resolutionWidth = resolutions[index].x;
|
||
draft.resolutionHeight = resolutions[index].y;
|
||
}).name = "settings-resolution";
|
||
Dropdown(content, "settings.windowMode", new List<string> { L("settings.windowed"), L("settings.fullscreen") }, draft.fullscreen ? 1 : 0,
|
||
index => draft.fullscreen = index == 1).name = "settings-window-mode";
|
||
Text(content, L("settings.displayHelp"), "hint");
|
||
}
|
||
|
||
void Controls(VisualElement content)
|
||
{
|
||
Text(content, L("settings.mouse"), "section");
|
||
Slider(content, "settings.sensitivity", draft.mouseSensitivity, .1f, 5, .05f,
|
||
value => draft.mouseSensitivity = value, value => L("settings.multiplier", value.ToString("0.00", GameLocalization.Culture)));
|
||
Slider(content, "settings.aimSensitivity", draft.aimSensitivity, .1f, 2, .05f,
|
||
value => draft.aimSensitivity = value, value => L("settings.multiplier", value.ToString("0.00", GameLocalization.Culture)));
|
||
Text(content, L("settings.bindings"), "section");
|
||
Text(content, L("settings.bind.help"), "hint");
|
||
foreach (var slot in settings.Bindings.Slots)
|
||
{
|
||
var row = Element(content, "settings-binding-row");
|
||
Text(row, L(slot.LabelKey), "settings-binding-label");
|
||
var button = AddButton(row, settings.Bindings.Display(slot), () => BeginRebind(slot), "settings-binding");
|
||
button.name = "binding-" + slot.Action.name.ToLowerInvariant() + "-" + slot.Index;
|
||
button.tooltip = L("settings.bind.prompt", L(slot.LabelKey));
|
||
}
|
||
}
|
||
|
||
void BeginRebind(BindingSlot slot)
|
||
{
|
||
capture = slot;
|
||
settings.Bindings.Begin(slot, (result, conflict) =>
|
||
{
|
||
if (!open)
|
||
return;
|
||
capture = null;
|
||
draft.bindingOverrides = settings.Bindings.Save();
|
||
string key = result == BindingChange.Success ? "settings.bind.changed"
|
||
: result == BindingChange.Cancelled ? "settings.bind.cancelled"
|
||
: result == BindingChange.Conflict ? "settings.bind.conflict"
|
||
: result == BindingChange.Reserved ? "settings.bind.reserved" : "settings.bind.unsupported";
|
||
Message(key, result == BindingChange.Conflict ? L(conflict.LabelKey) : L(slot.LabelKey));
|
||
Draw();
|
||
});
|
||
Draw();
|
||
}
|
||
|
||
void Apply()
|
||
{
|
||
var result = settings.Apply(draft);
|
||
if (result == SettingsApplyResult.Saved)
|
||
{
|
||
draft = settings.Current;
|
||
Message("settings.saved");
|
||
}
|
||
else if (result == SettingsApplyResult.Failed)
|
||
Message("settings.saveFailed");
|
||
Draw();
|
||
}
|
||
|
||
void ConfirmDisplay()
|
||
{
|
||
bool saved = settings.ConfirmDisplay();
|
||
draft = settings.Current;
|
||
Message(saved ? "settings.saved" : "settings.saveFailed");
|
||
Draw();
|
||
}
|
||
|
||
void RevertDisplay()
|
||
{
|
||
settings.CancelDisplay();
|
||
var saved = settings.Current;
|
||
draft.resolutionWidth = saved.resolutionWidth;
|
||
draft.resolutionHeight = saved.resolutionHeight;
|
||
draft.fullscreen = saved.fullscreen;
|
||
Message("settings.display.reverted");
|
||
Draw();
|
||
}
|
||
|
||
void Reset()
|
||
{
|
||
draft = settings.Defaults;
|
||
settings.Bindings.Reset();
|
||
Message("settings.resetHint");
|
||
Draw();
|
||
}
|
||
|
||
void Back()
|
||
{
|
||
if (settings.Bindings.IsRebinding)
|
||
{
|
||
settings.Bindings.Cancel();
|
||
return;
|
||
}
|
||
if (settings.ConfirmingDisplay)
|
||
{
|
||
RevertDisplay();
|
||
return;
|
||
}
|
||
var callback = closed;
|
||
Close();
|
||
callback?.Invoke();
|
||
}
|
||
|
||
public void Tick()
|
||
{
|
||
if (!open)
|
||
return;
|
||
if (settings.Tick())
|
||
RevertDisplay();
|
||
if (settings.ConfirmingDisplay && countdown != null)
|
||
countdown.text = L("settings.display.countdown", settings.ConfirmationSeconds);
|
||
if (settings.Bindings.SuppressMenuInput)
|
||
return;
|
||
var keyboard = Keyboard.current;
|
||
if (keyboard != null)
|
||
{
|
||
if (keyboard.escapeKey.wasPressedThisFrame) HandleKey(KeyCode.Escape, false);
|
||
else if (keyboard.tabKey.wasPressedThisFrame) HandleKey(KeyCode.Tab, keyboard.shiftKey.isPressed);
|
||
else if (keyboard.enterKey.wasPressedThisFrame || keyboard.numpadEnterKey.wasPressedThisFrame) HandleKey(KeyCode.Return, false);
|
||
else if (keyboard.spaceKey.wasPressedThisFrame) HandleKey(KeyCode.Space, false);
|
||
else if (keyboard.leftArrowKey.wasPressedThisFrame) HandleKey(KeyCode.LeftArrow, false);
|
||
else if (keyboard.rightArrowKey.wasPressedThisFrame) HandleKey(KeyCode.RightArrow, false);
|
||
else if (keyboard.upArrowKey.wasPressedThisFrame) HandleKey(KeyCode.UpArrow, false);
|
||
else if (keyboard.downArrowKey.wasPressedThisFrame) HandleKey(KeyCode.DownArrow, false);
|
||
}
|
||
if (backPressed() && lastKeyFrame != Time.frameCount)
|
||
HandleKey(KeyCode.Escape, false);
|
||
}
|
||
|
||
bool HandleKey(KeyCode key, bool shift)
|
||
{
|
||
if (settings.Bindings.IsRebinding)
|
||
{
|
||
if (key == KeyCode.Escape) settings.Bindings.Cancel();
|
||
else if (key != KeyCode.None) settings.Bindings.CapturePath(SettingsInputCapture.KeyboardPath(key));
|
||
return true;
|
||
}
|
||
if (settings.Bindings.SuppressMenuInput)
|
||
return true;
|
||
if (lastKeyFrame == Time.frameCount)
|
||
return true;
|
||
var focused = screen.focusController.focusedElement as VisualElement;
|
||
int index = focusOrder.FindIndex(x => x == focused || (focused != null && x.Contains(focused)));
|
||
if (key == KeyCode.Escape)
|
||
Back();
|
||
else if (key == KeyCode.Tab)
|
||
{
|
||
int direction = shift ? -1 : 1;
|
||
for (int i = 0; i < focusOrder.Count; i++)
|
||
{
|
||
index = (index + direction + focusOrder.Count) % focusOrder.Count;
|
||
if (focusOrder[index].enabledInHierarchy)
|
||
{
|
||
focusOrder[index].Focus();
|
||
if (scroll.Contains(focusOrder[index])) scroll.ScrollTo(focusOrder[index]);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if ((key == KeyCode.Return || key == KeyCode.KeypadEnter || key == KeyCode.Space) && focused is Button button && buttonActions.TryGetValue(button, out var action))
|
||
action();
|
||
else if (index >= 0 && (key == KeyCode.LeftArrow || key == KeyCode.RightArrow || key == KeyCode.UpArrow || key == KeyCode.DownArrow))
|
||
{
|
||
int direction = key == KeyCode.LeftArrow || key == KeyCode.DownArrow ? -1 : 1;
|
||
if (focusOrder[index] is Slider slider)
|
||
slider.value += direction * (float)slider.userData;
|
||
else if (focusOrder[index] is DropdownField dropdown)
|
||
dropdown.index = (dropdown.index + direction + dropdown.choices.Count) % dropdown.choices.Count;
|
||
else
|
||
return false;
|
||
}
|
||
else
|
||
return false;
|
||
lastKeyFrame = Time.frameCount;
|
||
return true;
|
||
}
|
||
|
||
void CapturePointer(PointerDownEvent evt)
|
||
{
|
||
if (!settings.Bindings.IsRebinding)
|
||
return;
|
||
var cancel = screen.Q<Button>("settings-capture-cancel");
|
||
var target = evt.target as VisualElement;
|
||
if (cancel != null && target != null && (target == cancel || cancel.Contains(target)))
|
||
settings.Bindings.Cancel();
|
||
else
|
||
settings.Bindings.CapturePath(SettingsInputCapture.MousePath(evt.button));
|
||
evt.StopImmediatePropagation();
|
||
}
|
||
|
||
void Message(string key, params object[] args) { messageKey = key; messageArgs = args; }
|
||
|
||
VisualElement Dialog(string titleKey)
|
||
{
|
||
var shade = Element(screen, "settings-dialog-shade");
|
||
var dialog = Element(shade, "settings-dialog");
|
||
Text(dialog, L(titleKey), "heading");
|
||
return dialog;
|
||
}
|
||
|
||
static VisualElement Element(VisualElement parent, string css, string name = null)
|
||
{
|
||
var element = new VisualElement { name = name };
|
||
element.AddToClassList(css);
|
||
parent.Add(element);
|
||
return element;
|
||
}
|
||
|
||
static Label Text(VisualElement parent, string value, string css)
|
||
{
|
||
var label = new Label(value);
|
||
label.AddToClassList(css);
|
||
parent.Add(label);
|
||
return label;
|
||
}
|
||
|
||
Button AddButton(VisualElement parent, string label, Action action, string css)
|
||
{
|
||
var button = new Button(action) { text = label };
|
||
button.AddToClassList(css);
|
||
parent.Add(button);
|
||
focusOrder.Add(button);
|
||
buttonActions.Add(button, action);
|
||
return button;
|
||
}
|
||
|
||
DropdownField Dropdown(VisualElement parent, string key, List<string> choices, int index, Action<int> changed)
|
||
{
|
||
var dropdown = new DropdownField(L(key), choices, Mathf.Clamp(index, 0, choices.Count - 1));
|
||
dropdown.AddToClassList("settings-dropdown");
|
||
dropdown.RegisterValueChangedCallback(evt => changed(dropdown.index));
|
||
parent.Add(dropdown);
|
||
focusOrder.Add(dropdown);
|
||
return dropdown;
|
||
}
|
||
|
||
void Slider(VisualElement parent, string key, float value, float min, float max, float step, Action<float> changed, Func<float, string> format)
|
||
{
|
||
var row = Element(parent, "settings-slider-row");
|
||
var heading = Element(row, "settings-slider-heading");
|
||
Text(heading, L(key), "settings-label");
|
||
var readout = Text(heading, format(value), "settings-value");
|
||
var slider = new Slider(min, max) { value = value, name = key, userData = step };
|
||
slider.AddToClassList("settings-slider");
|
||
slider.RegisterValueChangedCallback(evt => { changed(evt.newValue); readout.text = format(evt.newValue); });
|
||
row.Add(slider);
|
||
focusOrder.Add(slider);
|
||
}
|
||
}
|
||
}
|