public static void SetValueInNode(XElement node, KeyT key_T, object value)
{
if (key_T.outFlag.IndexOf(ConfigIni.OUTPUT_S) < 0)
{
return;
}
if (KEY_TYPE.ITEM == key_T.keyType)
{
node.Add(GetItemNode(key_T.key, value.ToString()));
}
else if (KEY_TYPE.ITEM_LIST == key_T.keyType)
{
node.Add(GetItemListNode(key_T.key, value.ToString()));
}
else if (KEY_TYPE.DROP_ID == key_T.keyType)
{
node.Add(GetDropIdListNode(key_T.key, value.ToString()));
}
else if (KEY_TYPE.EFFECT == key_T.keyType)
{
node.Add(GetEffectListNode(key_T.key, value.ToString()));
}
else
{
node.SetElementValue(key_T.key, value);
}
}
public override void PostProcessTableList(List <Table> table_list)
{
// add sceneobject value
{
int condition_key_index = 0;
int c_param1_key_index = 0;
List <KeyT> key_list = table_list[0].keyList;
for (int i = 0; i < key_list.Count; ++i)
{
KeyT key_T = key_list[i];
if ("accept_npc" == key_T.key || "commit_npc" == key_T.key)
{
key_T.keyType = KEY_TYPE.NPC_OBJ;
}
if ("condition" == key_T.key)
{
condition_key_index = i;
}
if ("c_param1" == key_T.key)
{
c_param1_key_index = i;
}
}
{
KeyT key_T = new KeyT();
key_T.key = "target_obj";
key_T.keyType = KEY_TYPE.SCENE_OBJ_LIST;
key_T.outFlag = ConfigIni.OUTPUT_C.ToString();
key_list.Add(key_T);
}
List <List <object> > item_list = table_list[0].itemList;
for (int i = 0; i < item_list.Count; ++i)
{
int condition = Convert.ToInt32(item_list[i][condition_key_index]);
int c_param1 = Convert.ToInt32(item_list[i][c_param1_key_index]);
item_list[i].Add(string.Format("{0},{1}", condition, c_param1));
}
}
base.PostProcessTableList(table_list);
}
private static string GetToLuaKeyValue(KeyT key_T, object value)
{
if (KEY_TYPE.ITEM == key_T.keyType)
{
return(GetLuaItemTable(key_T.key, value.ToString()));
}
else if (KEY_TYPE.ITEM_LIST == key_T.keyType)
{
return(ConvertToLuaItemListTable(key_T.key, value.ToString()));
}
else if (KEY_TYPE.NPC_OBJ == key_T.keyType)
{
return(GetNpcTable(key_T.key, value));
}
else if (KEY_TYPE.SCENE_OBJ_LIST == key_T.keyType)
{
return(GetSceneObjListTable(key_T.key, value));
}
else if (KEY_TYPE.SPLIT_LIST == key_T.keyType)
{
return(GetSplitListTable(key_T.key, value));
}
else if (KEY_TYPE.STEP_LIST == key_T.keyType)
{
return(GetStepListTable(key_T.key, value));
}
else if (KEY_TYPE.NORMA == key_T.keyType || KEY_TYPE.MAIN_KEY == key_T.keyType)
{
if (value.GetType() == typeof(string))
{
return(string.Format("{0}=\"{1}\"", key_T.key, value));
}
else
{
return(string.Format("{0}={1}", key_T.key, value));
}
}
else
{
return("error");
}
}
public override void PostProcessTableList(List <Table> table_list)
{
// combine table
{
List <List <object> > item_list = table_list[0].itemList;
for (int i = 1; i < table_list.Count; i++)
{
List <List <object> > temp_item_list = table_list[i].itemList;
for (int j = 0; j < temp_item_list.Count; ++j)
{
item_list.Add(temp_item_list[j]);
}
}
while (table_list.Count > 1)
{
table_list.RemoveAt(table_list.Count - 1);
}
table_list[0].tableType = TABLE_TYPE.LIST;
table_list[0].keyList[0].keyType = KEY_TYPE.MAIN_KEY;
}
// handle default table
{
Table default_table = LuaBuilder.SimplifiedTable(table_list[0]);
default_table.tableType = TABLE_TYPE.SIMPLE;
default_table.name = "default_table";
KeyT key_T = new KeyT();
key_T.outFlag = "";
key_T.key = "default_table";
key_T.keyType = KEY_TYPE.MAIN_KEY;
default_table.keyList.Add(key_T);
table_list.Add(default_table);
}
}
public static Table SimplifiedTable(Table table)
{
List <KeyT> default_key_list = new List <KeyT>();
List <Dictionary <object, int> > value_count_list = new List <Dictionary <object, int> >();
// init key
for (int j = 0; j < table.keyList.Count; ++j)
{
value_count_list.Add(new Dictionary <object, int>());
KeyT key_T = table.keyList[j].Clone();
if (KEY_TYPE.MAIN_KEY == key_T.keyType)
{
key_T.keyType = KEY_TYPE.NORMA;
}
default_key_list.Add(key_T);
}
// calc value disappear count
for (int m = 0; m < table.itemList.Count; ++m)
{
List <object> value_list = table.itemList[m];
for (int n = 0; n < value_list.Count; ++n)
{
Dictionary <object, int> count_dic = value_count_list[n];
object value = value_list[n];
if (count_dic.ContainsKey(value))
{
++count_dic[value];
}
else
{
count_dic.Add(value, 1);
}
}
}
// find default val
List <object> default_value_list = new List <object>();
for (int x = 0; x < value_count_list.Count; ++x)
{
Dictionary <object, int> count_dic = value_count_list[x];
int max_count = 0;
object default_val = null;
foreach (var item in count_dic)
{
if (item.Value > max_count)
{
max_count = item.Value;
default_val = item.Key;
}
}
default_value_list.Add(default_val);
}
// flag del default val in itemlist
for (int m = 0; m < default_value_list.Count; ++m)
{
object default_val = default_value_list[m];
for (int n = 0; n < table.itemList.Count; ++n)
{
if (default_val.Equals(table.itemList[n][m]) &&
KEY_TYPE.MAIN_KEY != table.keyList[m].keyType)
{
table.itemList[n][m] = null;
}
}
}
// add default to memtable list
Table default_table = new Table();
default_table.name = string.Format("{0}_default_table", table.name);
default_table.tableType = TABLE_TYPE.SIMPLE;
default_table.keyList = default_key_list;
default_table.itemList = new List <List <object> >();
default_table.itemList.Add(default_value_list);
return(default_table);
}
public static string GetLuaTable(Table table)
{
if (!string.IsNullOrEmpty(table.outFlag) &&
table.outFlag.IndexOf(ConfigIni.OUTPUT_S) >= 0)
{
return("");
}
int item_count = table.itemList.Count;
int key_count = table.keyList.Count;
if (key_count <= 0)
{
return("");
}
StringBuilder builder = new StringBuilder();
if (TABLE_TYPE.NORMAL == table.tableType)
{
builder.Append(string.Format("{0}={{\n", table.name));
}
else if (TABLE_TYPE.SIMPLE == table.tableType)
{
builder.Append(string.Format("{0}=", table.name));
}
for (int i = 0; i < item_count; ++i)
{
List <object> value_list = table.itemList[i];
if (KEY_TYPE.MAIN_KEY == table.keyList[0].keyType)
{
if (value_list[0].GetType() == typeof(string))
{
builder.Append(string.Format("[\"{0}\"]={{", value_list[0]));
}
else
{
builder.Append(string.Format("[{0}]={{", value_list[0]));
}
}
else
{
builder.Append("{");
}
for (int j = 0; j < key_count; ++j)
{
KeyT key_T = table.keyList[j];
if (key_T.outFlag.IndexOf(ConfigIni.OUTPUT_C) < 0 ||
null == value_list[j])
{
continue;
}
builder.Append(GetToLuaKeyValue(key_T, value_list[j]));
builder.Append(",");
}
builder.Append(i != item_count - 1 ? "},\n" : "}");
}
if (TABLE_TYPE.NORMAL == table.tableType)
{
builder.Append("}");
}
return(builder.ToString());
}
protected virtual bool ParseSheetData(ISheet sheet, Table ret_table)
{
if (null == sheet)
{
return(false);
}
int row_num = sheet.LastRowNum;
int start_row_index = this.header.startLine - 1;
if (start_row_index < 0 ||
(row_num > 0 && start_row_index >= row_num))
{
return(false);
}
// LastRowNum have bug
int col_num = 1000;
// key
{
IRow out_flag_row = sheet.GetRow(start_row_index);
IRow key_row = sheet.GetRow(start_row_index + 2);
for (int i = 0; i < col_num; ++i)
{
if (null == out_flag_row)
{
break;
}
ICell flag_col = out_flag_row.GetCell(i);
ICell key_col = key_row.GetCell(i);
if (null == flag_col || null == key_col)
{
break;
}
string out_flag = flag_col.ToString();
string key = key_col.ToString();
key = key.Trim(' ');
key = key.Trim('\n');
if (string.IsNullOrEmpty(out_flag) && string.IsNullOrEmpty(key))
{
break;
}
if (!string.IsNullOrEmpty(out_flag) && !string.IsNullOrEmpty(key))
{
KeyT key_T = new KeyT();
key_T.outFlag = out_flag;
key_T.key = key;
string[] flags = out_flag.IndexOf("，") >= 0 ? out_flag.Split('，') : out_flag.Split(',');
key_T.outFlag = flags[0];
if (flags.Length > 1)
{
if (flags[1].Equals(ConfigIni.INDEX_FLAG) && 0 == i)
{
key_T.keyType = KEY_TYPE.MAIN_KEY;
}
else if (flags[1].Equals(ConfigIni.ITEMLIST_FLAG))
{
key_T.keyType = KEY_TYPE.ITEM_LIST;
}
else if (flags[1].Equals(ConfigIni.ITEM_FLAG))
{
key_T.keyType = KEY_TYPE.ITEM;
}
else if (flags[1].Equals(ConfigIni.DROP_ID_FLAG))
{
key_T.keyType = KEY_TYPE.DROP_ID;
}
else if (flags[1].Equals(ConfigIni.EFFECT_FLAG))
{
key_T.keyType = KEY_TYPE.EFFECT;
}
else if (flags[1].Equals(ConfigIni.SPLITLIST_FLAG))
{
key_T.keyType = KEY_TYPE.SPLIT_LIST;
}
else if (flags[1].Equals(ConfigIni.STEPLIST_FLAG))
{
key_T.keyType = KEY_TYPE.STEP_LIST;
}
else
{
key_T.keyType = KEY_TYPE.NORMA;
}
}
ret_table.keyList.Add(key_T);
}
else
{
return(false);
}
}
}
// real col num
col_num = ret_table.keyList.Count;
// LastRowNum have bug
row_num = 10000000;
// list value
for (int i = start_row_index + 3; i < row_num; ++i)
{
IRow row = sheet.GetRow(i);
if (null == row)
{
break; // read end
}
List <object> value_list = new List <object>();
bool is_end = false;
for (int j = 0; j < col_num; ++j)
{
ICell cell = row.GetCell(j);
if (null == cell || string.IsNullOrEmpty(cell.ToString()))
{
value_list.Add(string.Empty);
if (0 == j)
{
is_end = true;
}
}
else
{
if (CellType.Numeric == cell.CellType)
{
value_list.Add(cell.NumericCellValue);
}
else if (CellType.String == cell.CellType)
{
if (Regex.Match(cell.StringCellValue, "^[-+]?[0-9]*\\.?[0-9]+$").Success)
{
value_list.Add(Convert.ToDouble(cell.StringCellValue));
}
else
{
value_list.Add(cell.StringCellValue);
}
}
else if (CellType.Formula == cell.CellType)
{
ICell new_cell = formulaEvaluator.EvaluateInCell(cell);
if (CellType.Numeric == new_cell.CellType)
{
value_list.Add(new_cell.NumericCellValue);
}
else if (CellType.String == new_cell.CellType)
{
if (Regex.Match(cell.StringCellValue, "^[-+]?[0-9]*\\.?[0-9]+$").Success)
{
value_list.Add(Convert.ToDouble(cell.StringCellValue));
}
else
{
value_list.Add(cell.StringCellValue);
}
}
}
}
}
if (is_end)
{
break; // read end
}
ret_table.itemList.Add(value_list);
}
return(true);
}
public override bool BuildServerXml(List <Table> table_list)
{
if (table_list.Count <= 0)
{
return(false);
}
Table table = table_list[0];
foreach (List <object> val_list in table.itemList)
{
int skill_id = Convert.ToInt32(val_list[0]);
XDocument doc = new XDocument();
XElement root_node = new XElement("Skill");
doc.Add(root_node);
bool is_self_pos = false;
for (int i = 0; i < table.keyList.Count; ++i)
{
KeyT key_T = table.keyList[i];
// del effect
if ((key_T.key.Equals("effect") || key_T.key.Equals("tipType")) &&
string.IsNullOrEmpty(val_list[i].ToString()))
{
continue;
}
// set skillname output
if (key_T.key.Equals("skillname"))
{
key_T.outFlag = "cs";
}
if (key_T.key.Equals("Distance") && Convert.ToInt32(val_list[i]) <= 1)
{
is_self_pos = true;
}
XmlBuilder.SetValueInNode(root_node, key_T, val_list[i]);
// special add
{
if (key_T.key.Equals("Distance"))
{
KeyT temp_key_T = new KeyT();
temp_key_T.key = "ProfLimit";
temp_key_T.outFlag = "s";
XmlBuilder.SetValueInNode(root_node, temp_key_T, 4);
}
if (key_T.key.Equals("Range"))
{
KeyT temp_key_T = new KeyT();
temp_key_T.key = "IsSelfPos";
temp_key_T.outFlag = "s";
int is_self_pos_val = is_self_pos && Convert.ToInt32(val_list[i]) > 0 ? 1 : 0;
XmlBuilder.SetValueInNode(root_node, temp_key_T, is_self_pos_val);
}
}
}
string group_name = this.GetSkillGroupName(skill_id);
string path = string.Format("{0}/gameworld/skill/monsterskills/{1}{2}.xml", ConfigIni.XmlDir, group_name, skill_id);
Writer.Instance.WriteXml(path, doc, false);
}
Command.Instance.AddSvnAddFilePath(string.Format("{0}/gameworld/skill/monsterskills/", ConfigIni.XmlDir));
Command.Instance.AddSvnCommitFilePath(string.Format("{0}/gameworld/skill/monsterskills/", ConfigIni.XmlDir));
// monster manager
{
XDocument doc = new XDocument();
XElement root_node = new XElement("skills");
doc.Add(root_node);
Dictionary <string, XElement> group_dic = new Dictionary <string, XElement>();
// init group
{
string[] group_name_list = { "CommonSkillToEnemy", "RangeCommonSkillToEnemyPos", "CommonSkillToSelf",
"RangeCommonSkillToSelfPos", "FaZhenSkillToEnemy", "FaZhenSkillToSelf",
"SkillToEnemyEffectToOther", "RandZoneSkillToSelfPos", "RectRangeSkillToEnemyPos" };
for (int i = 0; i < group_name_list.Length; i++)
{
XElement group_node = new XElement(group_name_list[i]);
root_node.Add(group_node);
group_dic.Add(group_name_list[i], group_node);
}
}
foreach (List <object> val_list in table.itemList)
{
int skill_id = Convert.ToInt32(val_list[0]);
string group_name = this.GetSkillGroupName(skill_id);
XElement group_node = null;
if (!group_dic.TryGetValue(group_name, out group_node))
{
group_node = new XElement(group_name);
root_node.Add(group_node);
group_dic.Add(group_name, group_node);
}
XElement path_node = new XElement("skill");
path_node.SetValue(string.Format("monsterskills/{0}{1}.xml", group_name, skill_id));
group_node.Add(path_node);
}
string path = string.Format("{0}/gameworld/skill/MonsterPetSkillManager.xml", ConfigIni.XmlDir);
Command.Instance.AddSvnAddFilePath(path);
Writer.Instance.WriteXml(path, doc);
Command.Instance.AddSvnCommitFilePath(path);
}
return(true);
}
protected override bool ParseSheetData(ISheet sheet, Table ret_table)
{
if (null == sheet)
{
return(false);
}
int col_num = 1000;
int row_num = 100000;
int start_row_index = this.header.startLine - 1;
// key
{
IRow key_row = sheet.GetRow(start_row_index);
for (int i = 0; i < col_num; ++i)
{
ICell key_col = key_row.GetCell(i);
if (null == key_col)
{
break;
}
KeyT key_T = new KeyT();
key_T.outFlag = "s";
key_T.key = key_col.ToString();
key_T.keyType = KEY_TYPE.NORMA;
ret_table.keyList.Add(key_T);
}
}
List <Object> value_list = null;
int condition_id = -1;
int real_col_num = ret_table.keyList.Count;
for (int i = start_row_index + 1; i < row_num; ++i)
{
IRow row = sheet.GetRow(i);
if (null == row)
{
continue; // read end
}
ICell cell = row.GetCell(0);
if (null != cell && cell.ToString().Equals("END"))
{
break;
}
cell = row.GetCell(0);
if (null != cell && !string.IsNullOrEmpty(cell.ToString()) &&
Convert.ToInt32(cell.NumericCellValue) != condition_id)
{
condition_id = Convert.ToInt32(cell.NumericCellValue);
value_list = new List <object>();
ret_table.itemList.Add(value_list);
}
for (int j = 0; j < real_col_num; ++j)
{
KeyT key_T = ret_table.keyList[j];
cell = row.GetCell(j);
if (null != cell && !string.IsNullOrEmpty(cell.ToString()))
{
object value = null;
if (CellType.Numeric == cell.CellType)
{
value = cell.NumericCellValue;
}
else if (CellType.String == cell.CellType)
{
value = cell.StringCellValue;
}
else if (CellType.Formula == cell.CellType)
{
ICell new_cell = formulaEvaluator.EvaluateInCell(cell);
if (CellType.Numeric == new_cell.CellType)
{
value = new_cell.NumericCellValue;
}
else if (CellType.String == new_cell.CellType)
{
value = new_cell.ToString();
}
}
if (value != null)
{
if (j < value_list.Count && null != value_list[j] &&
(key_T.key.Equals("cond") || key_T.key.Equals("skill_id")))
{
value_list[j] = value_list[j].ToString() + "|" + value.ToString();
}
else
{
value_list.Add(value);
}
}
else
{
value_list.Add(string.Empty);
}
}
}
}
return(true);
}
public override bool BuildServerXml(List <Table> table_list)
{
if (table_list.Count <= 0)
{
return(false);
}
Table table = table_list[0];
foreach (List <object> val_list in table.itemList)
{
XDocument doc = new XDocument();
XElement root_node = new XElement("config");
doc.Add(root_node);
string cond_val = "";
string skill_id_val = "";
for (int i = 0; i < table.keyList.Count; ++i)
{
KeyT key_T = table.keyList[i];
if (key_T.key.Equals("cond"))
{
cond_val = val_list[i].ToString();
}
else if (key_T.key.Equals("skill_id"))
{
skill_id_val = val_list[i].ToString();
}
else if (key_T.key.Equals("comment"))
{
continue;
}
else
{
XmlBuilder.SetValueInNode(root_node, key_T, val_list[i]);
}
}
XElement cond_list_node = new XElement("cond_list");
root_node.Add(cond_list_node);
string[] conds = cond_val.Split('|');
string[] skill_ids = skill_id_val.Split('|');
if (conds.Length != skill_ids.Length)
{
return(false);
}
for (int i = 0; i < conds.Length; i++)
{
XElement cond_node = new XElement("cond");
{
cond_list_node.Add(cond_node);
string[] ary = conds[i].Split('#');
cond_node.SetElementValue("cond_type", ary[0]);
for (int j = 1; j < 5; ++j)
{
int param = j < ary.Length ? Convert.ToInt32(ary[j]) : 0;
cond_node.SetElementValue(string.Format("param{0}", j - 1), param);
}
}
// skill_id
{
XElement skill_list_node = new XElement("skill_list");
cond_node.Add(skill_list_node);
string[] ary = skill_ids[i].Split('#');
for (int j = 0; j < ary.Length; ++j)
{
XElement skill_node = new XElement("skill");
skill_list_node.Add(skill_node);
skill_node.SetElementValue("skill_id", ary[j]);
}
}
}
string path = string.Format("{0}/gameworld/bossskillcondition/{1}.xml", ConfigIni.XmlDir, val_list[0]);
Writer.Instance.WriteXml(path, doc, false);
}
Command.Instance.AddSvnAddFilePath(string.Format("{0}/gameworld/bossskillcondition/", ConfigIni.XmlDir));
Command.Instance.AddSvnCommitFilePath(string.Format("{0}/gameworld/bossskillcondition/", ConfigIni.XmlDir));
// bossskillconditionmanager
{
XDocument doc = new XDocument();
XElement root_node = new XElement("bossskillconditionmanager");
doc.Add(root_node);
foreach (List <object> val_list in table.itemList)
{
XElement path_node = new XElement("path");
path_node.SetValue(string.Format("bossskillcondition/{0}.xml", val_list[0]));
root_node.Add(path_node);
}
string path = string.Format("{0}/gameworld/bossskillconditionmanager.xml", ConfigIni.XmlDir);
Command.Instance.AddSvnAddFilePath(path);
Writer.Instance.WriteXml(path, doc);
Command.Instance.AddSvnCommitFilePath(string.Format("{0}/gameworld/bossskillcondition/", ConfigIni.XmlDir));
}
return(true);
}
