public static List <PlayerData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <PlayerData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[4];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
PlayerData data = new PlayerData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
data.name = csvFile.mapData[i].data[1];
columnNameArray [1] = "name";
data.department = csvFile.mapData[i].data[2];
columnNameArray [2] = "department";
data.image = csvFile.mapData[i].data[3];
columnNameArray [3] = "image";
dataList.Add(data);
}
return(dataList);
}
public static List <CardData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <CardData>();
dataMap = new Dictionary <int, CardData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[4];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
CardData data = new CardData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
int.TryParse(csvFile.mapData[i].data[1], out data.type);
columnNameArray [1] = "type";
int.TryParse(csvFile.mapData[i].data[2], out data.value);
columnNameArray [2] = "value";
data.resPath = csvFile.mapData[i].data[3];
columnNameArray [3] = "resPath";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
public static List <Soldier> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
List <Soldier> dataList = new List <Soldier>();
for (int i = 0; i < csvFile.mapData.Count; i++)
{
Soldier data = new Soldier();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
data.name = csvFile.mapData[i].data[1];
int.TryParse(csvFile.mapData[i].data[2], out data.accountPopulation);
int.TryParse(csvFile.mapData[i].data[3], out data.needBarrackLevel);
int.TryParse(csvFile.mapData[i].data[4], out data.unitType);
int.TryParse(csvFile.mapData[i].data[5], out data.lifeType);
int.TryParse(csvFile.mapData[i].data[6], out data.attackType);
int.TryParse(csvFile.mapData[i].data[7], out data.damageType);
int.TryParse(csvFile.mapData[i].data[8], out data.armorType);
int.TryParse(csvFile.mapData[i].data[9], out data.moveSpeed);
int.TryParse(csvFile.mapData[i].data[10], out data.TrainingTime);
int.TryParse(csvFile.mapData[i].data[11], out data.attackDistance);
float.TryParse(csvFile.mapData[i].data[12], out data.attackSpeed);
int.TryParse(csvFile.mapData[i].data[13], out data.maxLevel);
int.TryParse(csvFile.mapData[i].data[14], out data.soldierBeginID);
dataList.Add(data);
}
return(dataList);
}
public static List <Heros> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
List <Heros> dataList = new List <Heros>();
for (int i = 0; i < csvFile.mapData.Count; i++)
{
Heros data = new Heros();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
bool.TryParse(csvFile.mapData[i].data[1], out data.isOpen);
data.showName = csvFile.mapData[i].data[2];
int.TryParse(csvFile.mapData[i].data[3], out data.unitType);
int.TryParse(csvFile.mapData[i].data[4], out data.lifeType);
int.TryParse(csvFile.mapData[i].data[5], out data.attackType);
int.TryParse(csvFile.mapData[i].data[6], out data.damageType);
int.TryParse(csvFile.mapData[i].data[7], out data.armorType);
int.TryParse(csvFile.mapData[i].data[8], out data.moveSpeed);
int.TryParse(csvFile.mapData[i].data[9], out data.attackDistance);
float.TryParse(csvFile.mapData[i].data[10], out data.attackSpeed);
int.TryParse(csvFile.mapData[i].data[11], out data.maxLevel);
int.TryParse(csvFile.mapData[i].data[12], out data.growupID);
data.itemIcon = csvFile.mapData[i].data[13];
data.descrption = csvFile.mapData[i].data[14];
data.prefab = csvFile.mapData[i].data[15];
int.TryParse(csvFile.mapData[i].data[16], out data.beginSkill);
int.TryParse(csvFile.mapData[i].data[17], out data.passivitySkill);
dataList.Add(data);
}
return(dataList);
}
public static List <HeroLevelGrowup> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
List <HeroLevelGrowup> dataList = new List <HeroLevelGrowup>();
for (int i = 0; i < csvFile.mapData.Count; i++)
{
HeroLevelGrowup data = new HeroLevelGrowup();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
int.TryParse(csvFile.mapData[i].data[1], out data.life);
int.TryParse(csvFile.mapData[i].data[2], out data.attack);
int.TryParse(csvFile.mapData[i].data[3], out data.defence);
float.TryParse(csvFile.mapData[i].data[4], out data.lifeGrowup);
float.TryParse(csvFile.mapData[i].data[5], out data.attackGrowup);
float.TryParse(csvFile.mapData[i].data[6], out data.defenceGrowup);
float.TryParse(csvFile.mapData[i].data[7], out data.reduceDamage);
float.TryParse(csvFile.mapData[i].data[8], out data.moveSpeedAdd);
float.TryParse(csvFile.mapData[i].data[9], out data.attackSpeedAdd);
float.TryParse(csvFile.mapData[i].data[10], out data.reduceSkillCD);
dataList.Add(data);
}
return(dataList);
}
public static List <ResourceData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <ResourceData>();
dataMap = new Dictionary <int, ResourceData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[5];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
ResourceData data = new ResourceData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
data.resourceName = csvFile.mapData[i].data[1];
columnNameArray [1] = "resourceName";
data.resourcePath = csvFile.mapData[i].data[2];
columnNameArray [2] = "resourcePath";
data.abName = csvFile.mapData[i].data[3];
columnNameArray [3] = "abName";
data.assetName = csvFile.mapData[i].data[4];
columnNameArray [4] = "assetName";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
public static List <EffectData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <EffectData>();
dataMap = new Dictionary <int, EffectData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[14];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
EffectData data = new EffectData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
float.TryParse(csvFile.mapData[i].data[1], out data.duration);
columnNameArray [1] = "duration";
int.TryParse(csvFile.mapData[i].data[2], out data.isConflict);
columnNameArray [2] = "isConflict";
int.TryParse(csvFile.mapData[i].data[3], out data.isStatic);
columnNameArray [3] = "isStatic";
int.TryParse(csvFile.mapData[i].data[4], out data.group);
columnNameArray [4] = "group";
int.TryParse(csvFile.mapData[i].data[5], out data.locationType);
columnNameArray [5] = "locationType";
data.slot = csvFile.mapData[i].data[6];
columnNameArray [6] = "slot";
data.location = new Vector3();
strs = csvFile.mapData[i].data[7].Split(new char[1] {
','
});
data.location.x = (float.Parse(strs[0]));
data.location.y = (float.Parse(strs[1]));
data.location.z = (float.Parse(strs[2]));
columnNameArray [7] = "location";
data.player = csvFile.mapData[i].data[8];
columnNameArray [8] = "player";
data.resourceName = csvFile.mapData[i].data[9];
columnNameArray [9] = "resourceName";
float.TryParse(csvFile.mapData[i].data[10], out data.delay);
columnNameArray [10] = "delay";
int.TryParse(csvFile.mapData[i].data[11], out data.effectType);
columnNameArray [11] = "effectType";
data.anim = csvFile.mapData[i].data[12];
columnNameArray [12] = "anim";
float.TryParse(csvFile.mapData[i].data[13], out data.soundDelay);
columnNameArray [13] = "soundDelay";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
public static List <SkillData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <SkillData>();
dataMap = new Dictionary <int, SkillData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[8];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
SkillData data = new SkillData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
data.name = csvFile.mapData[i].data[1];
columnNameArray [1] = "name";
data.desc = csvFile.mapData[i].data[2];
columnNameArray [2] = "desc";
int.TryParse(csvFile.mapData[i].data[3], out data.icon);
columnNameArray [3] = "icon";
data.cd = new List <int>();
strs = csvFile.mapData[i].data[4].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.cd.Add(int.Parse(strs[j]));
}
columnNameArray [4] = "cd";
int.TryParse(csvFile.mapData[i].data[5], out data.dependSkill);
columnNameArray [5] = "dependSkill";
data.skillAction = new List <int>();
strs = csvFile.mapData[i].data[6].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.skillAction.Add(int.Parse(strs[j]));
}
columnNameArray [6] = "skillAction";
int.TryParse(csvFile.mapData[i].data[7], out data.castRange);
columnNameArray [7] = "castRange";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
public static List <PlayerExp> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
List <PlayerExp> dataList = new List <PlayerExp>();
for (int i = 0; i < csvFile.mapData.Count; i++)
{
PlayerExp data = new PlayerExp();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
int.TryParse(csvFile.mapData[i].data[1], out data.playerExp);
dataList.Add(data);
}
return(dataList);
}
public static List <GameBaseData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <GameBaseData>();
dataMap = new Dictionary <int, GameBaseData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[12];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
GameBaseData data = new GameBaseData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
float.TryParse(csvFile.mapData[i].data[1], out data.forwardSpeed);
columnNameArray [1] = "forwardSpeed";
float.TryParse(csvFile.mapData[i].data[2], out data.backwardsSpeed);
columnNameArray [2] = "backwardsSpeed";
float.TryParse(csvFile.mapData[i].data[3], out data.sidewaysSpeed);
columnNameArray [3] = "sidewaysSpeed";
int.TryParse(csvFile.mapData[i].data[4], out data.hp);
columnNameArray [4] = "hp";
float.TryParse(csvFile.mapData[i].data[5], out data.zhunxingMinValue);
columnNameArray [5] = "zhunxingMinValue";
float.TryParse(csvFile.mapData[i].data[6], out data.zhunxingMaxValue);
columnNameArray [6] = "zhunxingMaxValue";
float.TryParse(csvFile.mapData[i].data[7], out data.zhunxingStepValue);
columnNameArray [7] = "zhunxingStepValue";
data.heartSound = csvFile.mapData[i].data[8];
columnNameArray [8] = "heartSound";
float.TryParse(csvFile.mapData[i].data[9], out data.luopanMaxDis);
columnNameArray [9] = "luopanMaxDis";
float.TryParse(csvFile.mapData[i].data[10], out data.luopanMidDis);
columnNameArray [10] = "luopanMidDis";
float.TryParse(csvFile.mapData[i].data[11], out data.luopanMinDis);
columnNameArray [11] = "luopanMinDis";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
public List <HeroData> LoadCSVHeroDatas()
{
CSVFile file = new CSVFile();
heroDatas = new List <HeroData>();
file.Open(CSVFileConfigs.dict_hero);
List <Row> data = file.mapData;
foreach (Row row in data)
{
HeroData heroData = new HeroData();
row.GetIntValue(DICT_HERO.HERO_TYPEID, out heroData.id);
heroDatas.Add(heroData);
}
return(heroDatas);
}
public static List <CastleLimits> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
List <CastleLimits> dataList = new List <CastleLimits>();
for (int i = 0; i < csvFile.mapData.Count; i++)
{
CastleLimits data = new CastleLimits();
data.id = csvFile.mapData[i].data[0];
bool.TryParse(csvFile.mapData[i].data[1], out data.isOpen);
int.TryParse(csvFile.mapData[i].data[2], out data.barrackID);
int.TryParse(csvFile.mapData[i].data[3], out data.barrackNUM);
int.TryParse(csvFile.mapData[i].data[4], out data.barrackMaxLEvel);
int.TryParse(csvFile.mapData[i].data[5], out data.campsiteID);
int.TryParse(csvFile.mapData[i].data[6], out data.campsiteNUM);
int.TryParse(csvFile.mapData[i].data[7], out data.campsiteMaxLEvel);
int.TryParse(csvFile.mapData[i].data[8], out data.goldmineID);
int.TryParse(csvFile.mapData[i].data[9], out data.goldmineNUM);
int.TryParse(csvFile.mapData[i].data[10], out data.goldmineMaxLEvel);
int.TryParse(csvFile.mapData[i].data[11], out data.magicSpringID);
int.TryParse(csvFile.mapData[i].data[12], out data.magicSpringNUM);
int.TryParse(csvFile.mapData[i].data[13], out data.magicSpringMaxLEvel);
int.TryParse(csvFile.mapData[i].data[14], out data.savingsPotID);
int.TryParse(csvFile.mapData[i].data[15], out data.savingsPotNUM);
int.TryParse(csvFile.mapData[i].data[16], out data.savingsPotMaxLEvel);
int.TryParse(csvFile.mapData[i].data[17], out data.magicBottleID);
int.TryParse(csvFile.mapData[i].data[18], out data.magicBottleNUM);
int.TryParse(csvFile.mapData[i].data[19], out data.magicBottleMaxLEvel);
int.TryParse(csvFile.mapData[i].data[20], out data.heroCampsiteID);
int.TryParse(csvFile.mapData[i].data[21], out data.heroCampsiteNUM);
int.TryParse(csvFile.mapData[i].data[22], out data.heroCampsiteMaxLEvel);
int.TryParse(csvFile.mapData[i].data[23], out data.laboratoryID);
int.TryParse(csvFile.mapData[i].data[24], out data.laboratoryNUM);
int.TryParse(csvFile.mapData[i].data[25], out data.laboratoryMaxLEvel);
int.TryParse(csvFile.mapData[i].data[26], out data.spellFactoryID);
int.TryParse(csvFile.mapData[i].data[27], out data.spellFactoryNUM);
int.TryParse(csvFile.mapData[i].data[28], out data.spellFactoryMaxLEvel);
int.TryParse(csvFile.mapData[i].data[29], out data.workerHouseID);
int.TryParse(csvFile.mapData[i].data[30], out data.workerHouseNUM);
int.TryParse(csvFile.mapData[i].data[31], out data.workerHouseMaxLEvel);
dataList.Add(data);
}
return(dataList);
}
public static List <GameSceneData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <GameSceneData>();
dataMap = new Dictionary <int, GameSceneData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[8];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
GameSceneData data = new GameSceneData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
data.sceneName = csvFile.mapData[i].data[1];
columnNameArray [1] = "sceneName";
data.levelName = csvFile.mapData[i].data[2];
columnNameArray [2] = "levelName";
data.ResRefreshPointsPath = csvFile.mapData[i].data[3];
columnNameArray [3] = "ResRefreshPointsPath";
data.bgsound = csvFile.mapData[i].data[4];
columnNameArray [4] = "bgsound";
data.randomSound = csvFile.mapData[i].data[5];
columnNameArray [5] = "randomSound";
data.stateName = csvFile.mapData[i].data[6];
columnNameArray [6] = "stateName";
data.enterPoint = new Vector3();
strs = csvFile.mapData[i].data[7].Split(new char[1] {
','
});
data.enterPoint.x = (float.Parse(strs[0]));
data.enterPoint.y = (float.Parse(strs[1]));
data.enterPoint.z = (float.Parse(strs[2]));
columnNameArray [7] = "enterPoint";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
public static List <CastleBuildDesign> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
List <CastleBuildDesign> dataList = new List <CastleBuildDesign>();
for (int i = 0; i < csvFile.mapData.Count; i++)
{
CastleBuildDesign data = new CastleBuildDesign();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
data.cName = csvFile.mapData[i].data[1];
data.eName = csvFile.mapData[i].data[2];
int.TryParse(csvFile.mapData[i].data[3], out data.maxBuildingNUM);
int.TryParse(csvFile.mapData[i].data[4], out data.maxLevel);
int.TryParse(csvFile.mapData[i].data[5], out data.castleBuildingBeginID);
dataList.Add(data);
}
return(dataList);
}
public static List <SpellSolutionProperty> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
List <SpellSolutionProperty> dataList = new List <SpellSolutionProperty>();
for (int i = 0; i < csvFile.mapData.Count; i++)
{
SpellSolutionProperty data = new SpellSolutionProperty();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
data.name = csvFile.mapData[i].data[1];
int.TryParse(csvFile.mapData[i].data[2], out data.trainGoldCost);
float.TryParse(csvFile.mapData[i].data[3], out data.totalValue);
int.TryParse(csvFile.mapData[i].data[4], out data.singleValue);
int.TryParse(csvFile.mapData[i].data[5], out data.magicCost);
int.TryParse(csvFile.mapData[i].data[6], out data.timeCost);
dataList.Add(data);
}
return(dataList);
}
public static List <CameraAnimData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <CameraAnimData>();
dataMap = new Dictionary <int, CameraAnimData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[8];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
CameraAnimData data = new CameraAnimData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
data.name = csvFile.mapData[i].data[1];
columnNameArray [1] = "name";
int.TryParse(csvFile.mapData[i].data[2], out data.xRate);
columnNameArray [2] = "xRate";
float.TryParse(csvFile.mapData[i].data[3], out data.xSwing);
columnNameArray [3] = "xSwing";
int.TryParse(csvFile.mapData[i].data[4], out data.yRate);
columnNameArray [4] = "yRate";
float.TryParse(csvFile.mapData[i].data[5], out data.ySwing);
columnNameArray [5] = "ySwing";
int.TryParse(csvFile.mapData[i].data[6], out data.zRate);
columnNameArray [6] = "zRate";
float.TryParse(csvFile.mapData[i].data[7], out data.zSwing);
columnNameArray [7] = "zSwing";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
public static List <SceneData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <SceneData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[10];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
SceneData data = new SceneData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
int.TryParse(csvFile.mapData[i].data[1], out data.sceneType1);
columnNameArray [1] = "sceneType1";
data.sizeType1 = csvFile.mapData[i].data[2];
columnNameArray [2] = "sizeType1";
data.sizeTypeNum1 = csvFile.mapData[i].data[3];
columnNameArray [3] = "sizeTypeNum1";
int.TryParse(csvFile.mapData[i].data[4], out data.sceneType2);
columnNameArray [4] = "sceneType2";
data.sizeType2 = csvFile.mapData[i].data[5];
columnNameArray [5] = "sizeType2";
data.sizeTypeNum2 = csvFile.mapData[i].data[6];
columnNameArray [6] = "sizeTypeNum2";
int.TryParse(csvFile.mapData[i].data[7], out data.sceneType3);
columnNameArray [7] = "sceneType3";
data.sizeType3 = csvFile.mapData[i].data[8];
columnNameArray [8] = "sizeType3";
data.sizeTypeNum3 = csvFile.mapData[i].data[9];
columnNameArray [9] = "sizeTypeNum3";
dataList.Add(data);
}
return(dataList);
}
public static List <CastleBuildingItems> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
List <CastleBuildingItems> dataList = new List <CastleBuildingItems>();
for (int i = 0; i < csvFile.mapData.Count; i++)
{
CastleBuildingItems data = new CastleBuildingItems();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
data.name = csvFile.mapData[i].data[1];
int.TryParse(csvFile.mapData[i].data[2], out data.level);
int.TryParse(csvFile.mapData[i].data[3], out data.goldCost);
int.TryParse(csvFile.mapData[i].data[4], out data.magicCost);
int.TryParse(csvFile.mapData[i].data[5], out data.timeCost);
int.TryParse(csvFile.mapData[i].data[6], out data.numericalAttributes);
int.TryParse(csvFile.mapData[i].data[7], out data.getPlayeExp);
data.buildingART = csvFile.mapData[i].data[8];
dataList.Add(data);
}
return(dataList);
}
public static List <SoldierProperty> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
List <SoldierProperty> dataList = new List <SoldierProperty>();
for (int i = 0; i < csvFile.mapData.Count; i++)
{
SoldierProperty data = new SoldierProperty();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
data.name = csvFile.mapData[i].data[1];
data.soldier = csvFile.mapData[i].data[2];
data.needLaboratoryLevel = csvFile.mapData[i].data[3];
int.TryParse(csvFile.mapData[i].data[4], out data.trainMagicCost);
data.healthProperty = csvFile.mapData[i].data[5];
data.attackValue = csvFile.mapData[i].data[6];
int.TryParse(csvFile.mapData[i].data[7], out data.magicCost);
int.TryParse(csvFile.mapData[i].data[8], out data.oilCost);
int.TryParse(csvFile.mapData[i].data[9], out data.timeCost);
dataList.Add(data);
}
return(dataList);
}
public static List <SpellSolution> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
List <SpellSolution> dataList = new List <SpellSolution>();
for (int i = 0; i < csvFile.mapData.Count; i++)
{
SpellSolution data = new SpellSolution();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
data.name = csvFile.mapData[i].data[1];
int.TryParse(csvFile.mapData[i].data[2], out data.needSpellFactoryLevel);
float.TryParse(csvFile.mapData[i].data[3], out data.radius);
float.TryParse(csvFile.mapData[i].data[4], out data.randomRadius);
int.TryParse(csvFile.mapData[i].data[5], out data.NUM);
float.TryParse(csvFile.mapData[i].data[6], out data.interval);
int.TryParse(csvFile.mapData[i].data[7], out data.TrainingTime);
int.TryParse(csvFile.mapData[i].data[8], out data.maxLevel);
int.TryParse(csvFile.mapData[i].data[9], out data.spellSolutionBeginID);
dataList.Add(data);
}
return(dataList);
}
void Create(FileInfo fileInfo)
{
string fileName = fileInfo.Name;
string className = fileName.Replace(".csv", "");
string head = className.Substring(0, 1).ToUpper();
string body = className.Substring(1, className.Length - 1);
className = head + body;
fileName = classFilePath + "/" + head + body + ".cs";
if (!Directory.Exists(classFilePath))
{
Directory.CreateDirectory(classFilePath);
}
if (File.Exists(fileName))
{
Debug.Log("Delete " + fileName);
File.Delete(fileName);
}
StreamWriter file = new StreamWriter(fileName, false);
file.WriteLine("using System;");
file.WriteLine("using System.Collections.Generic;");
file.WriteLine("using System.Collections;");
file.WriteLine("using UnityEngine;");
file.WriteLine("namespace BattleFramework.Data{");
file.WriteLine(" [System.Serializable]");
file.WriteLine(" public class " + className + " {");
string resourcesPath = "Configs/" + className;
file.WriteLine(" public static string csvFilePath = \"" + resourcesPath + "\";");
CSVFile csvFile = new CSVFile();
csvFile.Open(resourcesPath);
file.WriteLine(" public static string[] columnNameArray = new string[" + csvFile.listColumnName.Count + "];");
file.WriteLine(" public static List<" + className + "> dataList;");
file.WriteLine(" public static Dictionary<int, " + className + "> dataMap;");
file.WriteLine(" public static List<" + className + "> LoadDatas(){");
file.WriteLine(" CSVFile csvFile = new CSVFile();");
file.WriteLine(" csvFile.Open (csvFilePath);");
file.WriteLine(" dataList = new List<" + className + ">();");
file.WriteLine(" dataMap = new Dictionary<int, " + className + ">();");
file.WriteLine(" string[] strs;");
file.WriteLine(" string[] strsTwo;");
file.WriteLine(" List<int> listChild;");
file.WriteLine(" columnNameArray = new string[" + csvFile.listColumnName.Count + "];");
file.WriteLine(" for(int i = 0;i < csvFile.mapData.Count;i ++){");
file.WriteLine(" " + className + " data = new " + className + "();");
List <string> fields = new List <string> ();
string columnName;
string type;
string fieldName;
for (int i = 0; i < csvFile.listColumnName.Count; i++)
{
columnName = csvFile.listColumnName [i];
//default csv column name is column name plus column type ,e.g NAME_STRING,ID_INT;
//so we can know the column type and then generate class field;
if (columnName.LastIndexOf("_") != -1)
{
type = columnName.Substring(columnName.LastIndexOf("_") + 1, columnName.Length - columnName.LastIndexOf("_") - 1).ToUpper();
}
else
{
type = "";
fieldName = columnName;
}
if (type.ToUpper() == "INT")
{
type = "int";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "FLOAT")
{
type = "float";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "BOOL")
{
type = "bool";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "STRING")
{
type = "string";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "MAP<INT,FLOAT>")
{
type = "Dictionary<int, float>";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "LIST<INT>")
{
type = "List<int>";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "LIST<FLOAT>")
{
type = "List<float>";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "LIST<STRING>")
{
type = "List<string>";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "LIST2")
{
type = "List<List<int>>";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "VECTOR3")
{
type = "Vector3";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else
{
type = "string";
fieldName = columnName;
}
if (type == "string")
{
file.WriteLine(" data." + fieldName + " = " + "csvFile.mapData[i].data[" + i + "];");
}
else if (type == "Vector3")
{
file.WriteLine(" data." + fieldName + "= new Vector3();");
file.WriteLine(" strs = " + "csvFile.mapData[i].data[" + i + "].Split(new char[1]{\',\'});");
file.WriteLine(" data." + fieldName + ".x = (float.Parse(strs[0]));");
file.WriteLine(" data." + fieldName + ".y = (float.Parse(strs[1]));");
file.WriteLine(" data." + fieldName + ".z = (float.Parse(strs[2]));");
}
else if (type == "List<int>")
{
file.WriteLine(" data." + fieldName + "= new List<int>();");
file.WriteLine(" strs = " + "csvFile.mapData[i].data[" + i + "].Split(new char[1]{\',\'});");
file.WriteLine(" for(int j=0;j<strs.Length;j++){");
file.WriteLine(" data." + fieldName + ".Add(int.Parse(strs[j]));");
file.WriteLine(" }");
}
else if (type == "List<float>")
{
file.WriteLine(" data." + fieldName + "= new List<float>();");
file.WriteLine(" strs = " + "csvFile.mapData[i].data[" + i + "].Split(new char[1]{\',\'});");
file.WriteLine(" for(int j=0;j<strs.Length;j++){");
file.WriteLine(" data." + fieldName + ".Add(float.Parse(strs[j]));");
file.WriteLine(" }");
}
else if (type == "List<string>")
{
file.WriteLine(" data." + fieldName + "= new List<string>();");
file.WriteLine(" strs = " + "csvFile.mapData[i].data[" + i + "].Split(new char[1]{\',\'});");
file.WriteLine(" for(int j=0;j<strs.Length;j++){");
file.WriteLine(" data." + fieldName + ".Add(strs[j]);");
file.WriteLine(" }");
}
else if (type == "Dictionary<int, float>")
{
file.WriteLine(" data." + fieldName + "= new Dictionary<int, float>();");
file.WriteLine(" strs = " + "csvFile.mapData[i].data[" + i + "].Split(new char[1]{\',\'});");
file.WriteLine(" for(int j=0;j<strs.Length;j++){");
file.WriteLine(" strsTwo = " + "strs[j].Split(new char[1]{\':\'});");
file.WriteLine(" if (strsTwo.Length == 2)");
file.WriteLine(" data." + fieldName + ".Add(int.Parse(strsTwo[0]),float.Parse(strsTwo[1]));");
file.WriteLine(" }");
}
else if (type == "List<List<int>>")
{
file.WriteLine(" data." + fieldName + "= new List<List<int>>();");
file.WriteLine(" strs = " + "csvFile.mapData[i].data[" + i + "].Split(new char[1]{\';\'});");
file.WriteLine(" for(int j=0;j<strs.Length;j++){");
file.WriteLine(" listChild = new List<int>();");
file.WriteLine(" strsTwo = " + "strs[j].Split(new char[1]{\',\'});");
file.WriteLine(" for(int m=0;m<strsTwo.Length;m++){");
file.WriteLine(" listChild.Add(int.Parse(strsTwo[m]));");
file.WriteLine(" }");
file.WriteLine(" data." + fieldName + ".Add(listChild);");
file.WriteLine(" }");
}
else
{
file.WriteLine(" " + type + ".TryParse(" + "csvFile.mapData[i].data[" + i + "],out data." + fieldName + ")" + ";");
}
fields.Add(" public " + type + " " + fieldName + ";//" + csvFile.listColumnComment [i]);
file.WriteLine(" columnNameArray [" + i + "] = \"" + fieldName + "\";");
}
file.WriteLine(" dataList.Add(data);");
file.WriteLine(" if (!dataMap.ContainsKey(data.id))");
file.WriteLine(" dataMap.Add(data.id,data);");
file.WriteLine(" }");
file.WriteLine(" return dataList;");
file.WriteLine(" }");
//添加根据ID查询的方法
file.WriteLine(" ");
file.WriteLine(" public static " + className + " GetByID (int id,List<" + className + "> data)");
file.WriteLine(" {");
file.WriteLine(" foreach (" + className + " item in " + "data) {");
file.WriteLine(" if (id == item.id) {");
file.WriteLine(" return item;");
file.WriteLine(" }");
file.WriteLine(" }");
file.WriteLine(" return null;");
file.WriteLine(" }");
file.WriteLine(" ");
//添加根据ID查询的方法
file.WriteLine(" ");
file.WriteLine(" public static " + className + " GetByID (int id)");
file.WriteLine(" {");
file.WriteLine(" return GetByID(id,dataList);");
file.WriteLine(" }");
file.WriteLine(" ");
for (int i = 0; i < fields.Count; i++)
{
file.WriteLine(fields [i]);
}
//添加根据ID查询的方法
file.WriteLine(" }");
file.WriteLine("}");
file.Flush();
file.Close();
Debug.Log("Create " + fileName);
}
public static List <MonsterData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <MonsterData>();
dataMap = new Dictionary <int, MonsterData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[19];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
MonsterData data = new MonsterData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
int.TryParse(csvFile.mapData[i].data[1], out data.modelId);
columnNameArray [1] = "modelId";
data.resourceName = csvFile.mapData[i].data[2];
columnNameArray [2] = "resourceName";
int.TryParse(csvFile.mapData[i].data[3], out data.type);
columnNameArray [3] = "type";
data.name = csvFile.mapData[i].data[4];
columnNameArray [4] = "name";
int.TryParse(csvFile.mapData[i].data[5], out data.currentHP);
columnNameArray [5] = "currentHP";
int.TryParse(csvFile.mapData[i].data[6], out data.maxHP);
columnNameArray [6] = "maxHP";
float.TryParse(csvFile.mapData[i].data[7], out data.guardRadius);
columnNameArray [7] = "guardRadius";
int.TryParse(csvFile.mapData[i].data[8], out data.guardType);
columnNameArray [8] = "guardType";
float.TryParse(csvFile.mapData[i].data[9], out data.patrolRadius);
columnNameArray [9] = "patrolRadius";
int.TryParse(csvFile.mapData[i].data[10], out data.patrolType);
columnNameArray [10] = "patrolType";
float.TryParse(csvFile.mapData[i].data[11], out data.PatrolCD);
columnNameArray [11] = "PatrolCD";
float.TryParse(csvFile.mapData[i].data[12], out data.floowDis);
columnNameArray [12] = "floowDis";
float.TryParse(csvFile.mapData[i].data[13], out data.attackDis);
columnNameArray [13] = "attackDis";
int.TryParse(csvFile.mapData[i].data[14], out data.attackValue);
columnNameArray [14] = "attackValue";
data.skillIDs = new List <int>();
strs = csvFile.mapData[i].data[15].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.skillIDs.Add(int.Parse(strs[j]));
}
columnNameArray [15] = "skillIDs";
int.TryParse(csvFile.mapData[i].data[16], out data.isRemove);
columnNameArray [16] = "isRemove";
int.TryParse(csvFile.mapData[i].data[17], out data.exp);
columnNameArray [17] = "exp";
data.hitShader = new List <int>();
strs = csvFile.mapData[i].data[18].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.hitShader.Add(int.Parse(strs[j]));
}
columnNameArray [18] = "hitShader";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
public static List <SkillAction> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <SkillAction>();
dataMap = new Dictionary <int, SkillAction>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[33];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
SkillAction data = new SkillAction();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
int.TryParse(csvFile.mapData[i].data[1], out data.type);
columnNameArray [1] = "type";
int.TryParse(csvFile.mapData[i].data[2], out data.targetType);
columnNameArray [2] = "targetType";
int.TryParse(csvFile.mapData[i].data[3], out data.targetRangeType);
columnNameArray [3] = "targetRangeType";
data.targetRangeParam = new List <float>();
strs = csvFile.mapData[i].data[4].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.targetRangeParam.Add(float.Parse(strs[j]));
}
columnNameArray [4] = "targetRangeParam";
float.TryParse(csvFile.mapData[i].data[5], out data.hitXoffset);
columnNameArray [5] = "hitXoffset";
float.TryParse(csvFile.mapData[i].data[6], out data.hitYoffset);
columnNameArray [6] = "hitYoffset";
int.TryParse(csvFile.mapData[i].data[7], out data.castPosType);
columnNameArray [7] = "castPosType";
float.TryParse(csvFile.mapData[i].data[8], out data.damageMul);
columnNameArray [8] = "damageMul";
int.TryParse(csvFile.mapData[i].data[9], out data.damageAdd);
columnNameArray [9] = "damageAdd";
int.TryParse(csvFile.mapData[i].data[10], out data.maxTargetCount);
columnNameArray [10] = "maxTargetCount";
int.TryParse(csvFile.mapData[i].data[11], out data.actionTime);
columnNameArray [11] = "actionTime";
int.TryParse(csvFile.mapData[i].data[12], out data.nextHitTime);
columnNameArray [12] = "nextHitTime";
int.TryParse(csvFile.mapData[i].data[13], out data.minAttackValue);
columnNameArray [13] = "minAttackValue";
int.TryParse(csvFile.mapData[i].data[14], out data.maxAttackValue);
columnNameArray [14] = "maxAttackValue";
int.TryParse(csvFile.mapData[i].data[15], out data.action);
columnNameArray [15] = "action";
int.TryParse(csvFile.mapData[i].data[16], out data.actionBeginDuration);
columnNameArray [16] = "actionBeginDuration";
int.TryParse(csvFile.mapData[i].data[17], out data.duration);
columnNameArray [17] = "duration";
int.TryParse(csvFile.mapData[i].data[18], out data.cameraTweenId);
columnNameArray [18] = "cameraTweenId";
int.TryParse(csvFile.mapData[i].data[19], out data.cameraTweenSL);
columnNameArray [19] = "cameraTweenSL";
int.TryParse(csvFile.mapData[i].data[20], out data.cameraTweenST);
columnNameArray [20] = "cameraTweenST";
int.TryParse(csvFile.mapData[i].data[21], out data.hitFxID);
columnNameArray [21] = "hitFxID";
data.hitAction = new List <int>();
strs = csvFile.mapData[i].data[22].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.hitAction.Add(int.Parse(strs[j]));
}
columnNameArray [22] = "hitAction";
data.sfx = new Dictionary <int, float>();
strs = csvFile.mapData[i].data[23].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
strsTwo = strs[j].Split(new char[1] {
':'
});
if (strsTwo.Length == 2)
{
data.sfx.Add(int.Parse(strsTwo[0]), float.Parse(strsTwo[1]));
}
}
columnNameArray [23] = "sfx";
data.hitSfx = new List <int>();
strs = csvFile.mapData[i].data[24].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.hitSfx.Add(int.Parse(strs[j]));
}
columnNameArray [24] = "hitSfx";
float.TryParse(csvFile.mapData[i].data[25], out data.extraSpeed);
columnNameArray [25] = "extraSpeed";
int.TryParse(csvFile.mapData[i].data[26], out data.extraSt);
columnNameArray [26] = "extraSt";
int.TryParse(csvFile.mapData[i].data[27], out data.extraSl);
columnNameArray [27] = "extraSl";
float.TryParse(csvFile.mapData[i].data[28], out data.teleportDistance);
columnNameArray [28] = "teleportDistance";
float.TryParse(csvFile.mapData[i].data[29], out data.hitExtraSpeed);
columnNameArray [29] = "hitExtraSpeed";
int.TryParse(csvFile.mapData[i].data[30], out data.hitExtraSt);
columnNameArray [30] = "hitExtraSt";
int.TryParse(csvFile.mapData[i].data[31], out data.hitExtraSl);
columnNameArray [31] = "hitExtraSl";
int.TryParse(csvFile.mapData[i].data[32], out data.damageFlag);
columnNameArray [32] = "damageFlag";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
void Create(FileInfo[] filePaths)
{
string mainClassName = "ExcelData";
string mainFileName = classFilePath + "/" + mainClassName + ".cs";
if (Directory.Exists(classFilePath))
{
Directory.Delete(classFilePath, true);
}
if (!Directory.Exists(classFilePath))
{
Directory.CreateDirectory(classFilePath);
}
if (File.Exists(mainFileName))
{
Debug.Log("Delete " + mainFileName);
File.Delete(mainFileName);
}
StreamWriter file = new StreamWriter(mainFileName, false);
file.WriteLine("using System;");
file.WriteLine("using System.Collections.Generic;");
file.WriteLine("using System.Collections;");
file.WriteLine("using UnityEngine;");
file.WriteLine("namespace BattleFramework.Data{");
file.WriteLine(" [System.Serializable]");
file.WriteLine(" public static class " + mainClassName + " {");
foreach (FileInfo fileInfo in filePaths)
{
string fileName = fileInfo.Name;
string className = fileName.Replace(".csv", "");
string head = className.Substring(0, 1).ToUpper();
string body = className.Substring(1, className.Length - 1);
className = head + body;
file.WriteLine("//--------------------" + className + "---------------------------//");
file.WriteLine(" public class " + className + " {");
string resourcesPath = "Configs/" + className;
file.WriteLine(" public static string csvFilePath = \"" + resourcesPath + "\";");
CSVFile csvFile = new CSVFile();
csvFile.Open(resourcesPath);
file.WriteLine(" public static List<" + className + "> LoadDatas(){");
file.WriteLine(" CSVFile csvFile = new CSVFile();");
file.WriteLine(" csvFile.Open (csvFilePath);");
file.WriteLine(" List<" + className + "> dataList = new List<" + className + ">();");
file.WriteLine(" for(int i = 0;i < csvFile.mapData.Count;i ++){");
file.WriteLine(" " + className + " data = new " + className + "();");
List <string> fields = new List <string> ();
string columnName;
string type;
string fieldName;
for (int i = 0; i < csvFile.listColumnName.Count; i++)
{
columnName = csvFile.listColumnName [i];
//default csv column name is column name plus column type ,e.g NAME_STRING,ID_INT;
//so we can know the column type and then generate class field;
if (columnName.LastIndexOf("_") != -1)
{
type = columnName.Substring(columnName.LastIndexOf("_") + 1, columnName.Length - columnName.LastIndexOf("_") - 1).ToUpper();
}
else
{
type = "";
fieldName = columnName;
}
if (type.ToUpper() == "INT")
{
type = "int";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "FLOAT")
{
type = "float";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "BOOL")
{
type = "bool";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "STRING")
{
type = "string";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else if (type.ToUpper() == "LIST")
{
type = "List<int>";
fieldName = columnName.Substring(0, columnName.LastIndexOf("_"));
}
else
{
type = "string";
fieldName = columnName;
}
if (type == "string")
{
file.WriteLine(" data." + fieldName + " = " + "csvFile.mapData[i].data[" + i + "];");
}
else if (type == "List<int>")
{
file.WriteLine(" data." + fieldName + "= new List<int>();");
file.WriteLine(" string[] strs = " + "csvFile.mapData[i].data[" + i + "].Split(new char[1]{\',\'});");
file.WriteLine(" for(int j=0;j<strs.Length;j++){");
file.WriteLine(" data." + fieldName + ".Add(int.Parse(strs[j]));");
file.WriteLine(" }");
}
else
{
file.WriteLine(" " + type + ".TryParse(" + "csvFile.mapData[i].data[" + i + "],out data." + fieldName + ")" + ";");
}
fields.Add(" public " + type + " " + fieldName + ";//" + csvFile.listColumnComment [i]);
}
file.WriteLine(" dataList.Add(data);");
file.WriteLine(" }");
file.WriteLine(" return dataList;");
file.WriteLine(" }");
file.WriteLine(" ");
for (int i = 0; i < fields.Count; i++)
{
file.WriteLine(fields [i]);
}
file.WriteLine(" }");
file.WriteLine(" ");
file.Flush();
Debug.Log("Create " + fileName);
}
file.WriteLine(" }");
file.WriteLine("}");
file.Flush();
file.Close();
}
public static List <EquipData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <EquipData>();
dataMap = new Dictionary <int, EquipData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[13];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
EquipData data = new EquipData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
data.type = new List <int>();
strs = csvFile.mapData[i].data[1].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.type.Add(int.Parse(strs[j]));
}
columnNameArray [1] = "type";
data.prefabPath = new List <string>();
strs = csvFile.mapData[i].data[2].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.prefabPath.Add(strs[j]);
}
columnNameArray [2] = "prefabPath";
data.mesh = csvFile.mapData[i].data[3];
columnNameArray [3] = "mesh";
data.material = csvFile.mapData[i].data[4];
columnNameArray [4] = "material";
data.slot = new List <string>();
strs = csvFile.mapData[i].data[5].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.slot.Add(strs[j]);
}
columnNameArray [5] = "slot";
data.slotInCity = new List <string>();
strs = csvFile.mapData[i].data[6].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.slotInCity.Add(strs[j]);
}
columnNameArray [6] = "slotInCity";
int.TryParse(csvFile.mapData[i].data[7], out data.priority);
columnNameArray [7] = "priority";
int.TryParse(csvFile.mapData[i].data[8], out data.putOnMethod);
columnNameArray [8] = "putOnMethod";
int.TryParse(csvFile.mapData[i].data[9], out data.suit);
columnNameArray [9] = "suit";
int.TryParse(csvFile.mapData[i].data[10], out data.suitCount);
columnNameArray [10] = "suitCount";
int.TryParse(csvFile.mapData[i].data[11], out data.isWeapon);
columnNameArray [11] = "isWeapon";
data.subEquip = new List <int>();
strs = csvFile.mapData[i].data[12].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.subEquip.Add(int.Parse(strs[j]));
}
columnNameArray [12] = "subEquip";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
public static List <GoodsData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <GoodsData>();
dataMap = new Dictionary <int, GoodsData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[12];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
GoodsData data = new GoodsData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
data.goodsName = csvFile.mapData[i].data[1];
columnNameArray [1] = "goodsName";
data.resourceName = csvFile.mapData[i].data[2];
columnNameArray [2] = "resourceName";
int.TryParse(csvFile.mapData[i].data[3], out data.goodsType);
columnNameArray [3] = "goodsType";
int.TryParse(csvFile.mapData[i].data[4], out data.effectType);
columnNameArray [4] = "effectType";
int.TryParse(csvFile.mapData[i].data[5], out data.effectValue);
columnNameArray [5] = "effectValue";
data.info = csvFile.mapData[i].data[6];
columnNameArray [6] = "info";
float.TryParse(csvFile.mapData[i].data[7], out data.dis);
columnNameArray [7] = "dis";
data.sound = csvFile.mapData[i].data[8];
columnNameArray [8] = "sound";
data.position = new Vector3();
strs = csvFile.mapData[i].data[9].Split(new char[1] {
','
});
data.position.x = (float.Parse(strs[0]));
data.position.y = (float.Parse(strs[1]));
data.position.z = (float.Parse(strs[2]));
columnNameArray [9] = "position";
data.scale = new Vector3();
strs = csvFile.mapData[i].data[10].Split(new char[1] {
','
});
data.scale.x = (float.Parse(strs[0]));
data.scale.y = (float.Parse(strs[1]));
data.scale.z = (float.Parse(strs[2]));
columnNameArray [10] = "scale";
data.rotion = new Vector3();
strs = csvFile.mapData[i].data[11].Split(new char[1] {
','
});
data.rotion.x = (float.Parse(strs[0]));
data.rotion.y = (float.Parse(strs[1]));
data.rotion.z = (float.Parse(strs[2]));
columnNameArray [11] = "rotion";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
public static List <AvatarModelData> LoadDatas()
{
CSVFile csvFile = new CSVFile();
csvFile.Open(csvFilePath);
dataList = new List <AvatarModelData>();
dataMap = new Dictionary <int, AvatarModelData>();
string[] strs;
string[] strsTwo;
List <int> listChild;
columnNameArray = new string[11];
for (int i = 0; i < csvFile.mapData.Count; i++)
{
AvatarModelData data = new AvatarModelData();
int.TryParse(csvFile.mapData[i].data[0], out data.id);
columnNameArray [0] = "id";
data.bornFx = new List <int>();
strs = csvFile.mapData[i].data[1].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.bornFx.Add(int.Parse(strs[j]));
}
columnNameArray [1] = "bornFx";
int.TryParse(csvFile.mapData[i].data[2], out data.bornTime);
columnNameArray [2] = "bornTime";
int.TryParse(csvFile.mapData[i].data[3], out data.deadTime);
columnNameArray [3] = "deadTime";
data.dieFx = new List <int>();
strs = csvFile.mapData[i].data[4].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.dieFx.Add(int.Parse(strs[j]));
}
columnNameArray [4] = "dieFx";
data.nakedEquipList = new List <int>();
strs = csvFile.mapData[i].data[5].Split(new char[1] {
','
});
for (int j = 0; j < strs.Length; j++)
{
data.nakedEquipList.Add(int.Parse(strs[j]));
}
columnNameArray [5] = "nakedEquipList";
data.prefabName = csvFile.mapData[i].data[6];
columnNameArray [6] = "prefabName";
float.TryParse(csvFile.mapData[i].data[7], out data.scale);
columnNameArray [7] = "scale";
float.TryParse(csvFile.mapData[i].data[8], out data.scaleRadius);
columnNameArray [8] = "scaleRadius";
float.TryParse(csvFile.mapData[i].data[9], out data.speed);
columnNameArray [9] = "speed";
data.vocation = csvFile.mapData[i].data[10];
columnNameArray [10] = "vocation";
dataList.Add(data);
if (!dataMap.ContainsKey(data.id))
{
dataMap.Add(data.id, data);
}
}
return(dataList);
}
