public Game(string word, GameLanguage lang) { Word = word; Lenght = Word.Length; Stage = 0; InitializeAlphabet(lang); }
/// <summary> /// Sets the value of a string for a given language. /// </summary> /// <param name="str">The string.</param> /// <param name="language">The language.</param> /// <param name="newValue">The new value. Can be <c>null</c>.</param> public void SetString(LocalizedString str, GameLanguage language, string newValue) { // Replace the string var offset = str.Offsets[(int)language]; if (offset < 0 || offset >= Data.Length) offset = Data.Length; // Add the string at the end var oldLength = GetStringLength(offset); var bytes = (newValue != null) ? Encoding.UTF8.GetBytes(newValue) : new byte[0]; if (bytes.Length > 0 && offset == Data.Length) { // If it's a new string, null-terminate it var nullTerminated = new byte[bytes.Length + 1]; Buffer.BlockCopy(bytes, 0, nullTerminated, 0, bytes.Length); bytes = nullTerminated; } Data = ArrayUtil.Replace(Data, offset, oldLength, bytes); // Update string offsets str.Offsets[(int)language] = (bytes.Length > 0) ? offset : -1; var sizeDelta = bytes.Length - oldLength; foreach (var adjustStr in Strings) { for (var i = 0; i < adjustStr.Offsets.Length; i++) { if (adjustStr.Offsets[i] > offset) adjustStr.Offsets[i] += sizeDelta; } } }
public GameManager(Game theGame) { mGame = theGame; mGraphicsDevice = theGame.GraphicsDevice; mGameStates = new List<GameState>(); mCurrentLang = GameLanguage.ENGLISH; }
/// <summary> /// Gets the value of a string in a given language. /// </summary> /// <param name="str">The string.</param> /// <param name="language">The language.</param> /// <returns>The value of the string, or <c>null</c> if the string is not available.</returns> public string GetString(LocalizedString str, GameLanguage language) { var offset = str.Offsets[(int)language]; if (offset < 0 || offset >= Data.Length) return null; // String not available var length = GetStringLength(offset); return Encoding.UTF8.GetString(Data, offset, length); }
public ThirdGenLanguage(GameLanguage language, StructureValueCollection values, FileSegmenter segmenter, FileSegmentGroup localeArea, EngineDescription buildInfo) { Language = language; _pointerLayout = buildInfo.Layouts.GetLayout("locale index table entry"); _encryptionKey = buildInfo.LocaleKey; _sizeAlign = (_encryptionKey != null) ? AES.BlockSize : 1; Load(values, segmenter, localeArea); }
// Use this for initialization public UserSettings() { //load settings mVolume = PlayerPrefs.GetFloat(volumeKey, 1.0f); mMute = PlayerPrefs.GetInt(muteKey, muteDefault) > 0; ApplyAudioSettings(); mLanguage = (GameLanguage)PlayerPrefs.GetInt(languageKey, (int)GameLanguage.English); }
/// <summary> /// Loads the language pack for a language. /// </summary> /// <param name="language">The language of the pack to load.</param> /// <param name="reader">The stream to read from.</param> /// <returns> /// The language pack that was loaded, or <c>null</c> if no pack exists for the language. /// </returns> public LanguagePack LoadLanguage(GameLanguage language, IReader reader) { if (_languageGlobals == null) return null; var data = _languageGlobals.Languages[(int)language]; var table = data.LoadStrings(reader); var pack = new LanguagePack(language); foreach (var group in _groupsByTag.Values) pack.AddStringList(CreateList(group, (int)language, table)); return pack; }
/// <summary> /// Loads the language pack for a language. /// </summary> /// <param name="language">The language of the pack to load.</param> /// <param name="reader">The stream to read from.</param> /// <returns> /// The language pack that was loaded, or <c>null</c> if no pack exists for the language. /// </returns> public LanguagePack LoadLanguage(GameLanguage language, IReader reader) { LanguagePack result; if (!_cachedPacks.TryGetValue(language, out result)) { // Not in the cache - load it from disk and store it result = _baseLoader.LoadLanguage(language, reader); if (result != null) _cachedPacks[language] = result; } return result; }
public static void Load(GameLanguage language) { string filename = string.Empty; switch (language) { case GameLanguage.English: filename = EnglishConfig; break; case GameLanguage.Português: filename = PortuguesConfig; break; } _config = Serializer<LanguageConfig>.DeserializeObject(filename); }
public LocaleEditor(GameLanguage language, ICacheFile cache, IStreamManager streamManager, Trie stringIdTrie, LocaleSymbolCollection symbols) { InitializeComponent(); _currentLanguage = language; _cache = cache; _streamManager = streamManager; _symbols = symbols; StringIDTrie = stringIdTrie; // Thread the loading routine var thrd = new Thread(LoadAll); thrd.SetApartmentState(ApartmentState.STA); thrd.Start(); }
/// <summary> /// Make sure to call this during Main's initialization based on user settings for language. /// </summary> public void Load(GameLanguage language) { int langInd = (int)language; TableData dat = tables[langInd]; fastJSON.JSON.Instance.Parameters.UseExtensions = false; List<Entry> tableEntries = fastJSON.JSON.Instance.ToObject<List<Entry>>(dat.file.text); mTable = new Dictionary<string, string>(tableEntries.Count); foreach(Entry entry in tableEntries) { mTable.Add(entry.key, entry.text); } //append platform specific entries TableDataPlatform platform = null; foreach(TableDataPlatform platformDat in dat.platforms) { if(platformDat.platform == GamePlatform.current) { platform = platformDat; break; } } if(platform != null) { List<Entry> platformEntries = fastJSON.JSON.Instance.ToObject<List<Entry>>(dat.file.text); foreach(Entry platformEntry in platformEntries) { if(mTable.ContainsKey(platformEntry.key)) { mTable[platformEntry.key] = platformEntry.text; } } } //already loaded before? then let everyone know it has changed if(mLoaded) { SceneManager.RootBroadcastMessage("OnLocalize", null, SendMessageOptions.DontRequireReceiver); } else { mLoaded = true; } }
/// <summary> /// Filters a set of localized strings and prepares them for display. /// </summary> /// <param name="unic">The string list.</param> /// <param name="stringIds">The string ID cache to use.</param> /// <param name="strings">The strings to display.</param> /// <param name="language">The language to display strings from.</param> /// <param name="filter">The filter to match strings and stringIDs against. Can be <c>null</c> to display everything.</param> /// <returns>The strings to print.</returns> public static List<DisplayString> PrepareForDisplay(MultilingualUnicodeStringList unic, StringIDCache stringIds, IEnumerable<LocalizedString> strings, GameLanguage language, string filter) { // Filter the input strings var display = new List<DisplayString>(); foreach (var localizedString in strings) { var str = unic.GetString(localizedString, language); if (str == null) continue; var stringId = stringIds.GetString(localizedString.StringID); if (filter != null && !str.Contains(filter) && !stringId.Contains(filter)) continue; display.Add(new DisplayString { StringID = stringId, String = str }); } display.Sort((a, b) => String.Compare(a.StringID, b.StringID, StringComparison.Ordinal)); return display; }
/// <summary> /// Initializes a new instance of the <see cref="LanguagePack"/> class. /// </summary> /// <param name="language">The language that the pack targets.</param> public LanguagePack(GameLanguage language) { Language = language; }
private void InitializeAlphabet(GameLanguage lang) { switch (lang) { case GameLanguage.En: Alphabet = new char[] {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}; break; case GameLanguage.Ru: Alphabet = new char[] {'А', 'Б', 'В', 'Г', 'Д', 'Е', 'Ё', 'Ж', 'З', 'И', 'Й', 'К', 'Л', 'М', 'Н', 'О', 'П', 'Р', 'С', 'Т', 'У', 'Ф', 'Х', 'Ц', 'Ч', 'Ш', 'Щ', 'Ъ', 'Ы', 'Ь', 'Э', 'Ю', 'Я'}; break; } }
public static void Save(GameLanguage language) { string filename = string.Empty; switch (language) { case GameLanguage.English: filename = EnglishConfig; break; case GameLanguage.Português: filename = PortuguesConfig; break; } Serializer<LanguageConfig>.Save(Config, filename); }
private void AddLanguage(string name, GameLanguage lang) { if (!_cacheFile.Languages.AvailableLanguages.Contains(lang)) return; _languages.Add(new LanguageEntry(name, lang)); }
public LanguageEntry(string name, GameLanguage lang) { Name = name; Language = lang; }
/// <summary> /// Loads the language pack for a language. /// </summary> /// <param name="language">The language of the pack to load.</param> /// <param name="reader">The stream to read from.</param> /// <returns> /// The language pack that was loaded, or <c>null</c> if no pack exists for the language. /// </returns> public ILanguagePack LoadLanguage(GameLanguage language, IReader reader) { return null; }
public static bool ParseLanguage(string name, out GameLanguage result) { return _languages.TryGetValue(name, out result); }
/// <summary> /// Determines whether or not a language pack is in the cache. /// </summary> /// <param name="language">The language to check.</param> /// <returns><c>true</c> if the language's pack is in the cache.</returns> public bool IsCached(GameLanguage language) { return _cachedPacks.ContainsKey(language); }
/// <summary> /// Loads the language pack for a language. /// </summary> /// <param name="language">The language of the pack to load.</param> /// <param name="reader">The stream to read from.</param> /// <returns> /// The language pack that was loaded, or <c>null</c> if no pack exists for the language. /// </returns> public ILanguagePack LoadLanguage(GameLanguage language, IReader reader) { ThirdGenLanguage data = _languageGlobals.Languages[(int) language]; return new ThirdGenLanguagePack(data, _groups, reader); }