hans/wolf_dart
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Implement Change View and Renderer Options menus

Browse Source 
- Added functionality to display and navigate the Change View menu in SixelRenderer and SoftwareRenderer.
- Introduced methods to draw the Change View and Renderer Options menus, including handling cursor and selection states.
- Updated WolfClassicMenuArt to include a customize label for the new menu.
- Enhanced WolfMenuScreen to support new menu states.
- Created tests for Change View menu interactions, ensuring proper transitions and renderer settings toggling.
- Implemented persistence for renderer settings in Flutter, allowing settings to be saved and loaded from a local file.

Signed-off-by: Hans Kokx <hans.d.kokx@gmail.com>
This commit is contained in:
Hans Kokx
2026-03-20 20:49:37 +01:00
parent 45e5302eac
commit 3270338f44
20 changed files with 2223 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
apps/wolf_3d_cli/bin/main.dart
View File

@@ -7,6 +7,7 @@ library;
import 'dart:io';
import 'package:wolf_3d_cli/cli_game_loop.dart';
import 'package:wolf_3d_cli/cli_renderer_settings_persistence.dart';
import 'package:wolf_3d_dart/wolf_3d_data.dart';
import 'package:wolf_3d_dart/wolf_3d_data_types.dart';
import 'package:wolf_3d_dart/wolf_3d_engine.dart';
@@ -66,9 +67,14 @@ void main() async {
engine.init();
final persistence = CliRendererSettingsPersistence();
final WolfRendererSettings? saved = await persistence.load();
gameLoop = CliGameLoop(
engine: engine,
onExit: stopAndExit,
persistence: persistence,
initialSettings: saved,
);
await gameLoop.start();

126
apps/wolf_3d_cli/lib/cli_game_loop.dart
View File

@@ -17,6 +17,8 @@ class CliGameLoop {
CliGameLoop({
required this.engine,
required this.onExit,
this.persistence,
this.initialSettings,
}) : input = engine.input is CliInput
? engine.input as CliInput
: throw ArgumentError.value(
@@ -37,6 +39,8 @@ class CliGameLoop {
final CliRendererBackend secondaryRenderer;
final CliInput input;
final void Function(int code) onExit;
final RendererSettingsPersistence? persistence;
final WolfRendererSettings? initialSettings;
final Stopwatch _stopwatch = Stopwatch();
final Stream<List<int>> _stdinStream = stdin.asBroadcastStream();
@@ -59,12 +63,32 @@ class CliGameLoop {
inputStream: _stdinStream,
);
_isSixelAvailable = sixel.isSixelSupported;
_renderer = _isSixelAvailable ? primaryRenderer : secondaryRenderer;
} else {
_isSixelAvailable = false;
_renderer = secondaryRenderer;
}
final Set<WolfRendererMode> supportedModes = <WolfRendererMode>{
WolfRendererMode.ascii,
if (_isSixelAvailable) WolfRendererMode.sixel,
};
engine.setRendererCapabilities(
WolfRendererCapabilities(
supportedModes: supportedModes,
supportsAsciiThemes: true,
supportsFpsCounter: true,
),
);
if (initialSettings != null) {
engine.updateRendererSettings(initialSettings!);
} else if (_isSixelAvailable) {
engine.updateRendererSettings(
engine.rendererSettings.copyWith(mode: WolfRendererMode.sixel),
);
}
_syncRendererFromEngine();
if (stdin.hasTerminal) {
try {
stdin.echoMode = false;
@@ -124,43 +148,48 @@ class CliGameLoop {
}
if (input.matchesRendererToggleShortcut(bytes)) {
if (!_isSixelAvailable) {
return;
}
// Allow dynamic renderer-switch bindings configured on the CLI input.
_renderer = identical(_renderer, secondaryRenderer)
? primaryRenderer
: secondaryRenderer;
engine.cycleRendererMode();
_syncRendererFromEngine();
unawaited(persistence?.save(engine.rendererSettings));
stdout.write('\x1b[2J\x1b[H');
return;
}
if (input.matchesAsciiThemeCycleShortcut(bytes)) {
_cycleAsciiTheme();
engine.cycleAsciiTheme();
_syncRendererFromEngine();
unawaited(persistence?.save(engine.rendererSettings));
return;
}
input.handleKey(bytes);
}
void _cycleAsciiTheme() {
final List<AsciiRenderer> asciiRenderers = <AsciiRenderer>[
if (primaryRenderer is AsciiRenderer) primaryRenderer as AsciiRenderer,
if (secondaryRenderer is AsciiRenderer)
secondaryRenderer as AsciiRenderer,
];
if (asciiRenderers.isEmpty) {
return;
void _syncRendererFromEngine() {
final CliRendererBackend previousRenderer = _renderer;
final WolfRendererMode mode = engine.rendererSettings.mode;
if (mode == WolfRendererMode.sixel && _isSixelAvailable) {
_renderer = primaryRenderer;
} else {
_renderer = secondaryRenderer;
}
final AsciiTheme nextTheme = AsciiThemes.nextOf(
asciiRenderers.first.activeTheme,
);
for (final renderer in asciiRenderers) {
renderer.activeTheme = nextTheme;
final AsciiTheme theme =
engine.rendererSettings.asciiThemeId ==
WolfRendererSettings.asciiThemeQuadrant
? AsciiThemes.quadrant
: AsciiThemes.blocks;
if (primaryRenderer is AsciiRenderer) {
(primaryRenderer as AsciiRenderer).activeTheme = theme;
}
if (secondaryRenderer is AsciiRenderer) {
(secondaryRenderer as AsciiRenderer).activeTheme = theme;
}
if (stdout.hasTerminal) {
engine.showFpsCounter = engine.rendererSettings.fpsCounterEnabled;
if (!identical(previousRenderer, _renderer) && stdout.hasTerminal) {
// Clear stale frame content when switching backend output modes.
stdout.write('\x1b[2J\x1b[H');
}
}
@@ -170,6 +199,9 @@ class CliGameLoop {
return;
}
// Apply renderer changes made via in-game menus or settings updates.
_syncRendererFromEngine();
if (stdout.hasTerminal) {
final int cols = stdout.terminalColumns;
final int rows = stdout.terminalLines;
@@ -198,51 +230,5 @@ class CliGameLoop {
engine.tick(elapsed);
stdout.write(_renderer.render(engine));
_writeShortcutHintLine();
}
void _writeShortcutHintLine() {
if (!stdout.hasTerminal) {
return;
}
final int cols = stdout.terminalColumns;
if (cols <= 0) {
return;
}
final int safeCols = cols > 1 ? cols - 1 : cols;
final String hint = _buildShortcutHintText();
if (hint.isEmpty) {
return;
}
final String visible = hint.length > safeCols
? hint.substring(0, safeCols)
: hint;
final String padded = visible.padRight(safeCols);
// Draw an overlay line without disturbing the renderer's cursor position.
stdout.write('\x1b[s\x1b[1;1H\x1b[0m\x1b[2m\x1b[2K$padded\x1b[0m\x1b[u');
}
String _buildShortcutHintText() {
if (!_isSixelAvailable) {
if (_renderer is AsciiRenderer) {
final AsciiRenderer ascii = _renderer as AsciiRenderer;
return '<${input.asciiThemeCycleKeyLabel}> ${ascii.activeTheme.name}';
}
return '';
}
final String rendererMode = _renderer is SixelRenderer ? 'sixel' : 'ascii';
final String rendererHint =
'<${input.rendererToggleKeyLabel}> $rendererMode';
if (_renderer is AsciiRenderer) {
final AsciiRenderer ascii = _renderer as AsciiRenderer;
return '$rendererHint <${input.asciiThemeCycleKeyLabel}> ${ascii.activeTheme.name}';
}
return rendererHint;
}
}

42
apps/wolf_3d_cli/lib/cli_renderer_settings_persistence.dart Normal file
View File

@@ -0,0 +1,42 @@
/// CLI host adapter for persisting renderer settings to a local file.
library;
import 'dart:io';
import 'package:wolf_3d_dart/wolf_3d_engine.dart';
/// Persists [WolfRendererSettings] as JSON to a local file.
///
/// The default path is `~/.wolf3d_cli_settings.json`.
/// An alternative [filePath] can be supplied at construction time.
class CliRendererSettingsPersistence extends RendererSettingsPersistence
with JsonRendererSettingsPersistence {
CliRendererSettingsPersistence({String? filePath})
: _filePath =
filePath ??
'${Platform.environment['HOME'] ?? '.'}/.wolf3d_cli_settings.json';
final String _filePath;
@override
Future<String?> readRaw() async {
try {
final File f = File(_filePath);
if (!f.existsSync()) {
return null;
}
return await f.readAsString();
} catch (_) {
return null;
}
}
@override
Future<void> writeRaw(String json) async {
try {
await File(_filePath).writeAsString(json, flush: true);
} catch (_) {
// Best-effort; never crash the loop on a write failure.
}
}
}

127
apps/wolf_3d_gui/lib/screens/game_screen.dart
View File

@@ -10,6 +10,7 @@ import 'package:window_manager/window_manager.dart';
import 'package:wolf_3d_dart/wolf_3d_engine.dart';
import 'package:wolf_3d_dart/wolf_3d_input.dart';
import 'package:wolf_3d_dart/wolf_3d_renderer.dart';
import 'package:wolf_3d_flutter/renderer_settings_persistence_flutter.dart';
import 'package:wolf_3d_flutter/wolf_3d_flutter.dart';
import 'package:wolf_3d_flutter/wolf_3d_input_flutter.dart';
import 'package:wolf_3d_gui/screens/debug_tools_screen.dart';
@@ -139,20 +140,38 @@ class GameScreen extends StatefulWidget {
class _GameScreenState extends State<GameScreen> {
late final WolfEngine _engine;
final FlutterRendererSettingsPersistence _persistence =
FlutterRendererSettingsPersistence();
/// Current active renderer implementation.
/// Mirrors [WolfRendererSettings.mode] into the Flutter renderer enum.
RendererMode _rendererMode = RendererMode.hardware;
/// Active ASCII glyph theme used by [RendererMode.ascii].
AsciiTheme _asciiTheme = AsciiThemes.blocks;
/// Whether CRT post-processing is enabled in [RendererMode.hardware].
bool _glslEffectsEnabled = false;
@override
void initState() {
super.initState();
const Set<WolfRendererMode> supportedModes = <WolfRendererMode>{
WolfRendererMode.hardware,
WolfRendererMode.software,
WolfRendererMode.ascii,
};
_engine = widget.wolf3d.launchEngine(
rendererCapabilities: const WolfRendererCapabilities(
supportedModes: supportedModes,
supportsAsciiThemes: true,
supportsHardwareEffects: true,
supportsFpsCounter: true,
),
rendererSettings: const WolfRendererSettings(
mode: WolfRendererMode.hardware,
),
onRendererSettingsChanged: (settings) {
unawaited(_persistence.save(settings));
if (mounted) {
setState(() {
_syncRendererModeFrom(settings);
});
}
},
onGameWon: () {
_engine.difficulty = null;
widget.wolf3d.clearActiveDifficulty();
@@ -162,6 +181,30 @@ class _GameScreenState extends State<GameScreen> {
SystemNavigator.pop();
},
);
_syncRendererModeFrom(_engine.rendererSettings);
_loadPersistedSettings();
}
Future<void> _loadPersistedSettings() async {
final WolfRendererSettings? saved = await _persistence.load();
if (saved != null && mounted) {
_engine.updateRendererSettings(saved);
}
}
void _syncRendererModeFrom(WolfRendererSettings settings) {
switch (settings.mode) {
case WolfRendererMode.hardware:
_rendererMode = RendererMode.hardware;
break;
case WolfRendererMode.software:
_rendererMode = RendererMode.software;
break;
case WolfRendererMode.ascii:
case WolfRendererMode.sixel:
_rendererMode = RendererMode.ascii;
break;
}
}
@override
@@ -222,17 +265,6 @@ class _GameScreenState extends State<GameScreen> {
child: CircularProgressIndicator(color: Colors.teal),
),
),
Positioned(
top: 16,
right: 16,
child: Text(
'<${widget.wolf3d.input.rendererToggleKeyLabel}> ${_rendererMode.name}${_activeModeOverlayHint()} <${widget.wolf3d.input.fpsToggleKeyLabel}> FPS ${_engine.showFpsCounter ? 'On' : 'Off'}',
style: TextStyle(
color: Colors.white.withValues(alpha: 0.5),
),
),
),
],
),
);
@@ -245,6 +277,7 @@ class _GameScreenState extends State<GameScreen> {
Widget _buildRenderer() {
// Keep all renderers behind the same engine so mode switching does not
// reset level state or audio playback.
final WolfRendererSettings settings = _engine.rendererSettings;
switch (_rendererMode) {
case RendererMode.software:
return WolfFlutterRenderer(
@@ -252,15 +285,19 @@ class _GameScreenState extends State<GameScreen> {
onKeyEvent: _handleRendererKeyEvent,
);
case RendererMode.ascii:
final AsciiTheme theme =
settings.asciiThemeId == WolfRendererSettings.asciiThemeQuadrant
? AsciiThemes.quadrant
: AsciiThemes.blocks;
return WolfAsciiRenderer(
engine: _engine,
theme: _asciiTheme,
theme: theme,
onKeyEvent: _handleRendererKeyEvent,
);
case RendererMode.hardware:
return WolfGlslRenderer(
engine: _engine,
effectsEnabled: _glslEffectsEnabled,
effectsEnabled: settings.hardwareEffectsEnabled,
onKeyEvent: _handleRendererKeyEvent,
onUnavailable: _onGlslUnavailable,
);
@@ -279,67 +316,31 @@ class _GameScreenState extends State<GameScreen> {
}
if (event.logicalKey == widget.wolf3d.input.rendererToggleKey) {
setState(_cycleRendererMode);
_engine.cycleRendererMode();
return;
}
if (event.logicalKey == widget.wolf3d.input.fpsToggleKey) {
setState(_toggleFpsCounter);
setState(() => _engine.toggleFpsCounter());
return;
}
if (event.logicalKey == widget.wolf3d.input.asciiThemeCycleKey) {
if (_rendererMode == RendererMode.ascii) {
setState(_cycleAsciiTheme);
_engine.cycleAsciiTheme();
} else if (_rendererMode == RendererMode.hardware) {
setState(_toggleGlslEffects);
_engine.toggleHardwareEffects();
}
}
}
String _activeModeOverlayHint() {
if (_rendererMode == RendererMode.ascii) {
return ' <${widget.wolf3d.input.asciiThemeCycleKeyLabel}> ${_asciiTheme.name}';
}
if (_rendererMode == RendererMode.hardware) {
return ' <${widget.wolf3d.input.asciiThemeCycleKeyLabel}> Effects ${_glslEffectsEnabled ? 'on' : 'off'}';
}
return '';
}
void _cycleRendererMode() {
switch (_rendererMode) {
case RendererMode.hardware:
_rendererMode = RendererMode.software;
break;
case RendererMode.software:
_rendererMode = RendererMode.ascii;
break;
case RendererMode.ascii:
_rendererMode = RendererMode.hardware;
break;
}
}
void _onGlslUnavailable() {
if (!mounted || _rendererMode != RendererMode.hardware) {
return;
}
setState(() {
_rendererMode = RendererMode.software;
});
}
void _toggleFpsCounter() {
_engine.showFpsCounter = !_engine.showFpsCounter;
}
void _cycleAsciiTheme() {
_asciiTheme = AsciiThemes.nextOf(_asciiTheme);
}
void _toggleGlslEffects() {
_glslEffectsEnabled = !_glslEffectsEnabled;
_engine.updateRendererSettings(
_engine.rendererSettings.copyWith(mode: WolfRendererMode.software),
);
}
void _openDebugTools() {