diff --git a/bin/json/game_gourmet.json b/bin/json/game_gourmet.json new file mode 100644 index 000000000..822bc5720 --- /dev/null +++ b/bin/json/game_gourmet.json @@ -0,0 +1,386 @@ +[ + { + "id": 1, + "type": 1001, + "level": 1, + "levelname": { + "key": "gourmet_ln1", + "text": "马马虎虎" + }, + "colour": 0, + "name": { + "key": "gourmet_1001", + "text": "魔法料理" + }, + "picture": "ty_wz_k1", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 2, + "type": 1001, + "level": 2, + "levelname": { + "key": "gourmet_ln2", + "text": "匠心独运" + }, + "colour": 0, + "name": { + "key": "gourmet_1001", + "text": "魔法料理" + }, + "picture": "ty_wz_k1", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 3, + "type": 1001, + "level": 3, + "levelname": { + "key": "gourmet_ln3", + "text": "孰能生巧" + }, + "colour": 0, + "name": { + "key": "gourmet_1001", + "text": "魔法料理" + }, + "picture": "ty_wz_k1", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 4, + "type": 1001, + "level": 4, + "levelname": { + "key": "gourmet_ln4", + "text": "可圈可点" + }, + "colour": 0, + "name": { + "key": "gourmet_1001", + "text": "魔法料理" + }, + "picture": "ty_wz_k1", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 5, + "type": 1002, + "level": 1, + "levelname": { + "key": "gourmet_ln1", + "text": "马马虎虎" + }, + "colour": 0, + "name": { + "key": "gourmet_1002", + "text": "功夫料理" + }, + "picture": "ty_wz_k2", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 6, + "type": 1002, + "level": 2, + "levelname": { + "key": "gourmet_ln2", + "text": "匠心独运" + }, + "colour": 0, + "name": { + "key": "gourmet_1002", + "text": "功夫料理" + }, + "picture": "ty_wz_k2", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 7, + "type": 1002, + "level": 3, + "levelname": { + "key": "gourmet_ln3", + "text": "孰能生巧" + }, + "colour": 0, + "name": { + "key": "gourmet_1002", + "text": "功夫料理" + }, + "picture": "ty_wz_k2", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 8, + "type": 1002, + "level": 4, + "levelname": { + "key": "gourmet_ln4", + "text": "可圈可点" + }, + "colour": 0, + "name": { + "key": "gourmet_1002", + "text": "功夫料理" + }, + "picture": "ty_wz_k2", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 9, + "type": 1003, + "level": 1, + "levelname": { + "key": "gourmet_ln1", + "text": "马马虎虎" + }, + "colour": 0, + "name": { + "key": "gourmet_1003", + "text": "科技料理" + }, + "picture": "ty_wz_k3", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 10, + "type": 1003, + "level": 2, + "levelname": { + "key": "gourmet_ln2", + "text": "匠心独运" + }, + "colour": 0, + "name": { + "key": "gourmet_1003", + "text": "科技料理" + }, + "picture": "ty_wz_k3", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 11, + "type": 1003, + "level": 3, + "levelname": { + "key": "gourmet_ln3", + "text": "孰能生巧" + }, + "colour": 0, + "name": { + "key": "gourmet_1003", + "text": "科技料理" + }, + "picture": "ty_wz_k3", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 12, + "type": 1003, + "level": 4, + "levelname": { + "key": "gourmet_ln4", + "text": "可圈可点" + }, + "colour": 0, + "name": { + "key": "gourmet_1003", + "text": "科技料理" + }, + "picture": "ty_wz_k3", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 13, + "type": 1004, + "level": 1, + "levelname": { + "key": "gourmet_ln1", + "text": "马马虎虎" + }, + "colour": 0, + "name": { + "key": "gourmet_1004", + "text": "月能料理" + }, + "picture": "ty_wz_k4", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 14, + "type": 1004, + "level": 2, + "levelname": { + "key": "gourmet_ln2", + "text": "匠心独运" + }, + "colour": 0, + "name": { + "key": "gourmet_1004", + "text": "月能料理" + }, + "picture": "ty_wz_k4", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 15, + "type": 1004, + "level": 3, + "levelname": { + "key": "gourmet_ln3", + "text": "孰能生巧" + }, + "colour": 0, + "name": { + "key": "gourmet_1004", + "text": "月能料理" + }, + "picture": "ty_wz_k4", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + }, + { + "id": 16, + "type": 1004, + "level": 4, + "levelname": { + "key": "gourmet_ln4", + "text": "可圈可点" + }, + "colour": 0, + "name": { + "key": "gourmet_1004", + "text": "月能料理" + }, + "picture": "ty_wz_k4", + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "using": 1, + "propsgroup": 10001 + } +] \ No newline at end of file diff --git a/bin/json/game_gourmetskill.json b/bin/json/game_gourmetskill.json new file mode 100644 index 000000000..efd243c55 --- /dev/null +++ b/bin/json/game_gourmetskill.json @@ -0,0 +1,738 @@ +[ + { + "id": 10011, + "type": 1001, + "initial": 1, + "level": 1, + "levelname": { + "key": "gourmet_ln1", + "text": "马马虎虎" + }, + "colour": 0, + "name": { + "key": "gourmet_ln1", + "text": "魔法厨艺" + }, + "needtime": 60, + "display": 1000, + "probability": 1000, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln1", + "text": "无" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10012, + "type": 1001, + "initial": 0, + "level": 2, + "levelname": { + "key": "gourmet_ln2", + "text": "匠心独运" + }, + "colour": 0, + "name": { + "key": "gourmet_ln2", + "text": "魔法厨艺" + }, + "needtime": 120, + "display": 1000, + "probability": 500, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln2", + "text": "极低" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10013, + "type": 1001, + "initial": 0, + "level": 3, + "levelname": { + "key": "gourmet_ln3", + "text": "孰能生巧" + }, + "colour": 0, + "name": { + "key": "gourmet_ln3", + "text": "魔法厨艺" + }, + "needtime": 240, + "display": 1000, + "probability": 20, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln3", + "text": "中等" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10014, + "type": 1001, + "initial": 0, + "level": 4, + "levelname": { + "key": "gourmet_ln4", + "text": "可圈可点" + }, + "colour": 0, + "name": { + "key": "gourmet_ln4", + "text": "魔法厨艺" + }, + "needtime": 480, + "display": 1000, + "probability": 10, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln4", + "text": "较高" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10021, + "type": 1002, + "initial": 1, + "level": 1, + "levelname": { + "key": "gourmet_ln1", + "text": "马马虎虎" + }, + "colour": 0, + "name": { + "key": "gourmet_ln1", + "text": "功夫厨艺" + }, + "needtime": 60, + "display": 1000, + "probability": 1000, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln1", + "text": "无" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10022, + "type": 1002, + "initial": 0, + "level": 2, + "levelname": { + "key": "gourmet_ln2", + "text": "匠心独运" + }, + "colour": 0, + "name": { + "key": "gourmet_ln2", + "text": "功夫厨艺" + }, + "needtime": 120, + "display": 1000, + "probability": 500, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln2", + "text": "极低" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10023, + "type": 1002, + "initial": 0, + "level": 3, + "levelname": { + "key": "gourmet_ln3", + "text": "孰能生巧" + }, + "colour": 0, + "name": { + "key": "gourmet_ln3", + "text": "功夫厨艺" + }, + "needtime": 240, + "display": 1000, + "probability": 20, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln3", + "text": "中等" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10024, + "type": 1002, + "initial": 0, + "level": 4, + "levelname": { + "key": "gourmet_ln4", + "text": "可圈可点" + }, + "colour": 0, + "name": { + "key": "gourmet_ln4", + "text": "功夫厨艺" + }, + "needtime": 480, + "display": 1000, + "probability": 10, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln4", + "text": "较高" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10031, + "type": 1003, + "initial": 1, + "level": 1, + "levelname": { + "key": "gourmet_ln1", + "text": "马马虎虎" + }, + "colour": 0, + "name": { + "key": "gourmet_ln1", + "text": "科技厨艺" + }, + "needtime": 60, + "display": 1000, + "probability": 1000, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln1", + "text": "无" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10032, + "type": 1003, + "initial": 0, + "level": 2, + "levelname": { + "key": "gourmet_ln2", + "text": "匠心独运" + }, + "colour": 0, + "name": { + "key": "gourmet_ln2", + "text": "科技厨艺" + }, + "needtime": 120, + "display": 1000, + "probability": 500, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln2", + "text": "极低" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10033, + "type": 1003, + "initial": 0, + "level": 3, + "levelname": { + "key": "gourmet_ln3", + "text": "孰能生巧" + }, + "colour": 0, + "name": { + "key": "gourmet_ln3", + "text": "科技厨艺" + }, + "needtime": 240, + "display": 1000, + "probability": 20, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln3", + "text": "中等" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10034, + "type": 1003, + "initial": 0, + "level": 4, + "levelname": { + "key": "gourmet_ln4", + "text": "可圈可点" + }, + "colour": 0, + "name": { + "key": "gourmet_ln4", + "text": "科技厨艺" + }, + "needtime": 480, + "display": 1000, + "probability": 10, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln4", + "text": "较高" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10041, + "type": 1004, + "initial": 1, + "level": 1, + "levelname": { + "key": "gourmet_ln1", + "text": "马马虎虎" + }, + "colour": 0, + "name": { + "key": "gourmet_ln1", + "text": "月能厨艺" + }, + "needtime": 60, + "display": 1000, + "probability": 1000, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln1", + "text": "无" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10042, + "type": 1004, + "initial": 0, + "level": 2, + "levelname": { + "key": "gourmet_ln2", + "text": "匠心独运" + }, + "colour": 0, + "name": { + "key": "gourmet_ln2", + "text": "月能厨艺" + }, + "needtime": 120, + "display": 1000, + "probability": 500, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln2", + "text": "极低" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10043, + "type": 1004, + "initial": 0, + "level": 3, + "levelname": { + "key": "gourmet_ln3", + "text": "孰能生巧" + }, + "colour": 0, + "name": { + "key": "gourmet_ln3", + "text": "月能厨艺" + }, + "needtime": 240, + "display": 1000, + "probability": 20, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln3", + "text": "中等" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10044, + "type": 1004, + "initial": 0, + "level": 4, + "levelname": { + "key": "gourmet_ln4", + "text": "可圈可点" + }, + "colour": 0, + "name": { + "key": "gourmet_ln4", + "text": "月能厨艺" + }, + "needtime": 480, + "display": 1000, + "probability": 10, + "icon": "ty_wz_k1", + "item": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ], + "affix": { + "key": "gourmet_ln4", + "text": "较高" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10051, + "type": 1005, + "initial": 0, + "level": 1, + "levelname": { + "key": "gourmet_ln1", + "text": "马马虎虎" + }, + "colour": 0, + "name": { + "key": "gourmet_ln1", + "text": "高效制作" + }, + "needtime": -5, + "display": 1000, + "probability": 1000, + "icon": "ty_wz_k1", + "item": [], + "affix": { + "key": "gourmet_ln1", + "text": "出餐时间-5分钟" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10052, + "type": 1005, + "initial": 0, + "level": 2, + "levelname": { + "key": "gourmet_ln2", + "text": "匠心独运" + }, + "colour": 0, + "name": { + "key": "gourmet_ln2", + "text": "高效制作" + }, + "needtime": -10, + "display": 1000, + "probability": 500, + "icon": "ty_wz_k1", + "item": [], + "affix": { + "key": "gourmet_ln2", + "text": "出餐时间-10分钟" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10053, + "type": 1005, + "initial": 0, + "level": 3, + "levelname": { + "key": "gourmet_ln3", + "text": "孰能生巧" + }, + "colour": 0, + "name": { + "key": "gourmet_ln3", + "text": "高效制作" + }, + "needtime": -15, + "display": 1000, + "probability": 20, + "icon": "ty_wz_k1", + "item": [], + "affix": { + "key": "gourmet_ln3", + "text": "出餐时间-15分钟" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + }, + { + "id": 10054, + "type": 1005, + "initial": 0, + "level": 4, + "levelname": { + "key": "gourmet_ln4", + "text": "可圈可点" + }, + "colour": 0, + "name": { + "key": "gourmet_ln4", + "text": "高效制作" + }, + "needtime": -20, + "display": 1000, + "probability": 10, + "icon": "ty_wz_k1", + "item": [], + "affix": { + "key": "gourmet_ln4", + "text": "出餐时间-20分钟" + }, + "affix_colour": 0, + "consume": [ + { + "a": "item", + "t": "10002", + "n": 1 + } + ] + } +] \ No newline at end of file diff --git a/modules/gourmet/api_createorder.go b/modules/gourmet/api_createorder.go new file mode 100644 index 000000000..a23326c0a --- /dev/null +++ b/modules/gourmet/api_createorder.go @@ -0,0 +1,25 @@ +package gourmet + +import ( + "go_dreamfactory/comm" + "go_dreamfactory/pb" + + "google.golang.org/protobuf/proto" +) + +//参数校验 +func (this *apiComp) GetRewardCheck(session comm.IUserSession, req *pb.GourmetGetRewardReq) (code pb.ErrorCode) { + + return +} + +///美食城领取奖励 +func (this *apiComp) GetReward(session comm.IUserSession, req *pb.GourmetGetRewardReq) (code pb.ErrorCode, data proto.Message) { + + code = this.GetRewardCheck(session, req) + if code != pb.ErrorCode_Success { + return // 参数校验失败直接返回 + } + + return +} diff --git a/modules/gourmet/api_getReward.go b/modules/gourmet/api_getReward.go index e8b9d36a7..1772b1857 100644 --- a/modules/gourmet/api_getReward.go +++ b/modules/gourmet/api_getReward.go @@ -8,17 +8,15 @@ import ( ) //参数校验 -func (this *apiComp) GetRewardCheck(session comm.IUserSession, req *pb.PagodaGetRewardReq) (code pb.ErrorCode) { - if req.Id <= 0 { - code = pb.ErrorCode_ReqParameterError - } +func (this *apiComp) CreateOrderCheck(session comm.IUserSession, req *pb.GourmetCreateOrderReq) (code pb.ErrorCode) { + return } -///获取主线关卡信息 -func (this *apiComp) GetReward(session comm.IUserSession, req *pb.PagodaGetRewardReq) (code pb.ErrorCode, data proto.Message) { +///美食城创建订单 +func (this *apiComp) CreateOrder(session comm.IUserSession, req *pb.GourmetCreateOrderReq) (code pb.ErrorCode, data proto.Message) { - code = this.GetRewardCheck(session, req) + code = this.CreateOrderCheck(session, req) if code != pb.ErrorCode_Success { return // 参数校验失败直接返回 } diff --git a/modules/gourmet/api_getlist.go b/modules/gourmet/api_getlist.go index 466147b62..11270ec92 100644 --- a/modules/gourmet/api_getlist.go +++ b/modules/gourmet/api_getlist.go @@ -8,13 +8,13 @@ import ( ) //参数校验 -func (this *apiComp) GetListCheck(session comm.IUserSession, req *pb.PagodaGetListReq) (code pb.ErrorCode) { +func (this *apiComp) GetListCheck(session comm.IUserSession, req *pb.GourmetGetListReq) (code pb.ErrorCode) { return } -///获取主线关卡信息 -func (this *apiComp) GetList(session comm.IUserSession, req *pb.PagodaGetListReq) (code pb.ErrorCode, data proto.Message) { +///获取美食城基本信息 +func (this *apiComp) GetList(session comm.IUserSession, req *pb.GourmetGetListReq) (code pb.ErrorCode, data proto.Message) { return } diff --git a/modules/hero/api_drawCard.go b/modules/hero/api_drawCard.go index 9ef71b437..7106ed0fe 100644 --- a/modules/hero/api_drawCard.go +++ b/modules/hero/api_drawCard.go @@ -18,19 +18,19 @@ func (this *apiComp) DrawCardCheck(session comm.IUserSession, req *pb.HeroDrawCa //抽卡 func (this *apiComp) DrawCard(session comm.IUserSession, req *pb.HeroDrawCardReq) (code pb.ErrorCode, data proto.Message) { var ( - szCards []string // 最终抽到的卡牌 - drawCount int32 // 抽卡次数 - szStar []int32 //星级 - costRes []*cfg.Gameatn - star4Max int32 // 10连抽最大4星数量 - star5Max int32 // 10连抽最大5星数量 - cfgDraw *cfg.GameglobalData - costAtn *cfg.Gameatn - heroRecord *pb.DBHeroRecord - pool string - //heroRecord *pb.DBHeroRecord // 英雄扩展属性 + szCards []string // 最终抽到的卡牌 + drawCount int32 // 抽卡次数 + szStar []int32 //星级 + costRes []*cfg.Gameatn + star4Max int32 // 10连抽最大4星数量 + star5Max int32 // 10连抽最大5星数量 + cfgDraw *cfg.GameglobalData + costAtn *cfg.Gameatn + heroRecord *pb.DBHeroRecord + pool string + _mapAddHero map[string]int32 ) - // test + _mapAddHero = make(map[string]int32, 0) cfgDraw = this.module.configure.GetGlobalConf() // 读取抽卡配置文件 if cfgDraw == nil { return @@ -184,10 +184,10 @@ func (this *apiComp) DrawCard(session comm.IUserSession, req *pb.HeroDrawCardReq if code != pb.ErrorCode_Success { return } - if err := this.module.modelHero.createMultiHero(session.GetUserId(), szCards...); err != nil { - code = pb.ErrorCode_HeroCreate - return + for _, heroId := range szCards { + _mapAddHero[heroId]++ } + code = this.module.CreateRepeatHeros(session, _mapAddHero, true) rsp.Heroes = szCards session.SendMsg(string(this.module.GetType()), DrawCard, rsp) diff --git a/pb/gourmet_db.pb.go b/pb/gourmet_db.pb.go new file mode 100644 index 000000000..d07deecf4 --- /dev/null +++ b/pb/gourmet_db.pb.go @@ -0,0 +1,307 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.0 +// protoc v3.20.0 +// source: gourmet/gourmet_db.proto + +package pb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// 烹饪 +type Cooking struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FoodType int32 `protobuf:"varint,1,opt,name=foodType,proto3" json:"foodType"` // 料理类型 + FoodCount int32 `protobuf:"varint,2,opt,name=foodCount,proto3" json:"foodCount"` // 料理数量 + CookTime int32 `protobuf:"varint,3,opt,name=cookTime,proto3" json:"cookTime"` // 烹饪时间 +} + +func (x *Cooking) Reset() { + *x = Cooking{} + if protoimpl.UnsafeEnabled { + mi := &file_gourmet_gourmet_db_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Cooking) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Cooking) ProtoMessage() {} + +func (x *Cooking) ProtoReflect() protoreflect.Message { + mi := &file_gourmet_gourmet_db_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Cooking.ProtoReflect.Descriptor instead. +func (*Cooking) Descriptor() ([]byte, []int) { + return file_gourmet_gourmet_db_proto_rawDescGZIP(), []int{0} +} + +func (x *Cooking) GetFoodType() int32 { + if x != nil { + return x.FoodType + } + return 0 +} + +func (x *Cooking) GetFoodCount() int32 { + if x != nil { + return x.FoodCount + } + return 0 +} + +func (x *Cooking) GetCookTime() int32 { + if x != nil { + return x.CookTime + } + return 0 +} + +type DBGourmet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id" bson:"_id"` //ID + Uid string `protobuf:"bytes,2,opt,name=uid,proto3" json:"uid" bson:"uid"` //用户ID + CookingFood *Cooking `protobuf:"bytes,3,opt,name=cookingFood,proto3" json:"cookingFood"` // 正在烹饪的食品 + Foods []*Cooking `protobuf:"bytes,4,rep,name=foods,proto3" json:"foods"` // 等待烹饪的食品 + Items []*UserAssets `protobuf:"bytes,5,rep,name=items,proto3" json:"items"` // 已经做好的食品 + Skilllv map[int32]int32 `protobuf:"bytes,6,rep,name=skilllv,proto3" json:"skilllv" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` // 技能等级 + Ordercosttime int32 `protobuf:"varint,7,opt,name=ordercosttime,proto3" json:"ordercosttime"` // 订单消耗的时常 + Ctime int64 `protobuf:"varint,8,opt,name=ctime,proto3" json:"ctime"` // 订单创建时间 +} + +func (x *DBGourmet) Reset() { + *x = DBGourmet{} + if protoimpl.UnsafeEnabled { + mi := &file_gourmet_gourmet_db_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DBGourmet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DBGourmet) ProtoMessage() {} + +func (x *DBGourmet) ProtoReflect() protoreflect.Message { + mi := &file_gourmet_gourmet_db_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DBGourmet.ProtoReflect.Descriptor instead. +func (*DBGourmet) Descriptor() ([]byte, []int) { + return file_gourmet_gourmet_db_proto_rawDescGZIP(), []int{1} +} + +func (x *DBGourmet) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *DBGourmet) GetUid() string { + if x != nil { + return x.Uid + } + return "" +} + +func (x *DBGourmet) GetCookingFood() *Cooking { + if x != nil { + return x.CookingFood + } + return nil +} + +func (x *DBGourmet) GetFoods() []*Cooking { + if x != nil { + return x.Foods + } + return nil +} + +func (x *DBGourmet) GetItems() []*UserAssets { + if x != nil { + return x.Items + } + return nil +} + +func (x *DBGourmet) GetSkilllv() map[int32]int32 { + if x != nil { + return x.Skilllv + } + return nil +} + +func (x *DBGourmet) GetOrdercosttime() int32 { + if x != nil { + return x.Ordercosttime + } + return 0 +} + +func (x *DBGourmet) GetCtime() int64 { + if x != nil { + return x.Ctime + } + return 0 +} + +var File_gourmet_gourmet_db_proto protoreflect.FileDescriptor + +var file_gourmet_gourmet_db_proto_rawDesc = []byte{ + 0x0a, 0x18, 0x67, 0x6f, 0x75, 0x72, 0x6d, 0x65, 0x74, 0x2f, 0x67, 0x6f, 0x75, 0x72, 0x6d, 0x65, + 0x74, 0x5f, 0x64, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x5f, 0x0a, 0x07, 0x43, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, + 0x67, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x6f, 0x6f, 0x64, 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x6f, 0x6f, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, + 0x09, 0x66, 0x6f, 0x6f, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x09, 0x66, 0x6f, 0x6f, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, + 0x6f, 0x6f, 0x6b, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x63, + 0x6f, 0x6f, 0x6b, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xc7, 0x02, 0x0a, 0x09, 0x44, 0x42, 0x47, 0x6f, + 0x75, 0x72, 0x6d, 0x65, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x2a, 0x0a, 0x0b, 0x63, 0x6f, 0x6f, 0x6b, 0x69, + 0x6e, 0x67, 0x46, 0x6f, 0x6f, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x08, 0x2e, 0x43, + 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x52, 0x0b, 0x63, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x46, + 0x6f, 0x6f, 0x64, 0x12, 0x1e, 0x0a, 0x05, 0x66, 0x6f, 0x6f, 0x64, 0x73, 0x18, 0x04, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x08, 0x2e, 0x43, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x52, 0x05, 0x66, 0x6f, + 0x6f, 0x64, 0x73, 0x12, 0x21, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x05, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x52, + 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x12, 0x31, 0x0a, 0x07, 0x73, 0x6b, 0x69, 0x6c, 0x6c, 0x6c, + 0x76, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x44, 0x42, 0x47, 0x6f, 0x75, 0x72, + 0x6d, 0x65, 0x74, 0x2e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x6c, 0x76, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x07, 0x73, 0x6b, 0x69, 0x6c, 0x6c, 0x6c, 0x76, 0x12, 0x24, 0x0a, 0x0d, 0x6f, 0x72, 0x64, + 0x65, 0x72, 0x63, 0x6f, 0x73, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0d, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x63, 0x6f, 0x73, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x63, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, + 0x63, 0x74, 0x69, 0x6d, 0x65, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x6c, 0x76, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x42, 0x06, 0x5a, 0x04, 0x2e, 0x3b, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_gourmet_gourmet_db_proto_rawDescOnce sync.Once + file_gourmet_gourmet_db_proto_rawDescData = file_gourmet_gourmet_db_proto_rawDesc +) + +func file_gourmet_gourmet_db_proto_rawDescGZIP() []byte { + file_gourmet_gourmet_db_proto_rawDescOnce.Do(func() { + file_gourmet_gourmet_db_proto_rawDescData = protoimpl.X.CompressGZIP(file_gourmet_gourmet_db_proto_rawDescData) + }) + return file_gourmet_gourmet_db_proto_rawDescData +} + +var file_gourmet_gourmet_db_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_gourmet_gourmet_db_proto_goTypes = []interface{}{ + (*Cooking)(nil), // 0: Cooking + (*DBGourmet)(nil), // 1: DBGourmet + nil, // 2: DBGourmet.SkilllvEntry + (*UserAssets)(nil), // 3: UserAssets +} +var file_gourmet_gourmet_db_proto_depIdxs = []int32{ + 0, // 0: DBGourmet.cookingFood:type_name -> Cooking + 0, // 1: DBGourmet.foods:type_name -> Cooking + 3, // 2: DBGourmet.items:type_name -> UserAssets + 2, // 3: DBGourmet.skilllv:type_name -> DBGourmet.SkilllvEntry + 4, // [4:4] is the sub-list for method output_type + 4, // [4:4] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name +} + +func init() { file_gourmet_gourmet_db_proto_init() } +func file_gourmet_gourmet_db_proto_init() { + if File_gourmet_gourmet_db_proto != nil { + return + } + file_comm_proto_init() + if !protoimpl.UnsafeEnabled { + file_gourmet_gourmet_db_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Cooking); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gourmet_gourmet_db_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DBGourmet); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_gourmet_gourmet_db_proto_rawDesc, + NumEnums: 0, + NumMessages: 3, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_gourmet_gourmet_db_proto_goTypes, + DependencyIndexes: file_gourmet_gourmet_db_proto_depIdxs, + MessageInfos: file_gourmet_gourmet_db_proto_msgTypes, + }.Build() + File_gourmet_gourmet_db_proto = out.File + file_gourmet_gourmet_db_proto_rawDesc = nil + file_gourmet_gourmet_db_proto_goTypes = nil + file_gourmet_gourmet_db_proto_depIdxs = nil +} diff --git a/pb/gourmet_msg.pb.go b/pb/gourmet_msg.pb.go new file mode 100644 index 000000000..de860132c --- /dev/null +++ b/pb/gourmet_msg.pb.go @@ -0,0 +1,451 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.0 +// protoc v3.20.0 +// source: gourmet/gourmet_msg.proto + +package pb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// 查询塔进度 +type GourmetGetListReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *GourmetGetListReq) Reset() { + *x = GourmetGetListReq{} + if protoimpl.UnsafeEnabled { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GourmetGetListReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GourmetGetListReq) ProtoMessage() {} + +func (x *GourmetGetListReq) ProtoReflect() protoreflect.Message { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GourmetGetListReq.ProtoReflect.Descriptor instead. +func (*GourmetGetListReq) Descriptor() ([]byte, []int) { + return file_gourmet_gourmet_msg_proto_rawDescGZIP(), []int{0} +} + +// 返回进度信息 +type GourmetGetListResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Data *DBGourmet `protobuf:"bytes,1,opt,name=data,proto3" json:"data"` +} + +func (x *GourmetGetListResp) Reset() { + *x = GourmetGetListResp{} + if protoimpl.UnsafeEnabled { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GourmetGetListResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GourmetGetListResp) ProtoMessage() {} + +func (x *GourmetGetListResp) ProtoReflect() protoreflect.Message { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GourmetGetListResp.ProtoReflect.Descriptor instead. +func (*GourmetGetListResp) Descriptor() ([]byte, []int) { + return file_gourmet_gourmet_msg_proto_rawDescGZIP(), []int{1} +} + +func (x *GourmetGetListResp) GetData() *DBGourmet { + if x != nil { + return x.Data + } + return nil +} + +// 创建订单 +type GourmetCreateOrderReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Order []*Cooking `protobuf:"bytes,1,rep,name=order,proto3" json:"order"` // 烹饪时间不用传 后端会重新计算 +} + +func (x *GourmetCreateOrderReq) Reset() { + *x = GourmetCreateOrderReq{} + if protoimpl.UnsafeEnabled { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GourmetCreateOrderReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GourmetCreateOrderReq) ProtoMessage() {} + +func (x *GourmetCreateOrderReq) ProtoReflect() protoreflect.Message { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GourmetCreateOrderReq.ProtoReflect.Descriptor instead. +func (*GourmetCreateOrderReq) Descriptor() ([]byte, []int) { + return file_gourmet_gourmet_msg_proto_rawDescGZIP(), []int{2} +} + +func (x *GourmetCreateOrderReq) GetOrder() []*Cooking { + if x != nil { + return x.Order + } + return nil +} + +type GourmetCreateOrderResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Data *DBGourmet `protobuf:"bytes,1,opt,name=data,proto3" json:"data"` +} + +func (x *GourmetCreateOrderResp) Reset() { + *x = GourmetCreateOrderResp{} + if protoimpl.UnsafeEnabled { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GourmetCreateOrderResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GourmetCreateOrderResp) ProtoMessage() {} + +func (x *GourmetCreateOrderResp) ProtoReflect() protoreflect.Message { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GourmetCreateOrderResp.ProtoReflect.Descriptor instead. +func (*GourmetCreateOrderResp) Descriptor() ([]byte, []int) { + return file_gourmet_gourmet_msg_proto_rawDescGZIP(), []int{3} +} + +func (x *GourmetCreateOrderResp) GetData() *DBGourmet { + if x != nil { + return x.Data + } + return nil +} + +// 领取奖励 +type GourmetGetRewardReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *GourmetGetRewardReq) Reset() { + *x = GourmetGetRewardReq{} + if protoimpl.UnsafeEnabled { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GourmetGetRewardReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GourmetGetRewardReq) ProtoMessage() {} + +func (x *GourmetGetRewardReq) ProtoReflect() protoreflect.Message { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GourmetGetRewardReq.ProtoReflect.Descriptor instead. +func (*GourmetGetRewardReq) Descriptor() ([]byte, []int) { + return file_gourmet_gourmet_msg_proto_rawDescGZIP(), []int{4} +} + +type GourmetGetRewardResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Data *DBGourmet `protobuf:"bytes,1,opt,name=data,proto3" json:"data"` +} + +func (x *GourmetGetRewardResp) Reset() { + *x = GourmetGetRewardResp{} + if protoimpl.UnsafeEnabled { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GourmetGetRewardResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GourmetGetRewardResp) ProtoMessage() {} + +func (x *GourmetGetRewardResp) ProtoReflect() protoreflect.Message { + mi := &file_gourmet_gourmet_msg_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GourmetGetRewardResp.ProtoReflect.Descriptor instead. +func (*GourmetGetRewardResp) Descriptor() ([]byte, []int) { + return file_gourmet_gourmet_msg_proto_rawDescGZIP(), []int{5} +} + +func (x *GourmetGetRewardResp) GetData() *DBGourmet { + if x != nil { + return x.Data + } + return nil +} + +var File_gourmet_gourmet_msg_proto protoreflect.FileDescriptor + +var file_gourmet_gourmet_msg_proto_rawDesc = []byte{ + 0x0a, 0x19, 0x67, 0x6f, 0x75, 0x72, 0x6d, 0x65, 0x74, 0x2f, 0x67, 0x6f, 0x75, 0x72, 0x6d, 0x65, + 0x74, 0x5f, 0x6d, 0x73, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x67, 0x6f, 0x75, + 0x72, 0x6d, 0x65, 0x74, 0x2f, 0x67, 0x6f, 0x75, 0x72, 0x6d, 0x65, 0x74, 0x5f, 0x64, 0x62, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x13, 0x0a, 0x11, 0x47, 0x6f, 0x75, 0x72, 0x6d, 0x65, 0x74, + 0x47, 0x65, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x22, 0x34, 0x0a, 0x12, 0x47, 0x6f, + 0x75, 0x72, 0x6d, 0x65, 0x74, 0x47, 0x65, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x12, 0x1e, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, + 0x2e, 0x44, 0x42, 0x47, 0x6f, 0x75, 0x72, 0x6d, 0x65, 0x74, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, + 0x22, 0x37, 0x0a, 0x15, 0x47, 0x6f, 0x75, 0x72, 0x6d, 0x65, 0x74, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x12, 0x1e, 0x0a, 0x05, 0x6f, 0x72, 0x64, + 0x65, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x08, 0x2e, 0x43, 0x6f, 0x6f, 0x6b, 0x69, + 0x6e, 0x67, 0x52, 0x05, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x22, 0x38, 0x0a, 0x16, 0x47, 0x6f, 0x75, + 0x72, 0x6d, 0x65, 0x74, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, + 0x65, 0x73, 0x70, 0x12, 0x1e, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x0a, 0x2e, 0x44, 0x42, 0x47, 0x6f, 0x75, 0x72, 0x6d, 0x65, 0x74, 0x52, 0x04, 0x64, + 0x61, 0x74, 0x61, 0x22, 0x15, 0x0a, 0x13, 0x47, 0x6f, 0x75, 0x72, 0x6d, 0x65, 0x74, 0x47, 0x65, + 0x74, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x22, 0x36, 0x0a, 0x14, 0x47, 0x6f, + 0x75, 0x72, 0x6d, 0x65, 0x74, 0x47, 0x65, 0x74, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x52, 0x65, + 0x73, 0x70, 0x12, 0x1e, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x0a, 0x2e, 0x44, 0x42, 0x47, 0x6f, 0x75, 0x72, 0x6d, 0x65, 0x74, 0x52, 0x04, 0x64, 0x61, + 0x74, 0x61, 0x42, 0x06, 0x5a, 0x04, 0x2e, 0x3b, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x33, +} + +var ( + file_gourmet_gourmet_msg_proto_rawDescOnce sync.Once + file_gourmet_gourmet_msg_proto_rawDescData = file_gourmet_gourmet_msg_proto_rawDesc +) + +func file_gourmet_gourmet_msg_proto_rawDescGZIP() []byte { + file_gourmet_gourmet_msg_proto_rawDescOnce.Do(func() { + file_gourmet_gourmet_msg_proto_rawDescData = protoimpl.X.CompressGZIP(file_gourmet_gourmet_msg_proto_rawDescData) + }) + return file_gourmet_gourmet_msg_proto_rawDescData +} + +var file_gourmet_gourmet_msg_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_gourmet_gourmet_msg_proto_goTypes = []interface{}{ + (*GourmetGetListReq)(nil), // 0: GourmetGetListReq + (*GourmetGetListResp)(nil), // 1: GourmetGetListResp + (*GourmetCreateOrderReq)(nil), // 2: GourmetCreateOrderReq + (*GourmetCreateOrderResp)(nil), // 3: GourmetCreateOrderResp + (*GourmetGetRewardReq)(nil), // 4: GourmetGetRewardReq + (*GourmetGetRewardResp)(nil), // 5: GourmetGetRewardResp + (*DBGourmet)(nil), // 6: DBGourmet + (*Cooking)(nil), // 7: Cooking +} +var file_gourmet_gourmet_msg_proto_depIdxs = []int32{ + 6, // 0: GourmetGetListResp.data:type_name -> DBGourmet + 7, // 1: GourmetCreateOrderReq.order:type_name -> Cooking + 6, // 2: GourmetCreateOrderResp.data:type_name -> DBGourmet + 6, // 3: GourmetGetRewardResp.data:type_name -> DBGourmet + 4, // [4:4] is the sub-list for method output_type + 4, // [4:4] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name +} + +func init() { file_gourmet_gourmet_msg_proto_init() } +func file_gourmet_gourmet_msg_proto_init() { + if File_gourmet_gourmet_msg_proto != nil { + return + } + file_gourmet_gourmet_db_proto_init() + if !protoimpl.UnsafeEnabled { + file_gourmet_gourmet_msg_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GourmetGetListReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gourmet_gourmet_msg_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GourmetGetListResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gourmet_gourmet_msg_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GourmetCreateOrderReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gourmet_gourmet_msg_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GourmetCreateOrderResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gourmet_gourmet_msg_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GourmetGetRewardReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gourmet_gourmet_msg_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GourmetGetRewardResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_gourmet_gourmet_msg_proto_rawDesc, + NumEnums: 0, + NumMessages: 6, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_gourmet_gourmet_msg_proto_goTypes, + DependencyIndexes: file_gourmet_gourmet_msg_proto_depIdxs, + MessageInfos: file_gourmet_gourmet_msg_proto_msgTypes, + }.Build() + File_gourmet_gourmet_msg_proto = out.File + file_gourmet_gourmet_msg_proto_rawDesc = nil + file_gourmet_gourmet_msg_proto_goTypes = nil + file_gourmet_gourmet_msg_proto_depIdxs = nil +} diff --git a/sys/configure/structs/game.Gourmet.go b/sys/configure/structs/game.Gourmet.go new file mode 100644 index 000000000..8a0f33fd6 --- /dev/null +++ b/sys/configure/structs/game.Gourmet.go @@ -0,0 +1,42 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +package cfg + +type GameGourmet struct { + _dataMap map[int32]*GameGourmetData + _dataList []*GameGourmetData +} + +func NewGameGourmet(_buf []map[string]interface{}) (*GameGourmet, error) { + _dataList := make([]*GameGourmetData, 0, len(_buf)) + dataMap := make(map[int32]*GameGourmetData) + for _, _ele_ := range _buf { + if _v, err2 := DeserializeGameGourmetData(_ele_); err2 != nil { + return nil, err2 + } else { + _dataList = append(_dataList, _v) + dataMap[_v.Id] = _v + } + } + return &GameGourmet{_dataList:_dataList, _dataMap:dataMap}, nil +} + +func (table *GameGourmet) GetDataMap() map[int32]*GameGourmetData { + return table._dataMap +} + +func (table *GameGourmet) GetDataList() []*GameGourmetData { + return table._dataList +} + +func (table *GameGourmet) Get(key int32) *GameGourmetData { + return table._dataMap[key] +} + + diff --git a/sys/configure/structs/game.GourmetData.go b/sys/configure/structs/game.GourmetData.go new file mode 100644 index 000000000..d80a51008 --- /dev/null +++ b/sys/configure/structs/game.GourmetData.go @@ -0,0 +1,66 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +package cfg + +import "errors" + +type GameGourmetData struct { + Id int32 + Type int32 + Level int32 + Levelname string + Colour int32 + Name string + Picture string + Consume []*Gameatn + Using int32 + Propsgroup int32 +} + +const TypeId_GameGourmetData = -359286171 + +func (*GameGourmetData) GetTypeId() int32 { + return -359286171 +} + +func (_v *GameGourmetData)Deserialize(_buf map[string]interface{}) (err error) { + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["id"].(float64); !_ok_ { err = errors.New("id error"); return }; _v.Id = int32(_tempNum_) } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["type"].(float64); !_ok_ { err = errors.New("type error"); return }; _v.Type = int32(_tempNum_) } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["level"].(float64); !_ok_ { err = errors.New("level error"); return }; _v.Level = int32(_tempNum_) } + {var _ok_ bool; var __json_text__ map[string]interface{}; if __json_text__, _ok_ = _buf["levelname"].(map[string]interface{}) ; !_ok_ { err = errors.New("_v.Levelname error"); return }; { var _ok_ bool; if _, _ok_ = __json_text__["key"].(string); !_ok_ { err = errors.New("key error"); return } }; { var _ok_ bool; if _v.Levelname, _ok_ = __json_text__["text"].(string); !_ok_ { err = errors.New("text error"); return } } } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["colour"].(float64); !_ok_ { err = errors.New("colour error"); return }; _v.Colour = int32(_tempNum_) } + {var _ok_ bool; var __json_text__ map[string]interface{}; if __json_text__, _ok_ = _buf["name"].(map[string]interface{}) ; !_ok_ { err = errors.New("_v.Name error"); return }; { var _ok_ bool; if _, _ok_ = __json_text__["key"].(string); !_ok_ { err = errors.New("key error"); return } }; { var _ok_ bool; if _v.Name, _ok_ = __json_text__["text"].(string); !_ok_ { err = errors.New("text error"); return } } } + { var _ok_ bool; if _v.Picture, _ok_ = _buf["picture"].(string); !_ok_ { err = errors.New("picture error"); return } } + { + var _arr_ []interface{} + var _ok_ bool + if _arr_, _ok_ = _buf["consume"].([]interface{}); !_ok_ { err = errors.New("consume error"); return } + + _v.Consume = make([]*Gameatn, 0, len(_arr_)) + + for _, _e_ := range _arr_ { + var _list_v_ *Gameatn + { var _ok_ bool; var _x_ map[string]interface{}; if _x_, _ok_ = _e_.(map[string]interface{}); !_ok_ { err = errors.New("_list_v_ error"); return }; if _list_v_, err = DeserializeGameatn(_x_); err != nil { return } } + _v.Consume = append(_v.Consume, _list_v_) + } + } + + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["using"].(float64); !_ok_ { err = errors.New("using error"); return }; _v.Using = int32(_tempNum_) } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["propsgroup"].(float64); !_ok_ { err = errors.New("propsgroup error"); return }; _v.Propsgroup = int32(_tempNum_) } + return +} + +func DeserializeGameGourmetData(_buf map[string]interface{}) (*GameGourmetData, error) { + v := &GameGourmetData{} + if err := v.Deserialize(_buf); err == nil { + return v, nil + } else { + return nil, err + } +} diff --git a/sys/configure/structs/game.GourmetSkill.go b/sys/configure/structs/game.GourmetSkill.go new file mode 100644 index 000000000..36104b464 --- /dev/null +++ b/sys/configure/structs/game.GourmetSkill.go @@ -0,0 +1,42 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +package cfg + +type GameGourmetSkill struct { + _dataMap map[int32]*GameGourmetSkillData + _dataList []*GameGourmetSkillData +} + +func NewGameGourmetSkill(_buf []map[string]interface{}) (*GameGourmetSkill, error) { + _dataList := make([]*GameGourmetSkillData, 0, len(_buf)) + dataMap := make(map[int32]*GameGourmetSkillData) + for _, _ele_ := range _buf { + if _v, err2 := DeserializeGameGourmetSkillData(_ele_); err2 != nil { + return nil, err2 + } else { + _dataList = append(_dataList, _v) + dataMap[_v.Id] = _v + } + } + return &GameGourmetSkill{_dataList:_dataList, _dataMap:dataMap}, nil +} + +func (table *GameGourmetSkill) GetDataMap() map[int32]*GameGourmetSkillData { + return table._dataMap +} + +func (table *GameGourmetSkill) GetDataList() []*GameGourmetSkillData { + return table._dataList +} + +func (table *GameGourmetSkill) Get(key int32) *GameGourmetSkillData { + return table._dataMap[key] +} + + diff --git a/sys/configure/structs/game.GourmetSkillData.go b/sys/configure/structs/game.GourmetSkillData.go new file mode 100644 index 000000000..17f49eec8 --- /dev/null +++ b/sys/configure/structs/game.GourmetSkillData.go @@ -0,0 +1,89 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +package cfg + +import "errors" + +type GameGourmetSkillData struct { + Id int32 + Type int32 + Initial int32 + Level int32 + Levelname string + Colour int32 + Name string + Needtime int32 + Display int32 + Probability int32 + Icon string + Item []*Gameatn + Affix string + AffixColour int32 + Consume []*Gameatn +} + +const TypeId_GameGourmetSkillData = 235491264 + +func (*GameGourmetSkillData) GetTypeId() int32 { + return 235491264 +} + +func (_v *GameGourmetSkillData)Deserialize(_buf map[string]interface{}) (err error) { + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["id"].(float64); !_ok_ { err = errors.New("id error"); return }; _v.Id = int32(_tempNum_) } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["type"].(float64); !_ok_ { err = errors.New("type error"); return }; _v.Type = int32(_tempNum_) } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["initial"].(float64); !_ok_ { err = errors.New("initial error"); return }; _v.Initial = int32(_tempNum_) } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["level"].(float64); !_ok_ { err = errors.New("level error"); return }; _v.Level = int32(_tempNum_) } + {var _ok_ bool; var __json_text__ map[string]interface{}; if __json_text__, _ok_ = _buf["levelname"].(map[string]interface{}) ; !_ok_ { err = errors.New("_v.Levelname error"); return }; { var _ok_ bool; if _, _ok_ = __json_text__["key"].(string); !_ok_ { err = errors.New("key error"); return } }; { var _ok_ bool; if _v.Levelname, _ok_ = __json_text__["text"].(string); !_ok_ { err = errors.New("text error"); return } } } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["colour"].(float64); !_ok_ { err = errors.New("colour error"); return }; _v.Colour = int32(_tempNum_) } + {var _ok_ bool; var __json_text__ map[string]interface{}; if __json_text__, _ok_ = _buf["name"].(map[string]interface{}) ; !_ok_ { err = errors.New("_v.Name error"); return }; { var _ok_ bool; if _, _ok_ = __json_text__["key"].(string); !_ok_ { err = errors.New("key error"); return } }; { var _ok_ bool; if _v.Name, _ok_ = __json_text__["text"].(string); !_ok_ { err = errors.New("text error"); return } } } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["needtime"].(float64); !_ok_ { err = errors.New("needtime error"); return }; _v.Needtime = int32(_tempNum_) } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["display"].(float64); !_ok_ { err = errors.New("display error"); return }; _v.Display = int32(_tempNum_) } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["probability"].(float64); !_ok_ { err = errors.New("probability error"); return }; _v.Probability = int32(_tempNum_) } + { var _ok_ bool; if _v.Icon, _ok_ = _buf["icon"].(string); !_ok_ { err = errors.New("icon error"); return } } + { + var _arr_ []interface{} + var _ok_ bool + if _arr_, _ok_ = _buf["item"].([]interface{}); !_ok_ { err = errors.New("item error"); return } + + _v.Item = make([]*Gameatn, 0, len(_arr_)) + + for _, _e_ := range _arr_ { + var _list_v_ *Gameatn + { var _ok_ bool; var _x_ map[string]interface{}; if _x_, _ok_ = _e_.(map[string]interface{}); !_ok_ { err = errors.New("_list_v_ error"); return }; if _list_v_, err = DeserializeGameatn(_x_); err != nil { return } } + _v.Item = append(_v.Item, _list_v_) + } + } + + {var _ok_ bool; var __json_text__ map[string]interface{}; if __json_text__, _ok_ = _buf["affix"].(map[string]interface{}) ; !_ok_ { err = errors.New("_v.Affix error"); return }; { var _ok_ bool; if _, _ok_ = __json_text__["key"].(string); !_ok_ { err = errors.New("key error"); return } }; { var _ok_ bool; if _v.Affix, _ok_ = __json_text__["text"].(string); !_ok_ { err = errors.New("text error"); return } } } + { var _ok_ bool; var _tempNum_ float64; if _tempNum_, _ok_ = _buf["affix_colour"].(float64); !_ok_ { err = errors.New("affix_colour error"); return }; _v.AffixColour = int32(_tempNum_) } + { + var _arr_ []interface{} + var _ok_ bool + if _arr_, _ok_ = _buf["consume"].([]interface{}); !_ok_ { err = errors.New("consume error"); return } + + _v.Consume = make([]*Gameatn, 0, len(_arr_)) + + for _, _e_ := range _arr_ { + var _list_v_ *Gameatn + { var _ok_ bool; var _x_ map[string]interface{}; if _x_, _ok_ = _e_.(map[string]interface{}); !_ok_ { err = errors.New("_list_v_ error"); return }; if _list_v_, err = DeserializeGameatn(_x_); err != nil { return } } + _v.Consume = append(_v.Consume, _list_v_) + } + } + + return +} + +func DeserializeGameGourmetSkillData(_buf map[string]interface{}) (*GameGourmetSkillData, error) { + v := &GameGourmetSkillData{} + if err := v.Deserialize(_buf); err == nil { + return v, nil + } else { + return nil, err + } +}