Beispiel #1
0
        /// <summary>
        ///     軍団名定義行を解釈する
        /// </summary>
        /// <param name="lexer">字句解析器</param>
        /// <param name="branch">兵科</param>
        private static void ParseLine(CsvLexer lexer, Branch branch)
        {
            string[] tokens = lexer.GetTokens();

            // 空行を読み飛ばす
            if (tokens == null)
            {
                return;
            }

            // トークン数が足りない行は読み飛ばす
            if (tokens.Length != 2)
            {
                Log.Warning("[CorpsName] Invalid token count: {0} ({1} L{2})\n", tokens.Length, lexer.FileName,
                    lexer.LineNo);
                // 余分な項目がある場合は解析を続ける
                if (tokens.Length < 2)
                {
                    return;
                }
            }

            // 国タグ
            string countryName = tokens[0].ToUpper();
            if (!Countries.StringMap.ContainsKey(countryName))
            {
                Log.Warning("[CorpsName] Invalid country: {0} ({1} L{2})\n", tokens.Length, lexer.FileName, lexer.LineNo);
                return;
            }
            Country country = Countries.StringMap[countryName];

            // 軍団名
            string name = tokens[1];
            if (string.IsNullOrEmpty(name))
            {
                return;
            }

            // 軍団名を追加する
            AddName(name, branch, country);
        }
Beispiel #2
0
        /// <summary>
        ///     軍団名定義ファイルを読み込む
        /// </summary>
        /// <param name="branch">兵科</param>
        /// <param name="fileName">ファイル名</param>
        private static void LoadFile(Branch branch, string fileName)
        {
            Log.Verbose("[CorpsName] Load: {0}", Path.GetFileName(fileName));

            using (CsvLexer lexer = new CsvLexer(fileName))
            {
                while (!lexer.EndOfStream)
                {
                    ParseLine(lexer, branch);
                }
            }
        }
