655 lines
16 KiB
C#
655 lines
16 KiB
C#
using System.Linq;
|
|
using System.Text;
|
|
using System.Collections.Generic;
|
|
using System;
|
|
using System.IO;
|
|
using BF;
|
|
|
|
namespace BFEditor
|
|
{
|
|
public class ProtoEnum
|
|
{
|
|
public string enumName = "";
|
|
public int enumNum = 0;
|
|
public int moduleId = 0;
|
|
}
|
|
|
|
public class ProtoModule
|
|
{
|
|
public string moduleDesc = "";
|
|
public int moduleNum = 0;
|
|
}
|
|
|
|
public class ProtoMessage
|
|
{
|
|
public string commentStr = "";
|
|
public string messageName = "";
|
|
public List<ProtoField> fields = new List<ProtoField>();
|
|
}
|
|
|
|
public class ProtoStruct
|
|
{
|
|
public string typeName = "";
|
|
public List<ProtoField> fields = new List<ProtoField>();
|
|
}
|
|
|
|
public class ProtoField
|
|
{
|
|
public string commentStr = "";
|
|
public string fieldName = "";
|
|
public string typeName = "";
|
|
public bool isRepeated = false;
|
|
|
|
public bool isMap = false;
|
|
public string keyTypeName = "";
|
|
public string valueTypeName = "";
|
|
}
|
|
|
|
public class Proto2MarkDown
|
|
{
|
|
const string COMMENT_CONST = "comment = ";
|
|
const string MESSAGE_NAME_CONST = "message_name = ";
|
|
const string MARKDOWN_FILE_NAME = "/bf_proto.md";
|
|
|
|
static string[] TYPE_KEYWORDS = new string[] { "uint32", "int32", "uint64", "int64", "string", "bool" };
|
|
|
|
static string MarkdownPath { get { return LocalData.GetProtoPath(); } }
|
|
|
|
static string MsgIdsProtoPath { get { return LocalData.GetProtoPath() + "/bf_msgids.proto"; } }
|
|
static string CommonProtoPath { get { return LocalData.GetProtoPath() + "/bf_comm.proto"; } }
|
|
static string LogicProtoPath { get { return LocalData.GetProtoPath() + "/bf_logic.proto"; } }
|
|
static string BattleProtoPath { get { return LocalData.GetProtoPath() + "/bf_battle.proto"; } }
|
|
static string protoMessageCommentStr = COMMENT_CONST;
|
|
static string protoStructTypeNameStr = "";
|
|
|
|
static StringBuilder sb = new StringBuilder();
|
|
|
|
static bool readingProtoEnum = false;
|
|
static bool readingProtoMessage = false;
|
|
static bool readingProtoStruct = false;
|
|
static List<ProtoEnum> protoEnums = new List<ProtoEnum>();
|
|
static List<ProtoModule> protoModules = new List<ProtoModule>();
|
|
static List<ProtoMessage> protoMessages = new List<ProtoMessage>();
|
|
static List<ProtoStruct> protoStructs = new List<ProtoStruct>();
|
|
static List<int> moduleIds = new List<int>();
|
|
|
|
public static bool Pb2Markdown()
|
|
{
|
|
protoEnums.Clear();
|
|
protoModules.Clear();
|
|
protoMessages.Clear();
|
|
protoStructs.Clear();
|
|
moduleIds.Clear();
|
|
|
|
if (string.IsNullOrEmpty(MsgIdsProtoPath) || string.IsNullOrEmpty(CommonProtoPath) ||
|
|
string.IsNullOrEmpty(LogicProtoPath) || string.IsNullOrEmpty(MarkdownPath) || string.IsNullOrEmpty(BattleProtoPath))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ParsingEnum();
|
|
ParsingLogic();
|
|
ParsingCommon();
|
|
ParsingBattle();
|
|
SortEnum();
|
|
Export2Markdown();
|
|
return true;
|
|
}
|
|
|
|
static void ParsingEnum()
|
|
{
|
|
var reader = new StreamReader(new FileStream(MsgIdsProtoPath, FileMode.Open));
|
|
var logicLineStr = "";
|
|
while ((logicLineStr = reader.ReadLine()) != null)
|
|
{
|
|
if (logicLineStr == "")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (logicLineStr == "enum MsgId")
|
|
{
|
|
readingProtoEnum = true;
|
|
continue;
|
|
}
|
|
|
|
if (readingProtoEnum)
|
|
{
|
|
if (logicLineStr == "{")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (logicLineStr == "}")
|
|
{
|
|
readingProtoEnum = false;
|
|
continue;
|
|
}
|
|
|
|
ReadProtoEnum(logicLineStr);
|
|
}
|
|
}
|
|
|
|
reader.Close();
|
|
reader.Dispose();
|
|
}
|
|
|
|
static void ParsingLogic()
|
|
{
|
|
var reader = new StreamReader(new FileStream(LogicProtoPath, FileMode.Open));
|
|
var logicLineStr = "";
|
|
while ((logicLineStr = reader.ReadLine()) != null)
|
|
{
|
|
if (logicLineStr == "")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (logicLineStr.Replace(" ", "").Replace("\t", "").StartsWith("//") && logicLineStr.Contains("========"))
|
|
{
|
|
ReadProtoModule(logicLineStr);
|
|
continue;
|
|
}
|
|
|
|
if (logicLineStr.Replace(" ", "").Replace("\t", "").StartsWith("//"))
|
|
{
|
|
protoMessageCommentStr = protoMessageCommentStr + logicLineStr.Replace("//", " ");
|
|
continue;
|
|
}
|
|
|
|
if (logicLineStr.Replace(" ", "").Replace("\t", "").StartsWith("message"))
|
|
{
|
|
readingProtoMessage = true;
|
|
|
|
sb.AppendLine(protoMessageCommentStr);
|
|
protoMessageCommentStr = COMMENT_CONST;
|
|
string messageName = MESSAGE_NAME_CONST + logicLineStr.Replace(" ", "").Replace("\t", "").Replace("message", "").Replace("{", "");
|
|
sb.AppendLine(messageName);
|
|
continue;
|
|
}
|
|
|
|
if (readingProtoMessage)
|
|
{
|
|
if (logicLineStr.Replace(" ", "").Replace("\t", "") == "}")
|
|
{
|
|
ReadProtoMessage(sb);
|
|
readingProtoMessage = false;
|
|
}
|
|
else
|
|
{
|
|
sb.AppendLine(logicLineStr);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
reader.Close();
|
|
reader.Dispose();
|
|
}
|
|
|
|
static void ReadProtoEnum(string enumStr)
|
|
{
|
|
enumStr = enumStr.Replace(" ", "").Replace("\t", "");
|
|
enumStr = enumStr.Replace(";", "");
|
|
var index = enumStr.IndexOf("//");
|
|
if (index > 0)
|
|
{
|
|
enumStr = enumStr.Remove(index, enumStr.Length - index);
|
|
}
|
|
|
|
var equalIndex = enumStr.IndexOf("=");
|
|
var name = enumStr.Substring(0, equalIndex);
|
|
var num = Int32.Parse(enumStr.Substring(equalIndex + 1, enumStr.Length - equalIndex - 1));
|
|
|
|
var pe = new ProtoEnum();
|
|
pe.enumName = name;
|
|
pe.enumNum = num;
|
|
var moduleKey = (num - (num % 1000)) / 1000;
|
|
pe.moduleId = moduleKey;
|
|
|
|
protoEnums.Add(pe);
|
|
}
|
|
|
|
static void ReadProtoModule(string moduleStr)
|
|
{
|
|
moduleStr = moduleStr.Replace(" ", "").Replace("\t", "");
|
|
moduleStr = moduleStr.Replace("=", "");
|
|
moduleStr = moduleStr.Replace("//", "");
|
|
|
|
var pm = new ProtoModule();
|
|
pm.moduleDesc = moduleStr;
|
|
var num = Int32.Parse(System.Text.RegularExpressions.Regex.Replace(moduleStr, @"[^0-9]+", ""));
|
|
pm.moduleNum = num;
|
|
moduleIds.Add(num);
|
|
protoModules.Add(pm);
|
|
}
|
|
|
|
static void ReadProtoMessage(StringBuilder sb)
|
|
{
|
|
var message = sb.ToString();
|
|
var lines = message.Split(new char[] { '\n' });
|
|
var pm = new ProtoMessage();
|
|
foreach (var line in lines)
|
|
{
|
|
if (line == "")
|
|
{
|
|
continue;
|
|
}
|
|
if (line.Contains(COMMENT_CONST))
|
|
{
|
|
pm.commentStr = line.Replace(COMMENT_CONST, "");
|
|
continue;
|
|
}
|
|
if (line.Contains(MESSAGE_NAME_CONST))
|
|
{
|
|
pm.messageName = line.Replace(MESSAGE_NAME_CONST, "");
|
|
continue;
|
|
}
|
|
|
|
var pf = GetProtoField(line);
|
|
pm.fields.Add(pf);
|
|
}
|
|
|
|
protoMessages.Add(pm);
|
|
sb.Clear();
|
|
}
|
|
|
|
static void SortEnum()
|
|
{
|
|
protoEnums.Sort((x, y) => { return x.enumNum - y.enumNum; });
|
|
}
|
|
|
|
static void ParsingCommon()
|
|
{
|
|
var reader = new StreamReader(new FileStream(CommonProtoPath, FileMode.Open));
|
|
var commonLineStr = "";
|
|
while ((commonLineStr = reader.ReadLine()) != null)
|
|
{
|
|
if (commonLineStr == "")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (commonLineStr.Replace(" ", "").Replace("\t", "").StartsWith("message"))
|
|
{
|
|
protoStructTypeNameStr = commonLineStr.Replace(" ", "").Replace("\t", "").Replace("message", "").Replace("{", "");
|
|
readingProtoStruct = true;
|
|
continue;
|
|
}
|
|
|
|
if (readingProtoStruct)
|
|
{
|
|
if (commonLineStr.Replace(" ", "").Replace("\t", "") == "}")
|
|
{
|
|
ReadProtoStruct(sb, protoStructTypeNameStr);
|
|
protoStructTypeNameStr = "";
|
|
readingProtoStruct = false;
|
|
}
|
|
else
|
|
{
|
|
sb.AppendLine(commonLineStr);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
reader.Close();
|
|
reader.Dispose();
|
|
}
|
|
|
|
static void ParsingBattle()
|
|
{
|
|
var reader = new StreamReader(new FileStream(BattleProtoPath, FileMode.Open));
|
|
var lineStr = "";
|
|
while ((lineStr = reader.ReadLine()) != null)
|
|
{
|
|
if (lineStr == "")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (lineStr.Replace(" ", "").Replace("\t", "").StartsWith("message"))
|
|
{
|
|
protoStructTypeNameStr = lineStr.Replace(" ", "").Replace("\t", "").Replace("message", "").Replace("{", "");
|
|
readingProtoStruct = true;
|
|
continue;
|
|
}
|
|
|
|
if (readingProtoStruct)
|
|
{
|
|
if (lineStr.Replace(" ", "").Replace("\t", "") == "}")
|
|
{
|
|
ReadProtoStruct(sb, protoStructTypeNameStr);
|
|
protoStructTypeNameStr = "";
|
|
readingProtoStruct = false;
|
|
}
|
|
else
|
|
{
|
|
sb.AppendLine(lineStr);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
reader.Close();
|
|
reader.Dispose();
|
|
}
|
|
|
|
static void ReadProtoStruct(StringBuilder sb, string structName)
|
|
{
|
|
var ps = new ProtoStruct();
|
|
ps.typeName = structName;
|
|
var message = sb.ToString();
|
|
var lines = message.Split(new char[] { '\n' });
|
|
foreach (var line in lines)
|
|
{
|
|
if (line == "")
|
|
{
|
|
continue;
|
|
}
|
|
ProtoField pf = GetProtoField(line);
|
|
ps.fields.Add(pf);
|
|
}
|
|
sb.Clear();
|
|
protoStructs.Add(ps);
|
|
}
|
|
|
|
static ProtoField GetProtoField(string fieldLine)
|
|
{
|
|
var pf = new ProtoField(); // 解析filed
|
|
if (fieldLine.Replace(" ", "").Replace("\t", "").StartsWith("repeated"))
|
|
{
|
|
pf.isRepeated = true;
|
|
}
|
|
|
|
if (fieldLine.Contains("//"))
|
|
{
|
|
var index1 = fieldLine.IndexOf("//");
|
|
var comment = fieldLine.Substring(index1, fieldLine.Length - index1);
|
|
pf.commentStr = comment;
|
|
}
|
|
|
|
var index2 = fieldLine.IndexOf("=");
|
|
var fieldStr = fieldLine.Remove(index2).Replace("repeated", "");
|
|
if (fieldStr.Replace(" ", "").Replace("\t", "").StartsWith("map<")) // map结构
|
|
{
|
|
pf.isMap = true;
|
|
|
|
var index3 = fieldStr.IndexOf(">") + 1;
|
|
var fieldName = fieldStr.Substring(index3, fieldStr.Length - index3).Replace(" ", "").Replace("\t", "");
|
|
pf.fieldName = fieldName;
|
|
|
|
var keyValueStr = fieldStr.Replace("map<", "").Replace(">", "").Replace(fieldName, "").Replace(" ", "").Replace("\t", "");
|
|
var index4 = keyValueStr.IndexOf(",");
|
|
var keyName = keyValueStr.Substring(0, index4);
|
|
pf.keyTypeName = keyName;
|
|
|
|
var vauleName = keyValueStr.Substring(index4 + 1, keyValueStr.Length - index4 - 1);
|
|
pf.valueTypeName = vauleName.Replace(" ", "").Replace("\t", "");
|
|
}
|
|
else
|
|
{
|
|
while (fieldStr.Contains(" ")) // 这个处理不好
|
|
{
|
|
fieldStr = fieldStr.Replace(" ", " ");
|
|
}
|
|
|
|
var typeFiledNameStr = fieldStr.Split(new char[] { ' ' });
|
|
foreach (var item in typeFiledNameStr)
|
|
{
|
|
if (item == "")
|
|
{
|
|
continue;
|
|
}
|
|
if (pf.typeName == "")
|
|
{
|
|
pf.typeName = item.Replace(" ", "").Replace("\t", "");
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
pf.fieldName = item;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return pf;
|
|
}
|
|
|
|
static void Export2Markdown()
|
|
{
|
|
var sw = new StreamWriter(MarkdownPath + MARKDOWN_FILE_NAME, false);
|
|
WriteTitle(sw);
|
|
WriteProtoModule(sw);
|
|
WriteProtoEnum(sw);
|
|
WriteProtoMessage(sw);
|
|
WriteProtoStructs(sw);
|
|
sw.Close();
|
|
sw.Dispose();
|
|
}
|
|
|
|
static void WriteTitle(StreamWriter sw)
|
|
{
|
|
sw.WriteLine("# *BF协议文档*");
|
|
sw.WriteLine(" ");
|
|
sw.WriteLine("<I><B>Auto Generated By: </B></I>");
|
|
sw.WriteLine(" ");
|
|
sw.WriteLine("bf_logic.proto (协议描述文件)\n");
|
|
sw.WriteLine("bf_comm.proto、bf_battle.proto (结构体描述文件)\n");
|
|
sw.WriteLine("bf_msgids.proto(协议枚举描述文件)\n");
|
|
sw.WriteLine(" ");
|
|
sw.WriteLine("<I><B>文档分为四部分:</B></I>\n");
|
|
sw.WriteLine("[功能模块](#一)、[协议枚举](#二)、[消息内容](#三)、[自定义结构体](#四)");
|
|
sw.WriteLine(" ");
|
|
sw.WriteLine("req: 前端请求， rsp: 服务器应答");
|
|
}
|
|
|
|
static void WriteProtoModule(StreamWriter sw)
|
|
{
|
|
sw.WriteLine(" ");
|
|
sw.WriteLine("## " + GetHtmlLink("top") + GetHtmlLink("一") + "第一部分 模块");
|
|
foreach (var item in protoModules)
|
|
{
|
|
sw.WriteLine(" - [" + "模块id: " + item.moduleNum + " // " + item.moduleDesc + "]" + "(#" + item.moduleNum + ")");
|
|
}
|
|
}
|
|
|
|
static void WriteProtoEnum(StreamWriter sw)
|
|
{
|
|
sw.WriteLine(" ");
|
|
sw.WriteLine("## " + GetHtmlLink("二") + "第二部分 ProtoEnum");
|
|
|
|
var moduleId = protoEnums[0].moduleId;
|
|
sw.WriteLine("### " + GetHtmlLink(moduleId.ToString()) + "模块" + moduleId + " // " + GetModuleDesc(moduleId));
|
|
|
|
foreach (var item in protoEnums)
|
|
{
|
|
if (item.moduleId != moduleId)
|
|
{
|
|
moduleId = item.moduleId;
|
|
sw.WriteLine("### " + GetHtmlLink(moduleId.ToString()) + "模块" + moduleId + " // " + GetModuleDesc(moduleId));
|
|
}
|
|
sw.WriteLine("> - [" + item.enumName + " = " + item.enumNum + "]" + "(#" + item.enumName + ")");
|
|
}
|
|
}
|
|
|
|
static string GetModuleDesc(int key)
|
|
{
|
|
foreach (var item in protoModules)
|
|
{
|
|
if (item.moduleNum == key)
|
|
{
|
|
return item.moduleDesc;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
static void WriteProtoMessage(StreamWriter sw)
|
|
{
|
|
sw.WriteLine(" ");
|
|
sw.WriteLine("## " + GetHtmlLink("三") + "第三部分 ProtoMessage");
|
|
|
|
foreach (var item in protoEnums)
|
|
{
|
|
var rspPM = GetRspMessage(item.enumName);
|
|
var reqPM = GetReqMessage(item.enumName);
|
|
if (rspPM == null && reqPM == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string comment = "";
|
|
if (reqPM != null && reqPM.commentStr != "")
|
|
{
|
|
comment = reqPM.commentStr;
|
|
}
|
|
else
|
|
{
|
|
comment = rspPM.commentStr;
|
|
}
|
|
|
|
sw.WriteLine("## " + "__" + GetHtmlLink(item.enumName) + "消息 " + item.enumName + " //" + comment + "__");
|
|
|
|
WriteProtoMessage(sw, reqPM, "req : ");
|
|
sw.WriteLine(" ");
|
|
|
|
WriteProtoMessage(sw, rspPM, "rsp : ");
|
|
sw.WriteLine(" ");
|
|
|
|
DrawTopBtn(sw);
|
|
|
|
sw.WriteLine("<br>");
|
|
sw.WriteLine("<br>");
|
|
sw.WriteLine(" ");
|
|
}
|
|
}
|
|
|
|
static ProtoMessage GetRspMessage(string enumName)
|
|
{
|
|
const string RSP = "rsp";
|
|
foreach (var item in protoMessages)
|
|
{
|
|
if (item.messageName == RSP + enumName)
|
|
{
|
|
return item;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static ProtoMessage GetReqMessage(string enumName)
|
|
{
|
|
const string REQ = "req";
|
|
foreach (var item in protoMessages)
|
|
{
|
|
if (item.messageName == REQ + enumName)
|
|
{
|
|
return item;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static void WriteProtoMessage(StreamWriter sw, ProtoMessage pm, string title)
|
|
{
|
|
if (pm == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
sw.WriteLine("### " + title);
|
|
sw.WriteLine(" ");
|
|
|
|
WriteTableTitle(sw);
|
|
|
|
foreach (var item in pm.fields)
|
|
{
|
|
WriteField(sw, item);
|
|
}
|
|
}
|
|
|
|
static void WriteTableTitle(StreamWriter sw)
|
|
{
|
|
sw.WriteLine("| repeated | 类型 | 字段名 | 注释 |");
|
|
sw.WriteLine("| :------------ | :------------ | :------------ | :------------ |");
|
|
}
|
|
|
|
static void WriteField(StreamWriter sw, ProtoField pf)
|
|
{
|
|
var str = "| ";
|
|
if (pf.isRepeated)
|
|
{
|
|
str = str + "repeated |";
|
|
}
|
|
else
|
|
{
|
|
str = str + " |";
|
|
}
|
|
|
|
if (pf.isMap)
|
|
{
|
|
str = str + "map< " + GetTypeMarkdownStr(pf.keyTypeName) + " , " + GetTypeMarkdownStr(pf.valueTypeName) + "> |";
|
|
}
|
|
else
|
|
{
|
|
str = str + GetTypeMarkdownStr(pf.typeName) + " |";
|
|
}
|
|
|
|
str = str + pf.fieldName + " |";
|
|
str = str + pf.commentStr + " |";
|
|
sw.WriteLine(str);
|
|
}
|
|
|
|
static string GetTypeMarkdownStr(string typeName)
|
|
{
|
|
if (TYPE_KEYWORDS.Contains(typeName))
|
|
{
|
|
return typeName;
|
|
}
|
|
else
|
|
{
|
|
return "[" + typeName + "]" + "(#TYPE_" + typeName + ")";
|
|
}
|
|
}
|
|
|
|
static void WriteProtoStructs(StreamWriter sw)
|
|
{
|
|
sw.WriteLine(" ");
|
|
sw.WriteLine("## " + GetHtmlLink("四") + "第四部分 结构体");
|
|
|
|
foreach (var item in protoStructs)
|
|
{
|
|
WriteStruct(sw, item);
|
|
sw.WriteLine(" ");
|
|
|
|
DrawTopBtn(sw);
|
|
|
|
sw.WriteLine("<br>");
|
|
sw.WriteLine(" ");
|
|
}
|
|
}
|
|
|
|
static void WriteStruct(StreamWriter sw, ProtoStruct ps)
|
|
{
|
|
sw.WriteLine("### " + "__" + GetHtmlLink("TYPE_" + ps.typeName) + "结构体 " + ps.typeName + "__");
|
|
WriteTableTitle(sw);
|
|
|
|
foreach (var item in ps.fields)
|
|
{
|
|
WriteField(sw, item);
|
|
}
|
|
}
|
|
|
|
static string GetHtmlLink(string name)
|
|
{
|
|
return "<a name = \"" + name + "\" />";
|
|
}
|
|
|
|
static void DrawTopBtn(StreamWriter sw)
|
|
{
|
|
sw.WriteLine("<p align=\"right\"><a href=\"#top\"><I><U>回到顶部</U></I></a></p>");
|
|
}
|
|
}
|
|
}
|