Initial commit: OpenRA game engine

Fork from OpenRA/OpenRA with one-click launch script (start-ra.cmd)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

OpenRA.Game/FluentBundle.cs

@@ -0,0 +1,202 @@
+#region Copyright & License Information
+/*
+ * Copyright (c) The OpenRA Developers and Contributors
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Globalization;
+using System.IO;
+using Linguini.Bundle;
+using Linguini.Bundle.Builder;
+using Linguini.Shared.Types.Bundle;
+using Linguini.Syntax.Parser;
+using Linguini.Syntax.Parser.Error;
+using OpenRA.FileSystem;
+using OpenRA.Traits;
+
+namespace OpenRA
+{
+	[AttributeUsage(AttributeTargets.Field)]
+	public sealed class FluentReferenceAttribute : Attribute
+	{
+		public readonly bool Optional;
+		public readonly string[] RequiredVariableNames;
+		public readonly LintDictionaryReference DictionaryReference;
+
+		public FluentReferenceAttribute() { }
+
+		public FluentReferenceAttribute(params string[] requiredVariableNames)
+		{
+			RequiredVariableNames = requiredVariableNames;
+		}
+
+		public FluentReferenceAttribute(LintDictionaryReference dictionaryReference = LintDictionaryReference.None)
+		{
+			DictionaryReference = dictionaryReference;
+		}
+
+		public FluentReferenceAttribute(bool optional)
+		{
+			Optional = optional;
+		}
+	}
+
+	[AttributeUsage(AttributeTargets.Class)]
+	public sealed class IncludeStaticFluentReferencesAttribute : Attribute
+	{
+		public readonly Type[] Types;
+
+		public IncludeStaticFluentReferencesAttribute(params Type[] types)
+		{
+			Types = types;
+		}
+	}
+
+	[AttributeUsage(AttributeTargets.Class)]
+	public sealed class IncludeChromeLogicArgsFluentReferencesAttribute : Attribute
+	{
+		public readonly string[] MethodNames;
+
+		public IncludeChromeLogicArgsFluentReferencesAttribute(params string[] methodNames)
+		{
+			MethodNames = methodNames;
+		}
+	}
+
+	[AttributeUsage(AttributeTargets.Field)]
+	public sealed class IncludeFluentReferencesAttribute : Attribute
+	{
+		public readonly LintDictionaryReference DictionaryReference;
+
+		public IncludeFluentReferencesAttribute() { }
+
+		public IncludeFluentReferencesAttribute(LintDictionaryReference dictionaryReference = LintDictionaryReference.None)
+		{
+			DictionaryReference = dictionaryReference;
+		}
+	}
+
+	public class FluentBundle
+	{
+		readonly Linguini.Bundle.FluentBundle bundle;
+
+		public FluentBundle(string culture, ImmutableArray<string> paths, IReadOnlyFileSystem fileSystem)
+			: this(culture, paths, fileSystem, error => Log.Write("debug", error.Message)) { }
+
+		public FluentBundle(string culture, ImmutableArray<string> paths, IReadOnlyFileSystem fileSystem, string text)
+			: this(culture, paths, fileSystem, text, error => Log.Write("debug", error.Message)) { }
+
+		public FluentBundle(string culture, ImmutableArray<string> paths, IReadOnlyFileSystem fileSystem, Action<ParseError> onError)
+			: this(culture, paths, fileSystem, null, onError) { }
+
+		public FluentBundle(string culture, string text, Action<ParseError> onError)
+			: this(culture, default, null, text, onError) { }
+
+		public FluentBundle(string culture, ImmutableArray<string> paths, IReadOnlyFileSystem fileSystem, string text, Action<ParseError> onError)
+		{
+			bundle = LinguiniBuilder.Builder()
+				.CultureInfo(new CultureInfo(culture))
+				.SkipResources()
+				.SetUseIsolating(false)
+				.UseConcurrent()
+				.UncheckedBuild();
+
+			if (paths != null)
+			{
+				foreach (var path in paths)
+				{
+					var stream = fileSystem.Open(path);
+					using (var reader = new StreamReader(stream))
+					{
+						var parser = new LinguiniParser(reader);
+						var resource = parser.Parse();
+						foreach (var error in resource.Errors)
+							onError(error);
+
+						bundle.AddResourceOverriding(resource);
+					}
+				}
+			}
+
+			if (!string.IsNullOrEmpty(text))
+			{
+				var parser = new LinguiniParser(text);
+				var resource = parser.Parse();
+				foreach (var error in resource.Errors)
+					onError(error);
+
+				bundle.AddResourceOverriding(resource);
+			}
+		}
+
+		public string GetMessage(string key, object[] args = null)
+		{
+			if (!TryGetMessage(key, out var message, args))
+				message = key;
+
+			return message;
+		}
+
+		public bool TryGetMessage(string key, out string value, object[] args = null)
+		{
+			ArgumentNullException.ThrowIfNull(key);
+
+			try
+			{
+				if (!HasMessage(key))
+				{
+					value = null;
+					return false;
+				}
+
+				Dictionary<string, IFluentType> fluentArgs = null;
+				if (args != null)
+				{
+					if (args.Length % 2 != 0)
+						throw new ArgumentException("Expected a comma separated list of name, value arguments " +
+							"but the number of arguments is not a multiple of two", nameof(args));
+
+					fluentArgs = [];
+					for (var i = 0; i < args.Length; i += 2)
+					{
+						var argKey = args[i] as string;
+						if (string.IsNullOrEmpty(argKey))
+							throw new ArgumentException($"Expected the argument at index {i} to be a non-empty string", nameof(args));
+
+						var argValue = args[i + 1];
+						if (argValue == null)
+							throw new ArgumentNullException(nameof(args), $"Expected the argument at index {i + 1} to be a non-null value");
+
+						fluentArgs.Add(argKey, argValue.ToFluentType());
+					}
+				}
+
+				var result = bundle.TryGetAttrMessage(key, fluentArgs, out var errors, out value);
+				foreach (var error in errors)
+					Log.Write("debug", $"FluentBundle of {key}: {error}");
+
+				return result;
+			}
+			catch (Exception)
+			{
+				Log.Write("debug", $"FluentBundle of {key}: threw exception");
+
+				value = null;
+				return false;
+			}
+		}
+
+		public bool HasMessage(string key)
+		{
+			return bundle.HasAttrMessage(key);
+		}
+	}
+}