Beispiel #3
0
        /// <summary>
        ///     プロヴィンス定義行を解釈する
        /// </summary>
        /// <param name="lexer">字句解析器</param>
        /// <returns>プロヴィンスデータ</returns>
        private static Province ParseLine(CsvLexer lexer)
        {
            string[] tokens = lexer.GetTokens();

            // ID指定のない行は読み飛ばす
            if (string.IsNullOrEmpty(tokens?[0]))
            {
                return null;
            }

            // トークン数が足りない行は読み飛ばす
            if (tokens.Length < 49)
            {
                Log.Warning("[Province] Invalid token count: {0} ({1} L{2})", tokens.Length, lexer.FileName,
                    lexer.LineNo);
                return null;
            }

            Province province = new Province();
            int index = 0;

            // プロヴィンスID
            int n;
            if (!int.TryParse(tokens[index], out n))
            {
                Log.Warning("[Province] Invalid id: {0} ({1} L{2})", tokens[index], lexer.FileName, lexer.LineNo);
                return null;
            }
            province.Id = n;
            index++;

            // プロヴィンス名
            province.Name = tokens[index];
            index++;

            // 地域ID
            string s = tokens[index].ToLower();
            if (string.IsNullOrEmpty(s))
            {
                province.Area = AreaId.None;
            }
            else if (AreaStringMap.ContainsKey(s))
            {
                province.Area = AreaStringMap[s];
            }
            else
            {
                Log.Warning("[Province] Invalid area: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
                province.Area = AreaId.None;
            }
            index++;

            // 地方ID
            s = tokens[index].ToLower();
            if (string.IsNullOrEmpty(s))
            {
                province.Region = RegionId.None;
            }
            else if (RegionStringMap.ContainsKey(s))
            {
                province.Region = RegionStringMap[s];
            }
            else
            {
                Log.Warning("[Province] Invalid region: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
                province.Region = RegionId.None;
            }
            index++;

            // 大陸ID
            s = tokens[index].ToLower();
            if (string.IsNullOrEmpty(s))
            {
                province.Continent = ContinentId.None;
            }
            else if (ContinentStringMap.ContainsKey(s))
            {
                province.Continent = ContinentStringMap[s];
            }
            else
            {
                Log.Warning("[Province] Invalid continent: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
                province.Continent = ContinentId.None;
            }
            index++;

            // 気候ID
            s = tokens[index].ToLower();
            if (string.IsNullOrEmpty(s))
            {
                province.Climate = ClimateId.None;
            }
            else if (ClimateStringMap.ContainsKey(s))
            {
                province.Climate = ClimateStringMap[s];
            }
            else
            {
                Log.Warning("[Province] Invalid climate: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
                province.Climate = ClimateId.None;
            }
            index++;

            // 地形ID
            s = tokens[index].ToLower();
            if (string.IsNullOrEmpty(s))
            {
                province.Terrain = TerrainId.Unknown;
            }
            else if (TerrainStringMap.ContainsKey(s))
            {
                province.Terrain = TerrainStringMap[s];
            }
            else
            {
                Log.Warning("[Province] Invalid terrain: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
                province.Terrain = TerrainId.Unknown;
            }
            index += 3;

            // インフラ
            double d;
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.Infrastructure = 0;
            }
            else if (DoubleHelper.TryParse(tokens[index], out d))
            {
                province.Infrastructure = d;
            }
            else
            {
                Log.Warning("[Province] Invalid infrastructure: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index += 2;

            // 砂浜の有無
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.Beaches = false;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.Beaches = n > 0;
            }
            else
            {
                Log.Warning("[Province] Invalid beach: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 港の有無
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.PortAllowed = false;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.PortAllowed = n > 0;
            }
            else
            {
                Log.Warning("[Province] Invalid port allowed: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 港の海域
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.PortSeaZone = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.PortSeaZone = n;
            }
            else
            {
                Log.Warning("[Province] Invalid port sea zone: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // IC
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.Ic = 0;
            }
            else if (DoubleHelper.TryParse(tokens[index], out d))
            {
                province.Ic = d;
            }
            else
            {
                Log.Warning("[Province] Invalid ic: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 労働力
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.Manpower = 0;
            }
            else if (DoubleHelper.TryParse(tokens[index], out d))
            {
                province.Manpower = d;
            }
            else
            {
                Log.Warning("[Province] Invalid manpower: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 石油
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.Oil = 0;
            }
            else if (DoubleHelper.TryParse(tokens[index], out d))
            {
                province.Oil = d;
            }
            else
            {
                Log.Warning("[Province] Invalid oil: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 金属
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.Metal = 0;
            }
            else if (DoubleHelper.TryParse(tokens[index], out d))
            {
                province.Metal = d;
            }
            else
            {
                Log.Warning("[Province] Invalid metal: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // エネルギー
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.Energy = 0;
            }
            else if (DoubleHelper.TryParse(tokens[index], out d))
            {
                province.Energy = d;
            }
            else
            {
                Log.Warning("[Province] Invalid energy: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 希少資源
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.RareMaterials = 0;
            }
            else if (DoubleHelper.TryParse(tokens[index], out d))
            {
                province.RareMaterials = d;
            }
            else
            {
                Log.Warning("[Province] Invalid rare materials: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 都市のX座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.CityXPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.CityXPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid city posision x: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 都市のY座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.CityYPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.CityYPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid city position y: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 軍隊のX座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.ArmyXPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.ArmyXPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid army position x: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 軍隊のY座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.ArmyYPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.ArmyYPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid army position y: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 港のX座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.PortXPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.PortXPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid port position x: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 港のY座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.PortYPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.PortYPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid port position y: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 砂浜のX座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.BeachXPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.BeachXPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid beach position x: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 砂浜のY座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.BeachYPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.BeachYPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid beach position y: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 砂浜のアイコン
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.BeachIcon = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.BeachIcon = n;
            }
            else
            {
                Log.Warning("[Province] Invalid beach icon: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 要塞のX座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.FortXPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.FortXPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid fort position x: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 要塞のY座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.FortYPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.FortYPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid fort position y: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 対空砲のX座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.AaXPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.AaXPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid aa position x: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 対空砲のY座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.AaYPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.AaYPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid aa position y: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // カウンターのX座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.CounterXPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.CounterXPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid counter position x: {0} [{1}: {2}] ({3} L{4})", tokens[index],
                    province.Id, province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // カウンターのY座標
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.CounterYPos = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.CounterYPos = n;
            }
            else
            {
                Log.Warning("[Province] Invalid counter position y: {0} [{1}: {2}] ({3} L{4})", tokens[index],
                    province.Id, province.Name, lexer.FileName, lexer.LineNo);
            }
            index += 11;

            // 塗りつぶしX座標1
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.FillCoordX1 = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.FillCoordX1 = n;
            }
            else
            {
                Log.Warning("[Province] Invalid fill position x1: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 塗りつぶしY座標1
            if (string.IsNullOrEmpty(tokens[index]))
            {
                province.FillCoordY1 = 0;
            }
            else if (int.TryParse(tokens[index], out n))
            {
                province.FillCoordY1 = n;
            }
            else
            {
                Log.Warning("[Province] Invalid fill position y1: {0} [{1}: {2}] ({3} L{4})", tokens[index], province.Id,
                    province.Name, lexer.FileName, lexer.LineNo);
            }
            index++;

            // 塗りつぶしX座標2
            if (index < tokens.Length)
            {
                if (string.IsNullOrEmpty(tokens[index]))
                {
                    province.FillCoordX2 = 0;
                }
                else if (int.TryParse(tokens[index], out n))
                {
                    province.FillCoordX2 = n;
                }
            }
            index++;

            // 塗りつぶしY座標2
            if (index < tokens.Length)
            {
                if (string.IsNullOrEmpty(tokens[index]))
                {
                    province.FillCoordY2 = 0;
                }
                else if (int.TryParse(tokens[index], out n))
                {
                    province.FillCoordY2 = n;
                }
            }
            index++;

            // 塗りつぶしX座標3
            if (index < tokens.Length)
            {
                if (string.IsNullOrEmpty(tokens[index]))
                {
                    province.FillCoordX3 = 0;
                }
                else if (int.TryParse(tokens[index], out n))
                {
                    province.FillCoordX3 = n;
                }
            }
            index++;

            // 塗りつぶしY座標3
            if (index < tokens.Length)
            {
                if (string.IsNullOrEmpty(tokens[index]))
                {
                    province.FillCoordY3 = 0;
                }
                else if (int.TryParse(tokens[index], out n))
                {
                    province.FillCoordY3 = n;
                }
            }
            index++;

            // 塗りつぶしX座標4
            if (index < tokens.Length)
            {
                if (string.IsNullOrEmpty(tokens[index]))
                {
                    province.FillCoordX4 = 0;
                }
                else if (int.TryParse(tokens[index], out n))
                {
                    province.FillCoordX4 = n;
                }
            }
            index++;

            // 塗りつぶしY座標4
            if (index < tokens.Length)
            {
                if (string.IsNullOrEmpty(tokens[index]))
                {
                    province.FillCoordY4 = 0;
                }
                else if (int.TryParse(tokens[index], out n))
                {
                    province.FillCoordY4 = n;
                }
            }
            index++;

            // 塗りつぶしX座標5
            if (index < tokens.Length)
            {
                if (string.IsNullOrEmpty(tokens[index]))
                {
                    province.FillCoordX5 = 0;
                }
                else if (int.TryParse(tokens[index], out n))
                {
                    province.FillCoordX5 = n;
                }
            }
            index++;

            // 塗りつぶしY座標5
            if (index < tokens.Length)
            {
                if (string.IsNullOrEmpty(tokens[index]))
                {
                    province.FillCoordY5 = 0;
                }
                else if (int.TryParse(tokens[index], out n))
                {
                    province.FillCoordY5 = n;
                }
            }
            index++;

            // 塗りつぶしX座標6
            if (index < tokens.Length)
            {
                if (string.IsNullOrEmpty(tokens[index]))
                {
                    province.FillCoordX6 = 0;
                }
                else if (int.TryParse(tokens[index], out n))
                {
                    province.FillCoordX6 = n;
                }
            }

            return province;
        }
Beispiel #4
0
        /// <summary>
        ///     プロヴィンスファイルを読み込む
        /// </summary>
        /// <param name="fileName">対象ファイル名</param>
        private static void LoadFile(string fileName)
        {
            Log.Verbose("[Province] Load: {0}", Path.GetFileName(fileName));

            using (CsvLexer lexer = new CsvLexer(fileName))
            {
                // 空ファイルを読み飛ばす
                if (lexer.EndOfStream)
                {
                    return;
                }

                // ヘッダ行読み込み
                lexer.SkipLine();

                // ヘッダ行のみのファイルを読み飛ばす
                if (lexer.EndOfStream)
                {
                    return;
                }

                while (!lexer.EndOfStream)
                {
                    Province province = ParseLine(lexer);

                    // 空行を読み飛ばす
                    if (province == null)
                    {
                        continue;
                    }

                    Items.Add(province);
                }

                ResetDirty();
            }
        }
Beispiel #5
0
        /// <summary>
        ///     ランダム指揮官名定義ファイルを読み込む
        /// </summary>
        /// <param name="fileName">ファイル名</param>
        private static void LoadFile(string fileName)
        {
            Log.Verbose("[RandomLeader] Load: {0}", Path.GetFileName(fileName));

            using (CsvLexer lexer = new CsvLexer(fileName))
            {
                while (!lexer.EndOfStream)
                {
                    ParseLine(lexer);
                }
            }
        }
Beispiel #6
0
        /// <summary>
        ///     文字列ファイルを読み込む
        /// </summary>
        /// <param name="fileName">対象ファイル名</param>
        private static void LoadFile(string fileName)
        {
            if (string.IsNullOrEmpty(fileName))
            {
                return;
            }

            string name = Path.GetFileName(fileName);
            if (string.IsNullOrEmpty(name))
            {
                return;
            }

            // ゲーム中に使用しないファイルを無視する
            if (name.Equals("editor.csv") || name.Equals("launcher.csv"))
            {
                return;
            }

            string dirName = Path.GetFileName(Path.GetDirectoryName(fileName));
            if (!string.IsNullOrEmpty(dirName) && dirName.ToLower().Equals("additional"))
            {
                name = Path.Combine("Addtional", name);
            }

            Log.Verbose("[Config] Load: {0}", name);

            // トークン数の設定
            int expectedCount;
            int effectiveCount;
            if (name.Equals("editor.csv"))
            {
                expectedCount = 11;
                effectiveCount = 10;
            }
            else if (name.Equals("famous_quotes.csv"))
            {
                expectedCount = 16;
                effectiveCount = 16;
            }
            else if (name.Equals("launcher.csv"))
            {
                expectedCount = 10;
                effectiveCount = 10;
            }
            else
            {
                expectedCount = 12;
                effectiveCount = 11;
            }

            List<string> orderList = new List<string>();

            using (CsvLexer lexer = new CsvLexer(fileName))
            {
                while (!lexer.EndOfStream)
                {
                    string[] tokens = lexer.GetTokens();

                    // 空行を読み飛ばす
                    if (tokens == null)
                    {
                        orderList.Add("");
                        continue;
                    }

                    // 先頭トークンを定義順リストに登録する
                    orderList.Add(tokens[0]);

                    // トークン数が足りない行は読み飛ばす
                    if (tokens.Length != expectedCount)
                    {
                        Log.Warning("[Config] Invalid token count: {0} ({1} L{2})", tokens.Length, name, lexer.LineNo);

                        // 末尾のxがない/余分な項目がある場合は解析を続ける
                        if (tokens.Length < effectiveCount)
                        {
                            continue;
                        }
                    }

                    // 空行、コメント行を読み飛ばす
                    if (tokens.Length <= 1 || string.IsNullOrEmpty(tokens[0]) || tokens[0][0] == '#')
                    {
                        continue;
                    }

                    string key = tokens[0].ToUpper();
                    // 何らかの理由で一時キーがファイルに残っていれば一時キーリストに登録する
                    if (RegexTempKey.IsMatch(key))
                    {
                        TempKeyList.Add(key);
                        Log.Warning("[Config] Unexpected temp key: {0} ({1} L{2})", key, name, lexer.LineNo);
                    }

                    // 変換テーブルに登録する
                    string[] t = new string[MaxLanguages];
                    for (int i = 0; i < MaxLanguages; i++)
                    {
                        t[i] = tokens[i + 1];
                    }
                    Text[key] = t;

                    // 文字列定義ファイルテーブルに登録する
                    TextFileTable[key] = name;
                }
            }

            // 定義順リストテーブルに登録する
            OrderListTable.Add(name, orderList);
        }