public List <T> ProcessData <T>(string input) where T : class
        {
            var engine = new FileHelperEngine <T>();
            var items  = engine.ReadStringAsList(input);

            return(items);
        }
예제 #2
0
        /// <summary>
        /// 데이터 파일을 이용해 초기화한다.
        /// </summary>
        /// <param name="data">어빌리티 데이터</param>
        public static void Init(string path)
        {
            FileHelperEngine engine   = new FileHelperEngine(typeof(MtAbility));
            List <object>    abilitys = engine.ReadStringAsList(path);
            int i = 0;

            foreach (var item in abilitys)
            {
                var ability = item as MtAbility;
                if (!Instance.ContainsKey(ability.Name))
                {
                    Instance[ability.Name] = ability;
                }
                else
                {
                    Instance[ability.Name + (i++)] = ability;
                }
            }
        }
예제 #3
0
        public async Task OnFileAdded(InputFileChangeEventArgs eventArgs)
        {
            var browserFile = eventArgs.File;

            var engine = new FileHelperEngine(typeof(LuminorStatement));

            using (var reader = new StreamReader(browserFile.OpenReadStream()))
            {
                string content = await reader.ReadToEndAsync();

                var statements = engine.ReadStringAsList(content);

                foreach (var statement in statements)
                {
                    CsvStatements.Add((LuminorStatement)statement);
                }
            }

            if (CsvStatements.Count != 0)
            {
                IsAnyStatements = true;
            }
        }
예제 #4
0
        /// <summary>
        /// 데이터 파일을 이용해 초기화한다.
        /// </summary>
        /// <param name="data">적 데이터</param>
        public static void Init(string path)
        {
            FileHelperEngine engine = new FileHelperEngine(typeof(MtEnemy));

            List <object> enemys = engine.ReadStringAsList(path);
            int           i      = 0;

            foreach (var item in enemys)
            {
                var      enemy = item as MtEnemy;
                string[] parts = enemy.CharaChip.Split('/');

                string key = parts[parts.Length - 1].Split('.')[0];

                if (!Instance.ContainsKey(key))
                {
                    Instance[key] = enemy;
                }
                else
                {
                    Instance[key + (i++)] = enemy;
                }
            }
        }
예제 #5
0
        /// <summary>
        /// 데이터 파일을 이용해 초기화한다.
        /// </summary>
        /// <param name="data">스킬 데이터</param>
        public static void Init(string path)
        {
            FileHelperEngine engine = new FileHelperEngine(typeof(MtSkill));

            List <object> skills = engine.ReadStringAsList(path);
            int           i      = 0;

            foreach (var item in skills)
            {
                var      skill = item as MtSkill;
                string[] parts = skill.Name.Split(']');

                string key = parts[parts.Length - 1];

                if (!Instance.ContainsKey(key))
                {
                    Instance[key] = skill;
                }
                else
                {
                    Instance[key + (i++)] = skill;
                }
            }
        }
예제 #6
0
        /// <summary>
        /// 데이터 파일을 이용해 초기화한다.
        /// </summary>
        /// <param name="data">유닛 데이터</param>
        public static void Init(string data)
        {
            FileHelperEngine engine = new FileHelperEngine(typeof(MtUnit));

            List <object> units = engine.ReadStringAsList(data);
            int           i     = 0;

            foreach (var item in units)
            {
                var      unit  = item as MtUnit;
                string[] parts = unit.CharaChip.Split('/');

                string key = parts[parts.Length - 1].Split('.')[0];

                if (!Instance.ContainsKey(key))
                {
                    Instance[key] = unit;
                }
                else
                {
                    Instance[key + (i++)] = unit;
                }
            }
        }