public override void update(GameTime time) { base.update(time); if (_languageCode != LocalizedContentManager.CurrentLanguageCode) { _languageCode = LocalizedContentManager.CurrentLanguageCode; _amString = Game1.content.LoadString("Strings\\StringsFromCSFiles:DayTimeMoneyBox.cs.10370"); _pmString = Game1.content.LoadString("Strings\\StringsFromCSFiles:DayTimeMoneyBox.cs.10371"); } if (questPingTimer > 0) { questPingTimer -= (int)time.ElapsedGameTime.TotalMilliseconds; } if (questPingTimer < 0) { questPingTimer = 0; } if (questsDirty) { if (Game1.player.hasPendingCompletedQuests) { PingQuestLog(); } questsDirty = false; } }
/// <summary>Load an asset that has been processed by the content pipeline.</summary> /// <typeparam name="T">The type of asset to load.</typeparam> /// <param name="assetName">The asset path relative to the loader root directory, not including the <c>.xnb</c> extension.</param> /// <param name="language">The language code for which to load content.</param> /// <param name="useCache">Whether to read/write the loaded asset to the asset cache.</param> public override T Load <T>(string assetName, LocalizedContentManager.LanguageCode language, bool useCache) { // raise first-load callback if (GameContentManager.IsFirstLoad) { GameContentManager.IsFirstLoad = false; this.OnLoadingFirstAsset(); } // normalize asset name assetName = this.AssertAndNormalizeAssetName(assetName); if (this.TryParseExplicitLanguageAssetKey(assetName, out string newAssetName, out LanguageCode newLanguage)) { return(this.Load <T>(newAssetName, newLanguage, useCache)); } // get from cache if (useCache && this.IsLoaded(assetName)) { return(this.RawLoad <T>(assetName, language, useCache: true)); } // get managed asset if (this.Coordinator.TryParseManagedAssetKey(assetName, out string contentManagerID, out string relativePath)) { T managedAsset = this.Coordinator.LoadManagedAsset <T>(contentManagerID, relativePath); if (useCache) { this.Inject(assetName, managedAsset, language); } return(managedAsset); } // load asset T data; if (this.AssetsBeingLoaded.Contains(assetName)) { this.Monitor.Log($"Broke loop while loading asset '{assetName}'.", LogLevel.Warn); this.Monitor.Log($"Bypassing mod loaders for this asset. Stack trace:\n{Environment.StackTrace}", LogLevel.Trace); data = this.RawLoad <T>(assetName, language, useCache); } else { data = this.AssetsBeingLoaded.Track(assetName, () => { string locale = this.GetLocale(language); IAssetInfo info = new AssetInfo(locale, assetName, typeof(T), this.AssertAndNormalizeAssetName); IAssetData asset = this.ApplyLoader <T>(info) ?? new AssetDataForObject(info, this.RawLoad <T>(assetName, language, useCache), this.AssertAndNormalizeAssetName); asset = this.ApplyEditors <T>(info, asset); return((T)asset.Data); }); } // update cache & return data this.Inject(assetName, data, language); return(data); }
private void _loadPreferences() { string fullFilePath = Path.Combine(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "StardewValley"), _filename); if (!File.Exists(fullFilePath)) { Console.WriteLine("path '{0}' did not exist and will be created", fullFilePath); try { languageCode = LocalizedContentManager.CurrentLanguageCode; using FileStream stream2 = File.Create(fullFilePath); writeSettings(stream2); } catch (Exception e2) { Console.WriteLine("_loadPreferences; exception occured trying to create/write: {0}", e2); Game1.debugOutput = Game1.parseText(e2.Message); return; } } try { using (FileStream stream = File.Open(fullFilePath, FileMode.Open, FileAccess.Read)) { readSettings(stream); } isLoaded = true; } catch (Exception e) { Console.WriteLine("_loadPreferences; exception occured trying open/read: {0}", e); Game1.debugOutput = Game1.parseText(e.Message); } }
/**** ** Content loading ****/ /// <summary>Load an asset name without heuristics to support mod content.</summary> /// <typeparam name="T">The type of asset to load.</typeparam> /// <param name="assetName">The asset path relative to the loader root directory, not including the <c>.xnb</c> extension.</param> /// <param name="language">The language code for which to load content.</param> private T LoadImpl <T>(string assetName, LocalizedContentManager.LanguageCode language) { // skip if already loaded if (this.IsNormalisedKeyLoaded(assetName)) { return(base.Load <T>(assetName, language)); } // load asset T data; if (this.AssetsBeingLoaded.Contains(assetName)) { this.Monitor.Log($"Broke loop while loading asset '{assetName}'.", LogLevel.Warn); this.Monitor.Log($"Bypassing mod loaders for this asset. Stack trace:\n{Environment.StackTrace}", LogLevel.Trace); data = base.Load <T>(assetName, language); } else { data = this.AssetsBeingLoaded.Track(assetName, () => { string locale = this.GetLocale(language); IAssetInfo info = new AssetInfo(locale, assetName, typeof(T), this.NormaliseAssetName); IAssetData asset = this.ApplyLoader <T>(info) ?? new AssetDataForObject(info, base.Load <T>(assetName, language), this.NormaliseAssetName); asset = this.ApplyEditors <T>(info, asset); return((T)asset.Data); }); } // update cache & return data this.Inject(assetName, data); return(data); }
/// <summary>Update the current context.</summary> /// <param name="language">The current language.</param> /// <param name="date">The current in-game date (if applicable).</param> /// <param name="weather">The current in-game weather (if applicable).</param> /// <param name="dayEvent">The day event (e.g. wedding or festival) occurring today (if applicable).</param> /// <param name="spouse">The current player's internal spouse name (if applicable).</param> /// <param name="seenEvents">The event IDs which the player has seen.</param> /// <param name="mailFlags">The mail flags set for the player.</param> /// <param name="friendships">The current player's friendship details.</param> public void Set(LocalizedContentManager.LanguageCode language, SDate date, Weather?weather, string dayEvent, string spouse, int[] seenEvents, string[] mailFlags, IEnumerable <KeyValuePair <string, Friendship> > friendships) { // optional date if (date != null) { this.Set(ConditionKey.Day, date.Day.ToString(CultureInfo.InvariantCulture)); this.Set(ConditionKey.DayOfWeek, date.DayOfWeek.ToString().ToLower()); this.Set(ConditionKey.Season, date.Season.ToLower()); } else { this.Set(ConditionKey.Day); this.Set(ConditionKey.DayOfWeek); this.Set(ConditionKey.Season); } // other basic conditions this.Set(ConditionKey.DayEvent, dayEvent); this.Set(ConditionKey.HasFlag, mailFlags); this.Set(ConditionKey.HasSeenEvent, seenEvents?.Select(p => p.ToString()).ToArray()); this.Set(ConditionKey.Language, language.ToString().ToLower()); this.Set(ConditionKey.Spouse, spouse); this.Set(ConditionKey.Weather, weather?.ToString().ToLower()); // NPC friendship conditions this.RemoveAll(ConditionType.Hearts, ConditionType.Relationship); if (friendships != null) { foreach (KeyValuePair <string, Friendship> friendship in friendships) { this.Set(new ConditionKey(ConditionType.Hearts, friendship.Key), (friendship.Value.Points / NPC.friendshipPointsPerHeartLevel).ToString()); this.Set(new ConditionKey(ConditionType.Relationship, friendship.Key), friendship.Value.Status.ToString()); } } }
public void OnLanguageChange(LocalizedContentManager.LanguageCode code) { if (isLoaded && languageCode != code) { savePreferences(async: false); } }
/**** ** Methods ****/ /// <summary>Update the current context.</summary> private void UpdateContext() { // get context IContentHelper contentHelper = this.Helper.Content; LocalizedContentManager.LanguageCode language = contentHelper.CurrentLocaleConstant; SDate date = null; Weather?weather = null; string spouse = null; string dayEvent = null; int[] seenEvents = null; string[] mailFlags = null; if (Context.IsWorldReady) { date = SDate.Now(); weather = this.GetCurrentWeather(); spouse = Game1.player?.spouse; dayEvent = this.GetDayEvent(); seenEvents = Game1.player?.eventsSeen.OrderBy(p => p).ToArray(); mailFlags = this.GetMailFlags().OrderBy(p => p).ToArray(); } // update context this.VerboseLog($"Context: date={(date != null ? $"{date.DayOfWeek} {date.Season} {date.Day}" : "none")}, weather={(weather != null ? weather.ToString() : "none")}, locale={language}."); this.PatchManager.UpdateContext(contentHelper: contentHelper, language: language, date: date, weather: weather, dayEvent: dayEvent, spouse: spouse, seenEvents: seenEvents, mailFlags: mailFlags); }
/// <summary>Adds a new message to the chat box.</summary> private void AddNewMessage(string message, Color color, SpriteFont font, LocalizedContentManager.LanguageCode code, bool isConsoleMessage = false) { if (string.IsNullOrEmpty(message)) { message = " "; } ChatMessage newMessage = isConsoleMessage && this.config.UseMonospacedFontForCommandOutput ? new ConsoleChatMessage() : new ChatMessage(); newMessage.timeLeftToDisplay = 600; newMessage.verticalSize = (int)font.MeasureString(message).Y + 4; newMessage.color = color; newMessage.language = code; newMessage.parseMessageForEmoji(message); this.bMessages.Add(newMessage); if (this.config.MaximumNumberOfHistoryMessages > 0 && this.bMessages.Count >= this.config.MaximumNumberOfHistoryMessages) { this.bMessages.RemoveAt(0); } else if (this.displayLineIndex == this.bMessages.Count - 2) { this.displayLineIndex++; } }
/********* ** Public methods *********/ /// <summary>Construct an instance.</summary> /// <param name="locale">The current language.</param> /// <param name="singleValueConditions">Condition keys which are guaranteed to only have one value.</param> public ConditionContext(LocalizedContentManager.LanguageCode locale, HashSet <ConditionKey> singleValueConditions) { this.SingleValueConditions = singleValueConditions; // set defaults this.Set(locale, null, null, null, null, null, null); this.Set(ConditionKey.HasMod); }
/// <summary>Raised after the game language is changed, and after SMAPI handles the change.</summary> /// <param name="code">The new language code.</param> private void OnLocaleChanged(LocalizedContentManager.LanguageCode code) { // update if locale changes after initialization if (!this.IsFirstTick) { this.UpdateContext(ContextUpdateType.All); } }
public static void SetForLanguage(LocalizedContentManager.LanguageCode code) { Translations.LanguageCodesToTry = new[] { code, Translations.DefaultLanguageCode }; }
/********* ** Public methods *********/ /// <summary>Construct an instance.</summary> /// <param name="monitor">Encapsulates monitoring and logging.</param> /// <param name="conditionFactory">Handles constructing, permuting, and updating conditions.</param> /// <param name="language">The current language.</param> /// <param name="verboseLog">Whether to enable verbose logging.</param> /// <param name="normaliseAssetName">Normalise an asset name.</param> public PatchManager(IMonitor monitor, ConditionFactory conditionFactory, LocalizedContentManager.LanguageCode language, bool verboseLog, Func <string, string> normaliseAssetName) { this.Monitor = monitor; this.ConditionFactory = conditionFactory; this.ConditionContext = new ConditionContext(language); this.Verbose = verboseLog; this.NormaliseAssetName = normaliseAssetName; }
/********* ** Public methods *********/ /// <summary>Construct an instance.</summary> /// <param name="modID">The unique ID of the relevant mod.</param> /// <param name="modName">The name of the relevant mod for error messages.</param> /// <param name="locale">The initial locale.</param> /// <param name="languageCode">The game's current language code.</param> public TranslationHelper(string modID, string modName, string locale, LocalizedContentManager.LanguageCode languageCode) : base(modID) { // save data this.ModName = modName; // set locale this.SetLocale(locale, languageCode); }
/********* ** Public methods *********/ /// <summary>Construct an instance.</summary> /// <param name="translationHelper">Gets translations from the content pack's translation folder.</param> public TranslationValueProvider(ITranslationHelper translationHelper) : base(ConditionType.I18n, mayReturnMultipleValuesForRoot: false) { this.TranslationHelper = translationHelper; this.LastLocale = translationHelper.LocaleEnum; this.EnableInputArguments(required: true, mayReturnMultipleValues: false, maxPositionalArgs: 1); this.MarkReady(true); }
/// <inheritdoc /> public override bool UpdateContext(IContext context) { if (this.TranslationHelper.LocaleEnum == this.LastLocale) { return(false); } this.LastLocale = this.TranslationHelper.LocaleEnum; return(true); }
private static void OnLanguageChange(LocalizedContentManager.LanguageCode code) { if (_characterMap != null) { _characterMap.Clear(); } else { _characterMap = new Dictionary <char, FontChar>(); } if (fontPages != null) { fontPages.Clear(); } else { fontPages = new List <Texture2D>(); } switch (code) { case LocalizedContentManager.LanguageCode.ja: FontFile = loadFont("Fonts\\Japanese"); fontPixelZoom = 1.75f; break; case LocalizedContentManager.LanguageCode.zh: FontFile = loadFont("Fonts\\Chinese"); fontPixelZoom = 1.5f; break; case LocalizedContentManager.LanguageCode.ru: FontFile = loadFont("Fonts\\Russian"); fontPixelZoom = 3f; break; case LocalizedContentManager.LanguageCode.th: FontFile = loadFont("Fonts\\Thai"); fontPixelZoom = 1.5f; break; case LocalizedContentManager.LanguageCode.ko: FontFile = loadFont("Fonts\\Korean"); fontPixelZoom = 1.5f; break; } foreach (FontChar fontCharacter in FontFile.Chars) { char c = (char)fontCharacter.ID; _characterMap.Add(c, fontCharacter); } foreach (FontPage fontPage in FontFile.Pages) { fontPages.Add(Game1.content.Load <Texture2D>("Fonts\\" + fontPage.File)); } }
private static void OnLanguageChange(LocalizedContentManager.LanguageCode code) { if (SpriteTextHelper._characterMap != null) { SpriteTextHelper._characterMap.Clear(); } else { SpriteTextHelper._characterMap = new Dictionary <char, FontChar>(); } if (SpriteTextHelper.fontPages != null) { SpriteTextHelper.fontPages.Clear(); } else { SpriteTextHelper.fontPages = new List <Texture2D>(); } switch (code) { case LocalizedContentManager.LanguageCode.ja: SpriteTextHelper.FontFile = SpriteTextHelper.LoadFont("Fonts\\Japanese"); SpriteText.fontPixelZoom = 1.75f; break; case LocalizedContentManager.LanguageCode.ru: SpriteTextHelper.FontFile = SpriteTextHelper.LoadFont("Fonts\\Russian"); SpriteText.fontPixelZoom = 3f; break; case LocalizedContentManager.LanguageCode.zh: SpriteTextHelper.FontFile = SpriteTextHelper.LoadFont("Fonts\\Chinese"); SpriteText.fontPixelZoom = 1.5f; break; case LocalizedContentManager.LanguageCode.th: SpriteTextHelper.FontFile = SpriteTextHelper.LoadFont("Fonts\\Thai"); SpriteText.fontPixelZoom = 1.5f; break; case LocalizedContentManager.LanguageCode.ko: SpriteTextHelper.FontFile = SpriteTextHelper.LoadFont("Fonts\\Korean"); SpriteText.fontPixelZoom = 1.5f; break; } foreach (FontChar fontChar in SpriteTextHelper.FontFile.Chars) { char id = (char)fontChar.ID; SpriteTextHelper._characterMap.Add(id, fontChar); } foreach (FontPage page in SpriteTextHelper.FontFile.Pages) { SpriteTextHelper.fontPages.Add(Game1.content.Load <Texture2D>("Fonts\\" + page.File)); } }
/// <summary> /// Gets a translated string from the the dictionary with the proper translation; Returns an empty string if this fails somehow. /// </summary> /// <param name="Language"></param> /// <param name="Key"></param> /// <returns></returns> public string getTranslatedString(LocalizedContentManager.LanguageCode Language, string Key) { try { return(HappyBirthday.Instance.messages.translatedStrings[Language][Key]); } catch (Exception err) { return(""); } }
/// <summary>Set the current locale and precache translations.</summary> /// <param name="locale">The current locale.</param> /// <param name="localeEnum">The game's current language code.</param> public void SetLocale(string locale, LocalizedContentManager.LanguageCode localeEnum) { this.Locale = locale.ToLower().Trim(); this.LocaleEnum = localeEnum; this.ForLocale = new Dictionary <string, Translation>(StringComparer.OrdinalIgnoreCase); foreach (string key in this.GetAllKeysRaw()) { string text = this.GetRaw(key, locale, withFallback: true); this.ForLocale.Add(key, new Translation(this.Locale, key, text)); } }
public void setTranslationFromLanguageCode(LocalizedContentManager.LanguageCode code) { foreach (var v in this.TranslationCodes) { if (v.Value.Equals(code)) { this.CurrentTranslation = v.Key; HappyBirthday.ModHelper.WriteConfig <ModConfig>(HappyBirthday.Config); return; } } }
/// <summary>Handle the game changing locale.</summary> private void OnLocaleChanged() { // get locale string locale = this.ContentManager.GetLocale(); LocalizedContentManager.LanguageCode languageCode = this.ContentManager.GetCurrentLanguage(); // update mod translation helpers foreach (IModMetadata mod in this.ModRegistry.GetMods()) { (mod.Mod.Helper.Translation as TranslationHelper)?.SetLocale(locale, languageCode); } }
/// <summary>Update the current context.</summary> /// <param name="language">The current language.</param> /// <param name="date">The current in-game date (if applicable).</param> /// <param name="weather">The current in-game weather (if applicable).</param> public void Update(LocalizedContentManager.LanguageCode language, SDate date, Weather?weather) { // language this.Values[ConditionKey.Language] = language.ToString().ToLower(); // optional date this.Values[ConditionKey.Day] = date?.Day.ToString(CultureInfo.InvariantCulture); this.Values[ConditionKey.DayOfWeek] = date?.DayOfWeek.ToString().ToLower(); this.Values[ConditionKey.Season] = date?.Season.ToLower(); // weather this.Values[ConditionKey.Weather] = weather?.ToString().ToLower(); }
public string this[LocalizedContentManager.LanguageCode code] { get { switch (code) { case LocalizedContentManager.LanguageCode.en: return(en); case LocalizedContentManager.LanguageCode.ja: return(ja ?? en); case LocalizedContentManager.LanguageCode.ru: return(ru ?? en); case LocalizedContentManager.LanguageCode.zh: return(zh ?? en); case LocalizedContentManager.LanguageCode.pt: return(pt ?? en); case LocalizedContentManager.LanguageCode.es: return(es ?? en); case LocalizedContentManager.LanguageCode.de: return(de ?? en); case LocalizedContentManager.LanguageCode.th: return(th ?? en); case LocalizedContentManager.LanguageCode.fr: return(fr ?? en); case LocalizedContentManager.LanguageCode.ko: return(ko ?? en); case LocalizedContentManager.LanguageCode.it: return(it ?? en); case LocalizedContentManager.LanguageCode.tr: return(tr ?? en); case LocalizedContentManager.LanguageCode.hu: return(hu ?? en); default: return(null); } } }
private void writeSettings(Stream stream) { using (XmlWriter xmlWriter = XmlWriter.Create(stream, new XmlWriterSettings { CloseOutput = true })) { xmlWriter.WriteStartDocument(); this.languageCode = LocalizedContentManager.CurrentLanguageCode; StartupPreferences.serializer.Serialize(xmlWriter, this); xmlWriter.WriteEndDocument(); xmlWriter.Flush(); } }
/// <inheritdoc /> public override void receiveChatMessage(long sourceFarmer, int chatKind, LocalizedContentManager.LanguageCode language, string message) { if (chatKind == ChatBox.errorMessage) { // log error this.Monitor.Log(message, LogLevel.Error); // add event details if applicable if (Game1.CurrentEvent != null && message.StartsWith("Event script error:")) { this.Monitor.Log($"In event #{Game1.CurrentEvent.id} for location {Game1.currentLocation?.NameOrUniqueName}", LogLevel.Error); } } base.receiveChatMessage(sourceFarmer, chatKind, language, message); }
public static void Init(LocalizedContentManager.LanguageCode language) { SpriteFont font = ChatBox.messageFont(language); //This is theoretically right, but in practice makes everything too wide. /*widestCharacter = -1; * for (int i = 32; i < 127; i++) * { * float width = font.MeasureString(char.ConvertFromUtf32(i)).X; * if (width > widestCharacter) * widestCharacter = width; * }*/ widestCharacter = font.MeasureString("e").X; }
/// <summary>This method get's ran whenever a player writes a message. This is used to capture the message sender and body to print into the console.</summary> /// <param name="sourceFarmer">The farmer that sent the message.</param> /// <param name="message">The message body.</param> private static void Postfix(long sourceFarmer, int chatKind, LocalizedContentManager.LanguageCode language, string message) { string playerName = ""; // Find the player's nanme from the id if (sourceFarmer == Game1.player.UniqueMultiplayerID) { playerName = ChatBox.formattedUserName(Game1.player); } else if (Game1.otherFarmers.ContainsKey(sourceFarmer)) { playerName = ChatBox.formattedUserName(Game1.otherFarmers[sourceFarmer]); } // Print to console the message ModMonitor.Log($"{playerName}: {message}", LogLevel.Info); }
/**** ** Methods ****/ /// <summary>Update the current context.</summary> private void UpdateContext() { // get context IContentHelper contentHelper = this.Helper.Content; LocalizedContentManager.LanguageCode language = contentHelper.CurrentLocaleConstant; SDate date = null; Weather?weather = null; if (Context.IsWorldReady) { date = SDate.Now(); weather = this.GetCurrentWeather(); } // update context this.VerboseLog($"Context: date={(date != null ? $"{date.DayOfWeek} {date.Season} {date.Day}" : "none")}, weather={(weather != null ? weather.ToString() : "none")}, locale={language}."); this.PatchManager.UpdateContext(contentHelper, language, date, weather); }
/// <summary>Adds a message with formatting to the chat box.</summary> public override void receiveChatMessage(long sourceFarmer, int chatKind, LocalizedContentManager.LanguageCode language, string message) { bool whisperMessage = false; string person = "you"; if (message[0] == WhisperSeparator) { string[] parts = message.Substring(1).Split(WhisperSeparator); string recipientId = Utils.DecipherText(parts[0], sourceFarmer ^ Game1.player.UniqueMultiplayerID); if (!long.TryParse(recipientId, out long recId) || recId != Game1.player.UniqueMultiplayerID) { return; } message = Utils.DecipherText(parts[1], sourceFarmer ^ Game1.player.UniqueMultiplayerID); whisperMessage = true; //check this tomorrow this.commandChatTextBox.LastWhisperId = sourceFarmer; } else if (message[0] == WhisperSeparator + 1) { string[] parts = message.Substring(1).Split(WhisperSeparator); person = parts[0]; message = parts[1]; whisperMessage = true; } string text1 = this.bFormatMessage.Invoke <string>(sourceFarmer, chatKind, message); if (whisperMessage) { text1 = text1.Substring(0, text1.IndexOf(":", StringComparison.InvariantCultureIgnoreCase)) + $" (to {person} only):" + text1.Substring(text1.IndexOf(":", StringComparison.InvariantCultureIgnoreCase) + 1); } string text2 = FixedParseText(text1, this.chatBox.Font, this.chatBox.Width - 16); foreach (string part in text2.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None)) { this.AddNewMessage(part, this.messageColor(chatKind), this.chatBox.Font, language); } }
private void readSettings(Stream stream) { StartupPreferences p = (StartupPreferences)serializer.Deserialize(stream); startMuted = p.startMuted; timesPlayed = p.timesPlayed + 1; levelTenCombat = p.levelTenCombat; levelTenFishing = p.levelTenFishing; levelTenForaging = p.levelTenForaging; levelTenMining = p.levelTenMining; skipWindowPreparation = p.skipWindowPreparation; windowMode = p.windowMode; playerLimit = p.playerLimit; gamepadMode = p.gamepadMode; fullscreenResolutionX = p.fullscreenResolutionX; fullscreenResolutionY = p.fullscreenResolutionY; languageCode = p.languageCode; clientOptions = p.clientOptions; }