增加GM

This reverts commit e9b22196a3.

.gitignore

@@ -10,3 +10,5 @@ src/server/log/
 src/server/*.exe
 src/server/gamedata/config/*.json
 src/server/unit_test.go
+src/server/teLog/*
+src/server/teLog/log.2024-11-28

src/server/GoUtil/AliyunOpenApi.go

@@ -0,0 +1,125 @@
+// This file is auto-generated, don't edit it. Thanks.
+package GoUtil
+
+import (
+	"fmt"
+
+	sdk "github.com/alibabacloud-go/cloudauth-20190307/v4/client"
+	openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
+	console "github.com/alibabacloud-go/tea-console/client"
+	util "github.com/alibabacloud-go/tea-utils/v2/service"
+	"github.com/alibabacloud-go/tea/tea"
+	credential "github.com/aliyun/credentials-go/credentials"
+)
+
+const (
+	ACCESS_KEY_ID     = "LTAI5t8DKMexEjcBH1cCmrp9"
+	ACCESS_KEY_SECRET = "p0KqKvTarTRXBXcBbUvfqSO9bynrCD"
+)
+
+type ClientInterface interface {
+}
+
+func IdVerify(UserName, Num string) (_err error) {
+	// 构建request。
+	request := &sdk.Id2MetaVerifyRequest{}
+	request.ParamType = tea.String("normal")
+	request.UserName = tea.String(UserName)
+	request.IdentifyNum = tea.String(Num)
+	// 自动路由服务。
+	response, _err := Id2MetaVerifyAutoRoute(request)
+	ret := util.ToJSONString(util.ToMap(response))
+	if _err != nil {
+		console.Log(tea.String("最终结果（若此处为空，则所有服务点均异常，请逐步调试）：" + tea.StringValue(ret)))
+	}
+	return _err
+}
+
+// Description:
+//
+// 主备服务点循环调用，获取到成功结果返回。
+func Id2MetaVerifyAutoRoute(request *sdk.Id2MetaVerifyRequest) (_result *sdk.Id2MetaVerifyResponse, err error) {
+	endpoints := []*string{tea.String("cloudauth.cn-shanghai.aliyuncs.com"), tea.String("cloudauth.cn-beijing.aliyuncs.com")}
+	var lastResponse *sdk.Id2MetaVerifyResponse
+	for _, endpoint := range endpoints {
+		func() (_r *sdk.Id2MetaVerifyResponse, _e error) {
+			defer func() {
+				if r := tea.Recover(recover()); r != nil {
+					_e = r
+				}
+			}()
+			// 调用服务。
+			response, _e := Id2MetaVerify(endpoint, request)
+			if _e != nil {
+				console.Error(tea.String("节点 " + tea.StringValue(endpoint) + " 调用失败，错误信息：" + _e.Error()))
+				return // 如果调用失败，继续下一个服务点。
+			}
+			// 节点调用结果
+			//ret := util.ToJSONString(util.ToMap(response))
+			//console.Log(tea.String("节点 " + tea.StringValue(endpoint) + " 结果：" + tea.StringValue(ret) + " "))
+			// 有一个服务调用成功即返回。
+			lastResponse = response
+			if !tea.BoolValue(util.IsUnset(response)) && tea.BoolValue(util.EqualNumber(tea.ToInt(response.StatusCode), tea.Int(200))) {
+				if !tea.BoolValue(util.IsUnset(response.Body)) && tea.BoolValue(util.EqualString(response.Body.Code, tea.String("200"))) {
+					return response, nil
+				}
+			}
+
+			return nil, fmt.Errorf("节点 %s 调用失败，错误码：%s，错误信息：%s", tea.StringValue(endpoint), tea.StringValue(response.Body.Code), tea.StringValue(response.Body.Message))
+		}()
+	}
+	_result = lastResponse
+	if lastResponse == nil {
+		return nil, fmt.Errorf("所有服务点调用失败，请检查网络或服务状态,或联系服务提供商")
+	}
+	if !tea.BoolValue(util.EqualString(lastResponse.Body.Code, tea.String("200"))) {
+		return nil, fmt.Errorf("所有服务点调用失败，错误码：%s，错误信息：%s", tea.StringValue(lastResponse.Body.Code), tea.StringValue(lastResponse.Body.Message))
+	}
+	if !tea.BoolValue(util.EqualString(lastResponse.Body.ResultObject.BizCode, tea.String("1"))) {
+		return nil, fmt.Errorf("校验失败，返回码：%s;", tea.StringValue(lastResponse.Body.ResultObject.BizCode))
+	}
+	return _result, nil
+}
+
+// Description:
+//
+// 获取服务Client实例，调用验证方法。
+func Id2MetaVerify(endpoint *string, request *sdk.Id2MetaVerifyRequest) (_result *sdk.Id2MetaVerifyResponse, _err error) {
+	// 获取SDK Client实例。
+	client := CreateClient(endpoint)
+	// 构建RuntimeObject
+	runtime := &util.RuntimeOptions{}
+	runtime.ReadTimeout = tea.Int(5000)
+	runtime.ConnectTimeout = tea.Int(5000)
+	// 连接
+	_result = &sdk.Id2MetaVerifyResponse{}
+	_body, _err := client.Id2MetaVerifyWithOptions(request, runtime)
+	if _err != nil {
+		return
+	}
+	_result = _body
+	return
+}
+
+// Description:
+//
+// 安全创建服务Client实例。
+func CreateClient(endpoint *string) (_result *sdk.Client) {
+	// 获取Credential工具，此工具会从环境变量中读取AccessKey。
+	credentialConfig := &credential.Config{
+		Type:            tea.String("access_key"),
+		AccessKeyId:     tea.String(ACCESS_KEY_ID),
+		AccessKeySecret: tea.String(ACCESS_KEY_SECRET),
+	}
+	credential, _err := credential.NewCredential(credentialConfig)
+	if _err != nil {
+		return _result
+	}
+	// 创建SDK Client实例。
+	apiConfig := &openapi.Config{}
+	apiConfig.Credential = credential
+	apiConfig.Endpoint = endpoint
+	_result = &sdk.Client{}
+	_result, _ = sdk.NewClient(apiConfig)
+	return _result
+}

src/server/GoUtil/AliyunSmsApi.go

@@ -0,0 +1,68 @@
+// This file is auto-generated, don't edit it. Thanks.
+package GoUtil
+
+import (
+	"fmt"
+	"server/pkg/github.com/name5566/leaf/log"
+
+	openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
+	dysmsapi20170525 "github.com/alibabacloud-go/dysmsapi-20170525/v5/client"
+	console "github.com/alibabacloud-go/tea-console/client"
+	util "github.com/alibabacloud-go/tea-utils/v2/service"
+	"github.com/alibabacloud-go/tea/tea"
+	credential "github.com/aliyun/credentials-go/credentials"
+)
+
+const (
+	SIGN_NAME     = "蹊径厦门科技"
+	TEMPLATE_CODE = "SMS_321046476"
+)
+
+// Description:
+//
+// 使用凭据初始化账号Client
+//
+// @return Client
+//
+// @throws Exception
+func CreateSmsClient() (_result *dysmsapi20170525.Client, _err error) {
+	// 工程代码建议使用更安全的无AK方式，凭据配置方式请参见：https://help.aliyun.com/document_detail/378661.html。
+	credential, _err := credential.NewCredential(&credential.Config{
+		Type:            tea.String("access_key"),
+		AccessKeyId:     tea.String(ACCESS_KEY_ID),
+		AccessKeySecret: tea.String(ACCESS_KEY_SECRET),
+	})
+	if _err != nil {
+		return _result, _err
+	}
+
+	config := &openapi.Config{
+		Credential: credential,
+	}
+	// Endpoint 请参考 https://api.aliyun.com/product/Dysmsapi
+	config.Endpoint = tea.String("dysmsapi.aliyuncs.com")
+	_result = &dysmsapi20170525.Client{}
+	_result, _err = dysmsapi20170525.NewClient(config)
+	return _result, _err
+}
+
+func SmsCode(Phone, Code string) (_err error) {
+	client, _err := CreateSmsClient()
+	if _err != nil {
+		return _err
+	}
+	console.Log(tea.String("生成的验证码：" + Code))
+	sendSmsRequest := &dysmsapi20170525.SendSmsRequest{
+		PhoneNumbers:  tea.String(Phone),
+		SignName:      tea.String(SIGN_NAME),
+		TemplateCode:  tea.String(TEMPLATE_CODE),
+		TemplateParam: tea.String(fmt.Sprintf("{\"code\":\"%s\"}", Code)),
+	}
+	runtime := &util.RuntimeOptions{}
+	resp, _err := client.SendSmsWithOptions(sendSmsRequest, runtime)
+	log.Debug("SendSmsWithOptions resp: %v", resp)
+	if _err != nil {
+		return _err
+	}
+	return nil
+}

src/server/GoUtil/GoUtil.go

@@ -2,10 +2,18 @@ package GoUtil
 
 import (
 	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/md5"
+	crand "crypto/rand"
+	"encoding/base64"
 	"encoding/gob"
+	"fmt"
+	"io"
 	"math/rand"
 	"reflect"
 	"strconv"
+	"strings"
 	"time"
 )
 
@@ -17,6 +25,61 @@ type EventObj struct {
 	Obj      interface{}
 }
 
+const (
+	SECRET_KEY   = ")VQbB(vpy=U(wcp)"
+	CONDITION_EQ = "="  // 等于
+	CONDITION_GT = ">"  // 大于
+	CONDITION_LT = "<"  // 小于
+	CONDITION_GE = ">=" // 大于等于
+	CONDITION_LE = "<=" // 小于等于
+
+	LETTER = "GhCvgqSNTUMVeRfwakiYmcxWKtJQpZrDIBXnPyLsAFdzjHbulE"
+)
+
+// 加密字符串
+func Encrypt(plainText string) (string, error) {
+	block, err := aes.NewCipher([]byte(SECRET_KEY))
+	if err != nil {
+		return "", err
+	}
+
+	cipherText := make([]byte, aes.BlockSize+len(plainText))
+	iv := cipherText[:aes.BlockSize]
+	if _, err := io.ReadFull(crand.Reader, iv); err != nil {
+		return "", err
+	}
+
+	stream := cipher.NewCFBEncrypter(block, iv)
+	stream.XORKeyStream(cipherText[aes.BlockSize:], []byte(plainText))
+
+	return base64.URLEncoding.EncodeToString(cipherText), nil
+}
+
+// 解密字符串
+func Decrypt(cipherText string) (string, error) {
+	cipherTextBytes, err := base64.URLEncoding.DecodeString(cipherText)
+	if err != nil {
+		return "", err
+	}
+
+	block, err := aes.NewCipher([]byte(SECRET_KEY))
+	if err != nil {
+		return "", err
+	}
+
+	if len(cipherTextBytes) < aes.BlockSize {
+		return "", fmt.Errorf("cipherText too short")
+	}
+
+	iv := cipherTextBytes[:aes.BlockSize]
+	cipherTextBytes = cipherTextBytes[aes.BlockSize:]
+
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(cipherTextBytes, cipherTextBytes)
+
+	return string(cipherTextBytes), nil
+}
+
 func (o *EventObj) isEqual(tar *EventObj) bool {
 	if reflect.ValueOf(o.Callback).Pointer() == reflect.ValueOf(tar.Callback).Pointer() && o.Obj == tar.Obj {
 		return true
@@ -68,9 +131,6 @@ func RemoveEvent(name string, callback func([]interface{}), Obj interface{}) {
 		}
 	}
 	eventByName[name] = list[:j]
-	// fmt.Println("len eventByName[name]:", len(eventByName[name]))
-	//fmt.Println("len eventByName[name]:", len(eventByName))
-	// fmt.Println("len list:", len(list))
 }
 
 func DeleteEleByValue(list []int, ele int) []int {
@@ -139,6 +199,25 @@ func Int(a interface{}) int {
 	return 0
 }
 
+func String(a interface{}) string {
+	if a == nil {
+		return ""
+	}
+	switch v := a.(type) {
+	case int:
+		return strconv.Itoa(v)
+	case int32:
+		return strconv.Itoa(int(v))
+	case int64:
+		return strconv.Itoa(int(v))
+	case float64:
+		return strconv.FormatFloat(v, 'f', -1, 64)
+	case string:
+		return v
+	}
+	return ""
+}
+
 func GobMarshal(data interface{}) ([]byte, error) {
 	var buf bytes.Buffer
 	encode := gob.NewEncoder(&buf)
@@ -159,7 +238,7 @@ func GobUnmarshal(data []byte, obj interface{}) error {
 }
 
 func GetServerIdByUid(uid int) int {
-	return int(uid / 100000)
+	return int((uid % 100000000) / 100000)
 }
 
 func CreateOrderSn(uid int) string {
@@ -177,3 +256,276 @@ func RandString(n int) string {
 	}
 	return string(b)
 }
+
+// 生成索要卡牌唯一id
+func CreateCardId(From, To, CardId int) string {
+	return fmt.Sprintf("%d_%d_%d_%d_%s", From, To, CardId, Now(), RandString(3))
+}
+
+func SplitInt(str, sep string) []int {
+	var ret []int
+	for _, v := range strings.Split(str, sep) {
+		ret = append(ret, Int(v))
+	}
+	return ret
+}
+
+func Compare(x int, condition string, y int) bool {
+	switch condition {
+	case CONDITION_EQ:
+		return x == y
+	case CONDITION_GT:
+		return x > y
+	case CONDITION_LT:
+		return x < y
+	case CONDITION_GE:
+		return x >= y
+	case CONDITION_LE:
+		return x <= y
+	default:
+		return false
+	}
+}
+
+func UniKey(seed string) string {
+	hash := md5.New()
+	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+	io.WriteString(hash, seed+timestamp)
+	return fmt.Sprintf("%x", hash.Sum(nil))
+}
+
+func GetUserKey(Uid int64) string {
+	return fmt.Sprintf("user_data_%d", Uid)
+}
+
+func GetCatnipLockKey(Uid, GameId int) string {
+	return fmt.Sprintf("catnip_lock_%d_%d", Uid, GameId)
+}
+
+func Rand6DigitNumber() string {
+	n := rand.Intn(1000000)
+	return fmt.Sprintf("%06d", n)
+}
+
+func UniqueInts(input []int) []int {
+	seen := make(map[int]struct{})
+	result := make([]int, 0, len(input))
+	for _, v := range input {
+		if _, ok := seen[v]; !ok {
+			seen[v] = struct{}{}
+			result = append(result, v)
+		}
+	}
+	return result
+}
+
+/*
+#codebase: GoUtil
+修改函数UniqueStringFromInt
+
+功能说明：
+将整数转换为包含字母和数字的唯一字符串
+
+算法步骤：
+1. 将输入整数格式化为5位数字符串（不足前补0）
+2. 分割字符串：前2位、中2位、最后1位
+3. 将各段转为整数，作为字母表索引
+4. 从预定义字母表中选择对应字符
+5. 随机生成2个数字字符
+6. 随机插入数字字符到字母串中
+7. 返回最终唯一标识字符串
+*/
+
+func UniqueStringFromInt(n int) string {
+	n = n % 100000 // 确保n在0-99999范围内
+	str := fmt.Sprintf("%05d", n)
+	a1 := str[0:2]
+	a2 := str[2:4]
+	a3 := str[4:5]
+
+	s1, _ := strconv.Atoi(a1)
+	s2, _ := strconv.Atoi(a2)
+	s3, _ := strconv.Atoi(a3)
+
+	// 修改索引计算逻辑
+	var letter1, letter2 string
+	if s1 >= len(LETTER) {
+		letter1 = string(LETTER[s1%len(LETTER)]) + strconv.Itoa(s1/len(LETTER))
+	} else {
+		letter1 = string(LETTER[s1])
+	}
+
+	if s2 >= len(LETTER) {
+		idx := (s2) % len(LETTER)
+		letter2 = string(LETTER[idx]) + strconv.Itoa(s2/len(LETTER))
+	} else {
+		letter2 = string(LETTER[s2])
+	}
+
+	letter3 := string(LETTER[s3+20])
+	letter := fmt.Sprintf("%s%s%s", letter1, letter2, letter3)
+	lastLetter := 5 - len(letter)
+	indices := rand.Perm(8)[:2]
+	chars := []byte{byte('2' + indices[0]), byte('2' + indices[1])}
+	if lastLetter > 0 {
+		for i := 0; i < lastLetter; i++ {
+			insertPos1 := rand.Intn(len(letter) + 1)
+			letter = letter[:insertPos1] + string(chars[0]) + letter[insertPos1:]
+		}
+	}
+	pos := rand.Intn(len(LETTER))
+	letter += string(LETTER[pos])
+	return fmt.Sprintf("%s-%s", letter[:3], letter[3:])
+}
+
+// 反解析 UniqueStringFromInt 生成的字符串，返回原始整数（0-99999），失败返回 -1
+func ParseUniqueStringToInt(s string) int {
+	arr := strings.Split(s, "-")
+	// 去除字符串中大于1的数字
+	s1 := arr[2] + arr[3]
+	s1 = s1[:len(s1)-1] // 去掉最后一个字符
+	s2 := ""
+	for _, ch := range s1 {
+		if ch < '2' || ch > '9' {
+			s2 += string(ch)
+		}
+	}
+	index1 := 0
+	s3 := ""
+	for i := 0; i < len(s2); i++ {
+		index := strings.Index(LETTER, string(s2[i]))
+
+		if i < len(s2)-1 && s2[i+1] == '1' {
+			index += len(LETTER)
+			i++
+		}
+		index1++
+		if i == len(s2)-1 {
+			index -= 20 // 最后一位是字母，减去20
+			s3 += fmt.Sprintf("%d", index)
+		} else {
+			s3 += fmt.Sprintf("%02d", index)
+		}
+
+	}
+	return Int(s3)
+}
+
+func GenerateShuffledAlphabet() string {
+	// 包含所有大小写字母的字符串
+	alphabet := "abcdefghijklmnpqrstuvwxyzABCDEFGHIJKLMNPQRSTUVWXYZ"
+
+	// 转换为字节切片以便打乱
+	bytes := []byte(alphabet)
+
+	// 使用当前时间作为随机种子
+	rand.Seed(time.Now().UnixNano())
+
+	// Fisher-Yates 洗牌算法
+	for i := len(bytes) - 1; i > 0; i-- {
+		j := rand.Intn(i + 1)
+		bytes[i], bytes[j] = bytes[j], bytes[i]
+	}
+
+	return string(bytes)
+}
+
+// 根据IP获取国家名称
+func GetCountryByIP(ip string) (string, error) {
+	return "", nil
+	// resp, err := http.Get("https://ipapi.co/" + ip + "/country_name/")
+	// if err != nil {
+	// 	return "", err
+	// }
+	// defer resp.Body.Close()
+	// buf := new(bytes.Buffer)
+	// buf.ReadFrom(resp.Body)
+	// return strings.TrimSpace(buf.String()), nil
+}
+
+// 根据国家名称获取ISO 3166-1国家码
+func GetISOCodeByCountry(country string) (string, error) {
+	// 简单映射，可以扩展为更完整的映射表
+	countryMap := map[string]string{
+		"Afghanistan":            "004", // 阿富汗
+		"Albania":                "008", // 阿尔巴尼亚
+		"Algeria":                "012", // 阿尔及利亚
+		"Angola":                 "024", // 安哥拉
+		"Argentina":              "032", // 阿根廷
+		"Austria":                "040", // 奥地利
+		"Azerbaijan":             "031", // 阿塞拜疆
+		"Bahrain":                "048", // 巴林
+		"Bangladesh":             "050", // 孟加拉国
+		"Belgium":                "056", // 比利时
+		"Bolivia":                "068", // 玻利维亚
+		"Bosnia and Herzegovina": "070", // 波斯尼亚和黑塞哥维那
+		"Brazil":                 "076", // 巴西
+		"Bulgaria":               "100", // 保加利亚
+		"Canada":                 "124", // 加拿大
+		"Chile":                  "152", // 智利
+		"China":                  "156", // 中国
+		"Colombia":               "170", // 哥伦比亚
+		"Costa Rica":             "188", // 哥斯达黎加
+		"Croatia":                "191", // 克罗地亚
+		"Cuba":                   "192", // 古巴
+		"Denmark":                "208", // 丹麦
+		"Ecuador":                "218", // 厄瓜多尔
+		"Egypt":                  "818", // 埃及
+		"Ethiopia":               "231", // 埃塞俄比亚
+		"Finland":                "246", // 芬兰
+		"France":                 "250", // 法国
+		"Germany":                "276", // 德国
+		"Ghana":                  "288", // 加纳
+		"Greece":                 "300", // 希腊
+		"Hungary":                "348", // 匈牙利
+		"India":                  "356", // 印度
+		"Indonesia":              "360", // 印度尼西亚
+		"Iran":                   "364", // 伊朗
+		"Iraq":                   "368", // 伊拉克
+		"Italy":                  "380", // 意大利
+		"Japan":                  "392", // 日本
+		"Jordan":                 "400", // 约旦
+		"Kenya":                  "404", // 肯尼亚
+		"Kuwait":                 "414", // 科威特
+		"Lebanon":                "422", // 黎巴嫩
+		"Malaysia":               "458", // 马来西亚
+		"Mexico":                 "484", // 墨西哥
+		"Morocco":                "504", // 摩洛哥
+		"Nigeria":                "566", // 尼日利亚
+		"Norway":                 "578", // 挪威
+		"Pakistan":               "586", // 巴基斯坦
+		"Peru":                   "604", // 秘鲁
+		"Philippines":            "608", // 菲律宾
+		"Poland":                 "616", // 波兰
+		"Portugal":               "620", // 葡萄牙
+		"Qatar":                  "634", // 卡塔尔
+		"Romania":                "642", // 罗马尼亚
+		"Russia":                 "643", // 俄罗斯
+		"Saudi Arabia":           "682", // 沙特阿拉伯
+		"South Africa":           "710", // 南非
+		"South Korea":            "410", // 韩国
+		"Spain":                  "724", // 西班牙
+		"Sweden":                 "752", // 瑞典
+		"Switzerland":            "756", // 瑞士
+		"Thailand":               "764", // 泰国
+		"Turkey":                 "792", // 土耳其
+		"Ukraine":                "804", // 乌克兰
+		"United Kingdom":         "826", // 英国
+		"United States":          "840", // 美国
+		"Vietnam":                "704", // 越南
+		"Zimbabwe":               "716", // 津巴布韦
+	}
+	if code, ok := countryMap[country]; ok {
+		return code, nil
+	}
+	return "", fmt.Errorf("country code not found for %s", country)
+}
+
+// 综合函数：根据IP获取ISO 3166-1国家码
+func GetISOCodeByIP(ip string) (string, error) {
+	country, err := GetCountryByIP(ip)
+	if err != nil {
+		return "", err
+	}
+	return GetISOCodeByCountry(country)
+}

src/server/GoUtil/feishu.go

@@ -0,0 +1,141 @@
+package GoUtil
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"runtime"
+	"server/conf"
+	"time"
+)
+
+const (
+	FEISHU_WEBHOOK = "https://gadmin.bywaystudios.com/api/feishu/notify"
+	FEISHU_ORDER   = "https://gadmin.bywaystudios.com/api/feishu/notify/order"
+)
+
+// AAqFpbuPhFSEx
+func SendFeishuFatal(PlayerId int, FuncName string, msg string) error {
+	// 创建请求体
+	stack := make([]byte, 1024)
+	length := runtime.Stack(stack, false)
+	payload := map[string]interface{}{
+		"notify_msg": fmt.Sprintf("游戏接口出错 %s:%d", conf.Server.GameName, PlayerId),
+		"host":       FuncName,
+		"event_name": fmt.Sprintf("%s\nStack trace:\n%s", msg, stack[:length]),
+		"severity":   "High",
+		"alarm_time": time.Unix(time.Now().Unix(), 0).Format("2006-01-02 15:04:05"),
+	}
+
+	payloadBytes, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	// 创建HTTP请求
+	req, err := http.NewRequest("POST", FEISHU_WEBHOOK, bytes.NewBuffer(payloadBytes))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	// 发送请求
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	// 检查响应状态码
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("failed to send message, status code: %d", resp.StatusCode)
+	}
+
+	return nil
+}
+
+func SendFeishuOrder(PlayerId int, OrderId string, Price float64, ProductName string, PayTime, VerityTime int64) error {
+	// 创建请求体
+
+	payload := map[string]interface{}{
+		"UID":           PlayerId,
+		"OrderId":       OrderId,
+		"Product":       String(Price),
+		"ProductName":   ProductName,
+		"EventRecovery": time.Unix(PayTime, 0).Format("2006-01-02 15:04:05"),
+		"EventAge":      time.Unix(VerityTime, 0).Format("2006-01-02 15:04:05"),
+	}
+
+	payloadBytes, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	// 创建HTTP请求
+	req, err := http.NewRequest("POST", FEISHU_ORDER, bytes.NewBuffer(payloadBytes))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	// 发送请求
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	// 检查响应状态码
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("failed to send message, status code: %d", resp.StatusCode)
+	}
+
+	return nil
+}
+
+func SendFeishuMsg2(msg string) error {
+	// 创建请求体
+	payload := map[string]interface{}{
+		"msg_type": "interactive",
+		"card": map[string]interface{}{
+			"type": "template",
+			"data": map[string]interface{}{
+				"template_id":           "AAqFpLD2XfySR",
+				"template_version_name": "1.0.1",
+				"template_variable": map[string]interface{}{
+					"appName": conf.Server.GameName,
+				},
+			},
+		},
+	}
+
+	payloadBytes, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	// 创建HTTP请求
+	req, err := http.NewRequest("POST", FEISHU_WEBHOOK, bytes.NewBuffer(payloadBytes))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	// 发送请求
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	// 检查响应状态码
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("failed to send message, status code: %d", resp.StatusCode)
+	}
+
+	return nil
+}

src/server/GoUtil/mapUtil.go

@@ -12,6 +12,13 @@ func MapIntToSlice(m map[int]struct{}) []int32 {
 	}
 	return s
 }
+func MapIntToIntSlice(m map[int]struct{}) []int {
+	var s []int
+	for k := range m {
+		s = append(s, k)
+	}
+	return s
+}
 
 func MapIntToInt32(m map[int]int) map[int32]int32 {
 	r := make(map[int32]int32)
@@ -21,6 +28,14 @@ func MapIntToInt32(m map[int]int) map[int32]int32 {
 	return r
 }
 
+func MapInt32ToInt(m map[int32]int32) map[int]int {
+	r := make(map[int]int)
+	for k, v := range m {
+		r[int(k)] = int(v)
+	}
+	return r
+}
+
 func GetMapKey(v any) []int {
 	if v == nil {
 		return []int{}
@@ -65,3 +80,18 @@ func GetMapKey(v any) []int {
 	}
 	return []int{}
 }
+
+func DiffMap(a, b map[int]int) map[int]int {
+	diff := make(map[int]int)
+	for k, v := range a {
+		if v2, ok := b[k]; !ok || v != v2 {
+			diff[k] = v
+		}
+	}
+	for k, v := range b {
+		if _, ok := a[k]; !ok {
+			diff[k] = v
+		}
+	}
+	return diff
+}

src/server/GoUtil/mathUtil.go

@@ -4,5 +4,8 @@ func RandNum(start int, end int) int {
 	if start > end {
 		return 0
 	}
+	if start == end {
+		return start
+	}
 	return start + GetRand().Intn(end-start+1)
 }

src/server/GoUtil/randUtil.go

@@ -6,6 +6,9 @@ import (
 )
 
 func RandMap(d map[int]int) int {
+	if len(d) == 0 {
+		return 0
+	}
 	total := 0
 	for _, v := range d {
 		total += v
@@ -23,7 +26,28 @@ func RandMap(d map[int]int) int {
 	}
 
 	// 如果没有找到，返回一个默认值
-	return -1
+	return 0
+}
+
+func RandStringMap(d map[string]int) string {
+	total := 0
+	for _, v := range d {
+		total += v
+	}
+
+	// 生成一个 [0, total) 范围内的随机数
+	r := rand.Intn(total)
+
+	// 根据随机数选择一个键
+	for k, v := range d {
+		if r < v {
+			return k
+		}
+		r -= v
+	}
+
+	// 如果没有找到，返回一个默认值
+	return ""
 }
 
 // 从d中随机选取n个元素 不放回

src/server/GoUtil/sliceUtil.go

@@ -1,8 +1,12 @@
 package GoUtil
 
 import (
+	"fmt"
+	"reflect"
+	"server/game/mod/item"
 	"sort"
 	"strconv"
+	"strings"
 )
 
 func IntToInt32(d []int) []int32 {
@@ -13,13 +17,32 @@ func IntToInt32(d []int) []int32 {
 	return r
 }
 
+func Int32ToInt(d []int32) []int {
+	r := make([]int, 0, len(d))
+	for _, d := range d {
+		r = append(r, int(d))
+	}
+	return r
+}
+
+func StringToInt(d []string) []int {
+	r := make([]int, 0, len(d))
+	for _, d := range d {
+		n, _ := strconv.Atoi(d)
+		r = append(r, n)
+	}
+	return r
+}
+
 func RandPopSlice(slice []int) ([]int, int) {
 	slen := len(slice)
 	if slen == 0 {
 		return slice, -1
 	}
 	Id := GetRand().Intn(slen)
-	return append(slice[0:Id], slice[Id+1:]...), slice[Id]
+	Val := slice[Id]
+	Slice2 := append(slice[0:Id], slice[Id+1:]...)
+	return Slice2, Val
 }
 
 func RandSlice(slice []int) int {
@@ -31,7 +54,18 @@ func RandSlice(slice []int) int {
 	return slice[Id]
 }
 
-func RandSliceNum(slice []int, num int) []int {
+func RandItem(slice []*item.Item) *item.Item {
+	slen := len(slice)
+	if slen == 0 {
+		return nil
+	}
+	Id := GetRand().Intn(slen)
+	return slice[Id]
+}
+
+func RandSliceNum(s []int, num int) []int {
+	slice := make([]int, len(s))
+	copy(slice, s)
 	r := make([]int, 0, num)
 	if num <= 0 || len(slice) < num {
 		return slice
@@ -45,7 +79,25 @@ func RandSliceNum(slice []int, num int) []int {
 	return r
 }
 
-func RandSliceNumNonAdjacent(slice []int, num int) []int {
+func RandSliceNum2(s []interface{}, num int) []interface{} {
+	slice := make([]interface{}, len(s))
+	copy(slice, s)
+	r := make([]interface{}, 0, num)
+	if num <= 0 || len(slice) < num {
+		return slice
+	}
+
+	for i := 0; i < num; i++ {
+		Id := GetRand().Intn(len(slice))
+		r = append(r, slice[Id])
+		slice = append(slice[0:Id], slice[Id+1:]...)
+	}
+	return r
+}
+
+func RandSliceNumNonAdjacent(s []int, num int) []int {
+	slice := make([]int, len(s))
+	copy(slice, s)
 	if len(slice) < 2*num {
 		return nil
 	}
@@ -84,6 +136,7 @@ func SliceStringToInt(s []string) []int {
 	}
 	r := make([]int, 0, len(s))
 	for _, v := range s {
+		v = strings.Trim(v, " ")
 		v1, _ := strconv.Atoi(v)
 		r = append(r, v1)
 	}
@@ -107,6 +160,17 @@ func PopElemSlice(s []int, Id int) ([]int, bool) {
 	return s, false
 }
 
+func PopStringElemSlice(s0 []string, Id string) ([]string, bool) {
+	s := make([]string, len(s0))
+	copy(s, s0)
+	for k, v := range s {
+		if v == Id {
+			return append(s[0:k], s[k+1:]...), true
+		}
+	}
+	return s, false
+}
+
 func ElemInSlice(s []int, Id int) bool {
 	for _, v := range s {
 		if v == Id {
@@ -135,6 +199,15 @@ func InArray(Id int, s []int) bool {
 	return false
 }
 
+func InArray64(Id int64, s []int64) bool {
+	for _, v := range s {
+		if v == Id {
+			return true
+		}
+	}
+	return false
+}
+
 func InStringArray(Id string, s []string) bool {
 	for _, v := range s {
 		if v == Id {
@@ -170,3 +243,119 @@ func PopSlice(s []int) (int, []int) {
 	}
 	return s[0], s[1:]
 }
+
+// 判断两个切片的元素是否一致
+func SliceEqual(a, b []int) bool {
+	if len(a) != len(b) {
+		return false
+	}
+
+	// 创建副本以避免修改原始切片
+	aCopy := make([]int, len(a))
+	bCopy := make([]int, len(b))
+	copy(aCopy, a)
+	copy(bCopy, b)
+
+	// 对切片进行排序
+	sort.Ints(aCopy)
+	sort.Ints(bCopy)
+
+	// 比较排序后的切片
+	return reflect.DeepEqual(aCopy, bCopy)
+}
+
+func SlicesEqualString(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+
+	// 创建副本以避免修改原始切片
+	aCopy := make([]string, len(a))
+	bCopy := make([]string, len(b))
+	copy(aCopy, a)
+	copy(bCopy, b)
+
+	// 对切片进行排序
+	sort.Strings(aCopy)
+	sort.Strings(bCopy)
+
+	// 比较排序后的切片
+	return reflect.DeepEqual(aCopy, bCopy)
+}
+
+// IsContainSlice checks if all elements of s2 are contained in s.
+func IsContainSlice(s []int, s2 []int) bool {
+	if len(s2) == 0 {
+		return true
+	}
+	if len(s) < len(s2) {
+		return false
+	}
+	for _, v := range s2 {
+		if !InArray(v, s) {
+			return false
+		}
+		s = SubSlices(s, []int{v})
+	}
+	return true
+}
+
+func InitNumSlice(start, end int) []int {
+	result := make([]int, 0, end-start+1)
+	for i := start; i <= end; i++ {
+		result = append(result, i)
+	}
+	return result
+}
+
+func IntSliceToString(slice []int) string {
+	str := fmt.Sprintf("%v", slice)
+	str = strings.Trim(str, "[]")
+	return str
+}
+
+func PopStringArray(s []string) (string, []string) {
+	if len(s) == 0 {
+		return "", s
+	}
+	return s[0], s[1:]
+}
+
+func ShuffleStringArray(s []string) []string {
+	r := make([]string, len(s))
+	perm := GetRand().Perm(len(s))
+	for i, v := range perm {
+		r[v] = s[i]
+	}
+	return r
+}
+
+func ShuffleArray(s []int) []int {
+	r := make([]int, len(s))
+	perm := GetRand().Perm(len(s))
+	for i, v := range perm {
+		r[v] = s[i]
+	}
+	return r
+}
+
+func IsContain(s []int, s2 []int) bool {
+	for _, v := range s2 {
+		if !InArray(v, s) {
+			return false
+		}
+		s = SubSlices(s, []int{v})
+	}
+	return true
+}
+
+func IsSameElem(s []int) bool {
+	r := make(map[int]struct{})
+	for _, v := range s {
+		if _, ok := r[v]; ok {
+			return true
+		}
+		r[v] = struct{}{}
+	}
+	return false
+}

src/server/GoUtil/timeUtil.go

@@ -1,6 +1,9 @@
 package GoUtil
 
-import "time"
+import (
+	"server/conf"
+	"time"
+)
 
 const (
 	SEVENDAYS = 604800
@@ -27,8 +30,16 @@ func MonthZeroTimestamp() int64 {
 
 func NextZeroTimestampDuration() int64 {
 	now := time.Now()
-	midnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
-	return midnight.AddDate(0, 0, 1).Unix() - now.Unix()
+	location := now.Location()
+	midnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, location)
+	nextMidnight := midnight.AddDate(0, 0, 1)
+
+	// Adjust for daylight saving time transitions
+	_, nowOffset := now.Zone()
+	_, nextMidnightOffset := nextMidnight.Zone()
+	offsetDifference := nextMidnightOffset - nowOffset
+
+	return nextMidnight.Unix() - now.Unix() + int64(offsetDifference)
 }
 
 // 获取距离下个中午十二点时间戳的秒数
@@ -87,10 +98,23 @@ func GetWeekdayAndHour() (int, int) {
 }
 
 func ParseTime(timeStr string) int64 {
-	t, _ := time.Parse("2006-01-02 15:04:05", timeStr)
+	loc, _ := time.LoadLocation("Local")
+	t, _ := time.ParseInLocation("2006-01-02 15:04:05", timeStr, loc)
 	return t.Unix()
 }
 
+func ServerOpenTime() int64 {
+	return ParseTime(conf.Server.ServerOpenTime)
+}
+
+func GetServerOpenDay() int {
+	ServerStartTime := conf.Server.ServerOpenTime
+	t, _ := time.Parse("2006-01-02 15:04:05", ServerStartTime)
+	now := time.Now()
+	d := now.Sub(t)
+	return int(d.Hours() / 24)
+}
+
 // 获取时间戳距离现在过了多少个自然周
 func WeeksSince(timestamp int64) int {
 	// 将时间戳转换为 time.Time 对象
@@ -118,3 +142,35 @@ func FullWeeksSince(timestamp int64) int {
 
 	return currentWeek - startWeek
 }
+
+func ZeroTime(timestamp int64) int64 {
+	t := time.Unix(timestamp, 0)
+	return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location()).Unix()
+}
+
+// 计算给定时间戳所在的 0 点到现在的 0 点过了几天
+func DaysSince(timestamp int64) int {
+	// 获取给定时间戳的 0 点时间
+	t := time.Unix(timestamp, 0)
+	startOfDay := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location())
+
+	// 获取当前时间的 0 点时间
+	now := time.Now()
+	startOfToday := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+
+	// 计算两个时间之间的天数差
+	days := int(startOfToday.Sub(startOfDay).Hours() / 24)
+	return days
+}
+
+func IsSameDay(timestamp1, timestamp2 int64) bool {
+	t1 := time.Unix(timestamp1, 0)
+	t2 := time.Unix(timestamp2, 0)
+
+	return t1.Year() == t2.Year() && t1.YearDay() == t2.YearDay()
+}
+
+func IsFirstDayOfMonth() bool {
+	now := time.Now()
+	return now.Day() == 1
+}

src/server/MergeConst/ErrorCode.go

@@ -8,8 +8,14 @@ const (
 	Protocol_Error_Account_OR_PWD_Short int32 = 102
 	Protocol_Error_Account_Fail         int32 = 103
 	Protocol_Error_Account_NoExsit      int32 = 104
+	Protocol_Error_Account_Code_Error   int32 = 105
+	Protocol_Error_Account_Device_Error int32 = 106
+	Protocol_Error_Id_Not_Verify        int32 = 107
+	Protocol_Error_Id_Verify_Error      int32 = 108
+	Protocol_Error_Account_Ban          int32 = 109
 	Protocol_Res_Buy_Cnt_Limit          int32 = 110
 	Protocol_Res_Buy_CD                 int32 = 111
+
 	Protocol_Email_Find_Fail                  int32 = 120
 	Protocol_Active_No_Exsit                  int32 = 130
 	Protocol_Active_7Day_Rewarded             int32 = 131
@@ -94,10 +100,12 @@ const G_Champion_settlement_Duration = 3600 * 23
 const G_Champion_Unlock_Score = 2
 const G_Champion_Max_Score = 44650
 const G_Champion_People_Cnt = 50
-
+const SUCCESS = 1
 const (
 	ORDER_STATUS_IDLE   = 0 // 订单未完成
 	ORDER_STATUS_PAY    = 1 // 订单已支付
-	ORDER_STATUS_CANCLE = 2 // 订单取消
+	ORDER_STATUS_CANCEL = 2 // 订单取消
 	ORDER_STATUS_SHIP   = 3 // 订单已发货
 )
+
+const GLOBAL_SERVER_ID = 0 // 全局服ID

src/server/benchmark_test.go

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"server/game"
+	"server/game/mod/msg"
+	"testing"
+	"time"
+)
+
+//	func TestBenchInit(t *testing.T) {
+//		f := "wmz00%d"
+//		for i := 0; i < 10000; i++ {
+//			UserName := fmt.Sprintf(f, i)
+//			game.G_GameLogicPtr.Db_AccountInfo.UserName = UserName
+//			game.G_GameLogicPtr.Db_AccountInfo.UserPassword = "123456"
+//			if game.G_GameLogicPtr.NewAccountInsertDataToDB() {
+//				fmt.Printf("UserName:%s\n init success", UserName)
+//			}
+//		}
+//	}
+func BenchmarkGame(b *testing.B) {
+	runtime.GOMAXPROCS(2)
+	fmt.Print("BenchmarkGame")
+	f := "wmz00%d"
+	for i := 0; i < 10000; i++ {
+		go func() {
+			UserName := fmt.Sprintf(f, i)
+			p1 := new(game.Player)
+			err := p1.InitPlayer(UserName)
+			if err != nil {
+				fmt.Println(err)
+			}
+			game.G_GameLogicPtr.SetPlayer(p1)
+			for {
+				time.Sleep(1 * time.Second)
+				game.Benchmark(p1)
+			}
+		}()
+	}
+	go func() {
+		time.Sleep(20 * time.Second)
+		game.G_GameLogicPtr.ChampshipMgrSend(&msg.Msg{
+			Type: msg.HANDLE_TYPE_CHAMPSHIP_GROUP,
+		})
+	}()
+	for {
+		time.Sleep(1 * time.Second)
+		printMemUsage()
+	}
+}
+func printMemUsage() {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	// 输出内存使用情况
+	fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
+	fmt.Printf("\tTotalAlloc = %v MiB", bToMb(m.TotalAlloc))
+	fmt.Printf("\tSys = %v MiB", bToMb(m.Sys))
+	fmt.Printf("\tNumGC = %v\n", m.NumGC)
+	var playerCount int
+	game.G_GameLogicPtr.M_Players.Range(func(key, value interface{}) bool {
+		playerCount++
+		return true
+	})
+	fmt.Printf("\tPlayerNum = %v\n", playerCount)
+}
+
+func bToMb(b uint64) uint64 {
+	return b / 1024 / 1024
+}

src/server/cluster/Cluster.go

@@ -16,7 +16,7 @@ const (
 )
 
 var FuncMap = map[int]func(*Agent, *msg.Msg) error{} // 消息处理函数
-
+var CallbackChan = make(map[string]chan *msg.Msg)    // 回调消息队列
 var (
 	server      *network.TCPServer          // 服务器
 	Center      *network.TCPClient          // 集群中心
@@ -37,7 +37,7 @@ func Init() {
 		server.Start()
 	}
 
-	if conf.Server.CenterAddr != "" {
+	if conf.Server.CenterAddr != "" && conf.Server.ServerType != "center" {
 		connectRemote(conf.Server.CenterAddr, ClusterCenterId, "center")
 	}
 

src/server/cluster/ClusterFunc.go

@@ -27,14 +27,14 @@ func HandShake(a *Agent) {
 		log.Debug("HandShake GobMarshal err %v", err)
 		return
 	}
-	log.Debug("握手 server id :%d", conf.Server.ServerID)
+	// log.Debug("握手 server id :%d", conf.Server.ServerID)
 	a.WriteMsg(data)
 }
 
 // 握手回调
 func HandShakeRecv(a *Agent, m *msg.Msg) error {
 	ServerId := m.From
-	log.Debug("收到握手回复 ServerId %v", ServerId)
+	// log.Debug("收到握手回复 ServerId %v", ServerId)
 	a.ServerId = ServerId
 	serverAgent.Store(ServerId, a)
 
@@ -54,13 +54,13 @@ func HandShakeRecv(a *Agent, m *msg.Msg) error {
 		To:   ServerId,
 	}
 	sendGameMsg(syncMsg)
-	fmt.Print("现有区服连接：")
-	serverAgent.Range(func(key, value interface{}) bool {
-		fmt.Print(key)
-		fmt.Print(",")
-		return true
-	})
-	fmt.Println()
+	// fmt.Print("现有区服连接：")
+	// serverAgent.Range(func(key, value interface{}) bool {
+	// 	fmt.Print(key)
+	// 	fmt.Print(",")
+	// 	return true
+	// })
+	// fmt.Println()
 	return nil
 }
 
@@ -120,10 +120,37 @@ func SendServerMsg(m *msg.Msg, serverId int) error {
 			return err
 		}
 		v.(network.Agent).WriteMsg(data)
+		return nil
 	}
 	return fmt.Errorf("server %d not online", serverId)
 }
 
+func CallServerMsg(m *msg.Msg, serverId int) (*msg.Msg, error) {
+	if v, ok := serverAgent.Load(serverId); ok {
+		data, err := GoUtil.GobMarshal(m)
+		if err != nil {
+			log.Debug("CallServerMsg GobMarshal err %v", err)
+			return nil, err
+		}
+		v.(network.Agent).WriteMsg(data)
+	}
+	m.UniKey = GoUtil.UniKey("clusterGlobal")
+	newChan := make(chan *msg.Msg, 1)
+	registerChanel(m.UniKey, newChan)
+	timeout := time.After(15 * time.Second)
+	select {
+	case <-newChan:
+		backm := <-newChan
+		unregisterChanel(m.UniKey)
+		if backm == nil {
+			return nil, fmt.Errorf("server %d not response", serverId)
+		}
+		return backm, nil
+	case <-timeout:
+		return nil, fmt.Errorf("timeout waiting for server %d response", serverId)
+	}
+}
+
 func SendMsgAll(m *msg.Msg) {
 	data, err := GoUtil.GobMarshal(m)
 	if err != nil {
@@ -138,6 +165,13 @@ func SendMsgAll(m *msg.Msg) {
 
 func processMsg(a *Agent, m *msg.Msg) error {
 	var err error
+	// 先处理同步回调
+	if m.UniKey != "" {
+		if chanel, ok := CallbackChan[m.UniKey]; ok {
+			chanel <- m
+		}
+		return nil
+	}
 	if fun, ok := FuncMap[m.Type]; ok {
 		err = fun(a, m)
 	} else {
@@ -150,6 +184,14 @@ func registerFunc(key int, fun func(*Agent, *msg.Msg) error) {
 	FuncMap[key] = fun
 }
 
+func registerChanel(key string, chanel chan *msg.Msg) {
+	CallbackChan[key] = chanel
+}
+
+func unregisterChanel(key string) {
+	delete(CallbackChan, key)
+}
+
 func sendGameMsg(m *msg.Msg) {
 	MsgChan <- m
 }

src/server/conf/StartOrder/StartOrderCfg.go

@@ -1,41 +0,0 @@
-package startOrderCfg
-
-import (
-	"server/gamedata"
-	"strconv"
-)
-
-type StartOrderCfg struct {
-}
-
-var CFG_NAME = "StartOrder"
-
-func init() {
-	gamedata.InitCfg(CFG_NAME)
-}
-
-// 根据step 获取初始订单
-func GetStartOrderByStep(id int) []*gamedata.StartOrderData {
-	ret := make([]*gamedata.StartOrderData, 0)
-	data, err := gamedata.GetData(CFG_NAME)
-	if err != nil {
-		return ret
-	}
-	for k, v := range data {
-		record := v.(map[string]interface{})
-		stepVal := gamedata.ParseInt(record["step"])
-		var MergeList []int
-		for _, vv := range record["merge_id_list"].([]interface{}) {
-			MergeList = append(MergeList, gamedata.ParseInt(vv))
-		}
-		if int(stepVal) == id {
-			OrderId, _ := strconv.Atoi(k)
-			ret = append(ret, &gamedata.StartOrderData{
-				Id:        OrderId,
-				Step:      int(stepVal),
-				MergeList: MergeList,
-			})
-		}
-	}
-	return ret
-}

src/server/conf/activity/ActivityCfg.go

@@ -2,17 +2,51 @@ package activityCfg
 
 import (
 	"server/GoUtil"
+	languageCfg "server/conf/language"
+	"server/game/mod/item"
 	"server/gamedata"
+	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 	"strconv"
 )
 
 const (
 	CFG_ACTIVITY      = "Activity"
+	CFG_ACTIVITY_GIFT = "ActivityGift"
 )
 
 func init() {
 	gamedata.InitCfg(CFG_ACTIVITY)
+	gamedata.InitCfg(CFG_ACTIVITY_GIFT)
+}
+
+func GetActivityGiftId(chargeId int) int {
+	data, err := gamedata.GetData(CFG_ACTIVITY_GIFT)
+	if err != nil {
+		log.Debug("GetActivityGift err:%v", err)
+	}
+	for _, v := range data {
+		ChargeId := gamedata.GetIntValue(v, "ChargeId")
+		if ChargeId == chargeId {
+			return gamedata.GetIntValue(v, "AId")
+		}
+	}
+	return 0
+}
+
+func GetAcitivityGiftItems(chargeId int) []*item.Item {
+	data, err := gamedata.GetData(CFG_ACTIVITY_GIFT)
+	if err != nil {
+		log.Debug("GetAcitivityGiftItems err:%v", err)
+	}
+	for _, v := range data {
+		ChargeId := gamedata.GetIntValue(v, "ChargeId")
+		if ChargeId == chargeId {
+			Items := gamedata.GetItemList(v, "Items")
+			return Items
+		}
+	}
+	return nil
 }
 
 func GetActivityList() []*gamedata.ActivityData {
@@ -33,14 +67,43 @@ func GetActivityList() []*gamedata.ActivityData {
 			Type := gamedata.GetIntValue(v, "Type")
 			Name := gamedata.GetStringValue(v, "Name")
 			Title := gamedata.GetStringValue(v, "Title")
+			Level := gamedata.GetIntValue(v, "Level")
 			ActivityData := &gamedata.ActivityData{
 				Id:        Id,
 				Type:      Type,
+				AType:     gamedata.GetIntValue(v, "AType"),
 				Name:      Name,
 				Title:     Title,
+				Level:     Level,
+				StartTime: StartTime,
+				EndTime:   EndTime,
 			}
 			List = append(List, ActivityData)
 		}
 	}
 	return List
 }
+
+func GetAcitivityRewardItems(ActId int) []*item.Item {
+	data, err := gamedata.GetData(CFG_ACTIVITY_GIFT)
+	if err != nil {
+		log.Debug("GetAcitivityGiftItems err:%v", err)
+	}
+	for _, v := range data {
+		ChargeId := gamedata.GetIntValue(v, "ChargeId")
+		AId := gamedata.GetIntValue(v, "AId")
+		if ChargeId == 0 && AId == ActId {
+			Items := gamedata.GetItemList(v, "Items")
+			return Items
+		}
+	}
+	return nil
+}
+
+func GetActivityTitle(ActId int) (string, string) {
+	data, err := gamedata.GetDataByIntKey(CFG_ACTIVITY, ActId)
+	if err != nil {
+		log.Debug("GetActivityTitle err:%v", err)
+	}
+	return languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, gamedata.GetStringValue(data, "Title")), languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, gamedata.GetStringValue(data, "Title"))
+}

src/server/conf/avatar/AvatarCfg.go

@@ -40,3 +40,17 @@ func CheckExist(Id int) bool {
 	_, ok := data[strconv.Itoa(Id)]
 	return ok
 }
+
+func GetAllId() []int {
+	data, err := gamedata.GetData(CFG_AVATAR)
+	if err != nil {
+		log.Debug("GetAllId err: %v", err)
+		return nil
+	}
+	r := make([]int, 0)
+	for k := range data {
+		Id, _ := strconv.Atoi(k)
+		r = append(r, Id)
+	}
+	return r
+}

src/server/conf/base/BaseCfg.go

@@ -12,10 +12,12 @@ const (
 
 const (
 	ENERGY_SHOP_MUL = "energy_shop_mul"
+	ENERGY_CFG      = "BaseEnergy"
 )
 
 func init() {
 	gamedata.InitCfg(CFG_BASE)
+	gamedata.InitCfg(ENERGY_CFG)
 }
 
 func GetEnergyByMul(T int) float64 {
@@ -35,5 +37,28 @@ func GetEnergyByMul(T int) float64 {
 	} else {
 		return 0
 	}
-
+}
+
+func GetMaxEnergyMul(Lv int, Energy int) int {
+	Mul := 0
+	for i := 1; i < 999; i++ {
+		data, err := gamedata.GetDataByIntKey(ENERGY_CFG, i)
+		if err != nil {
+			break
+		}
+		UnlockLv := gamedata.GetIntValue(data, "UnlockLv")
+		if Lv < UnlockLv || Energy < gamedata.GetIntValue(data, "NeedEnergy") {
+			break
+		}
+		Mul = i - 1
+	}
+	return Mul
+}
+
+func GetLimitEnergyMul(Lv int) int {
+	data, err := gamedata.GetDataByIntKey(ENERGY_CFG, Lv+1)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Limit")
 }

src/server/conf/card/CardCfg.go

@@ -40,6 +40,14 @@ func GetStarById(Id int) int {
 	return gamedata.GetIntValue(data, "Star")
 }
 
+func GetRoundById(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CARD_DETAIL_CFG_NAME, Id)
+	if err != nil {
+		log.Debug("GetRoundById data not found")
+	}
+	return gamedata.GetIntValue(data, "Round")
+}
+
 // 获取开启卡包获得的卡牌数量
 func GetPackRewardCnt(Star int) int {
 	data, err := gamedata.GetDataByIntKey(CARD_PACK_CFG_NAME, Star)
@@ -62,13 +70,17 @@ func GetPackMustHave(Star int) int {
 }
 
 // 根据星级获取卡牌列表
-func GetCardListByStar(Star, IsGold int) []int {
+func GetCardListByStar(Round, Star, IsGold int) []int {
 	var CardList []int
 	data, err := gamedata.GetData(CARD_DETAIL_CFG_NAME)
 	if err != nil {
 		log.Debug("GetCardListByStar data not found")
 	}
 	for k, v := range data {
+		Extra := gamedata.GetIntValue(v, "Round")
+		if Round < Extra {
+			continue
+		}
 		vStar := gamedata.GetIntValue(v, "Star")
 		isGold := gamedata.GetIntValue(v, "IsGold")
 		if vStar == Star && IsGold == isGold {
@@ -80,7 +92,7 @@ func GetCardListByStar(Star, IsGold int) []int {
 }
 
 // 获取随机卡牌
-func GetRandListByStar(Star int) []int {
+func GetRandListByStar(Star int) map[int]int {
 	var randList []int
 	data, err := gamedata.GetDataByIntKey(CARD_PACK_CFG_NAME, Star)
 	if err != nil {
@@ -89,7 +101,11 @@ func GetRandListByStar(Star int) []int {
 	r1 := gamedata.GetStringValue(data, "RandRate")
 	r2 := strings.Split(r1, ",")
 	randList = GoUtil.SliceStringToInt(r2)
-	return randList
+	r := make(map[int]int)
+	for k, v := range randList {
+		r[k+1] = v
+	}
+	return r
 }
 
 // 获取卡牌收集奖励
@@ -106,19 +122,14 @@ func GetCollectReward(Color int) ([]*item.Item, int) {
 }
 
 // 获取兑换奖励
-func GetExchangeCfg(Id int) (int, []*item.Item, []int) {
+func GetExchangeCfg(Id int) (int, []*item.Item) {
 	data, err := gamedata.GetDataByIntKey(CARD_EXCHANGE_CFG, Id)
 	if err != nil {
 		log.Debug("GetExchangeCfg data not found")
-		return 0, nil, nil
 	}
-	itemNum := gamedata.GetIntValue(data, "Item")
-	itemList := []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, itemNum)}
 	CostStar := gamedata.GetIntValue(data, "CostStar")
-	CardPackStr := gamedata.GetStringValue(data, "CardPack")
-	s1 := CardPackStr[1 : len(CardPackStr)-1]
-	CardPack := GoUtil.SliceStringToInt(strings.Split(s1, ","))
-	return CostStar, itemList, CardPack
+	itemList := gamedata.GetItemList(data, "Item")
+	return CostStar, itemList
 }
 
 // 根据系列获取卡牌列表
@@ -140,20 +151,32 @@ func GetCardListByColor(Id int) []int {
 }
 
 // 获取所有卡牌id
-func GetAllCardId() []int {
+func GetAllCardId(Round int) []int {
 	data, err := gamedata.GetData(CARD_DETAIL_CFG_NAME)
 	if err != nil {
 		log.Debug("GetCardListByColor data not found")
 		return []int{}
 	}
 	var r []int
-	for k := range data {
+	for k, v := range data {
+		Extra := gamedata.GetIntValue(v, "Round")
+		if Round < Extra {
+			continue
+		}
 		k1, _ := strconv.Atoi(k)
 		r = append(r, k1)
 	}
 	return r
 }
 
+func CheckCardIsGold(Id int) bool {
+	data, err := gamedata.GetDataByIntKey(CARD_DETAIL_CFG_NAME, Id)
+	if err != nil {
+		log.Debug("CheckCardIsGold data not found")
+	}
+	return gamedata.GetIntValue(data, "IsGold") == 1
+}
+
 func GetCardDuration() int64 {
 	data, err := gamedata.GetDataByKey(CARD_CONST_CFG_NAME, "duration")
 	if err != nil {
@@ -177,3 +200,19 @@ func GetReqTimes() int {
 	}
 	return gamedata.GetIntValue(data, "Value")
 }
+
+func GetItemIdByCardId(CardId int) int {
+	data, err := gamedata.GetDataByIntKey(CARD_DETAIL_CFG_NAME, CardId)
+	if err != nil {
+		log.Debug("GetItemIdByCardId data not found")
+	}
+	return gamedata.GetIntValue(data, "ItemId")
+}
+
+func GetSeasonFirstReward() []*item.Item {
+	data, err := gamedata.GetDataByKey(CARD_CONST_CFG_NAME, "season_first")
+	if err != nil {
+		log.Debug("GetSeasonFirstReward data not found")
+	}
+	return item.ParseItem(data["Value"])
+}

src/server/conf/catnip/CatnipCfg.go

@@ -0,0 +1,110 @@
+package catnipCfg
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	"server/gamedata"
+)
+
+const (
+	CATNIP_TEMPLATE_CFG_NAME   = "CatnipTemplate"
+	CATNIP_JACKPOT_CFG_NAME    = "CatnipJackpot"
+	CATNIP_MULTIPLIER_CFG_NAME = "CatnipMultiplier"
+	CATNIP_GAME_CFG_NAME       = "CatnipGame"
+)
+
+const (
+	CATNIP_REWARD_TYPE_LOW  = 1
+	CATNIP_REWARD_TYPE_MID  = 2
+	CATNIP_REWARD_TYPE_HIGH = 3
+)
+
+func init() {
+	gamedata.InitCfg(CATNIP_TEMPLATE_CFG_NAME)
+	gamedata.InitCfg(CATNIP_JACKPOT_CFG_NAME)
+	gamedata.InitCfg(CATNIP_MULTIPLIER_CFG_NAME)
+	gamedata.InitCfg(CATNIP_GAME_CFG_NAME)
+}
+
+func GetGameNum(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CATNIP_TEMPLATE_CFG_NAME, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "PassNum")
+}
+
+func GetJackpotItem(Mul int) (int, []*item.Item, int) {
+	data, err := gamedata.GetData(CATNIP_JACKPOT_CFG_NAME)
+	if err != nil {
+		return 0, nil, 0
+	}
+	JackpotType := GetJackpotType(Mul)
+	r := make(map[int]int)
+	for k, v := range data {
+		if gamedata.GetIntValue(v, "Type") == JackpotType {
+			r[GoUtil.Int(k)] = 1
+		}
+	}
+	Id := GoUtil.RandMap(r)
+	if Id == 0 {
+		return 0, nil, 0
+	}
+	itemData, err := gamedata.GetDataByIntKey(CATNIP_JACKPOT_CFG_NAME, Id)
+	if err != nil {
+		return 0, nil, 0
+	}
+	return Id, gamedata.GetItemList(itemData, "Items"), gamedata.GetIntValue(itemData, "Growth")
+}
+
+func GetJackpotType(Mul int) int {
+	data, err := gamedata.GetDataByIntKey(CATNIP_MULTIPLIER_CFG_NAME, Mul)
+	if err != nil {
+		return 0
+	}
+	R := map[int]int{
+		CATNIP_REWARD_TYPE_LOW:  gamedata.GetIntValue(data, "Low"),
+		CATNIP_REWARD_TYPE_MID:  gamedata.GetIntValue(data, "Mid"),
+		CATNIP_REWARD_TYPE_HIGH: gamedata.GetIntValue(data, "High"),
+	}
+	return GoUtil.RandMap(R)
+}
+
+func GetTemplateId(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CATNIP_TEMPLATE_CFG_NAME, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Template")
+}
+
+func GetProgressReward(Id int, Progress int) []*item.Item {
+	TemplateId := GetTemplateId(Id)
+	data, err := gamedata.GetDataByIntKey(CATNIP_GAME_CFG_NAME, Id)
+	if err != nil {
+		return nil
+	}
+
+	for _, v := range data {
+		if gamedata.GetIntValue(v, "Need") == Progress && gamedata.GetIntValue(v, "Template") == TemplateId {
+			return gamedata.GetItemList(v, "Items")
+		}
+	}
+	return nil
+}
+
+func GetItemCost(Id, Mul int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CATNIP_TEMPLATE_CFG_NAME, Id)
+	if err != nil {
+		return nil
+	}
+	return item.MutilItem(gamedata.GetItemList(data, "ItemCost"), Mul)
+}
+
+func GetGrandReward(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CATNIP_TEMPLATE_CFG_NAME, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "Reward")
+}

src/server/conf/champship/ChampshipCfg.go

@@ -10,12 +10,27 @@ const (
 	CFG_CHAMPSHIP_SCORE   = "ChampshipScore"
 	CFG_CHAMPSHIP_RANK    = "ChampshipRank"
 	CFG_CHAMPSHIP_JACKPOT = "ChampshipJackpot"
+	CFG_CHAMPSHIP_GROUP   = "ChampshipGroup"
 )
 
 func init() {
 	gamedata.InitCfg(CFG_CHAMPSHIP_SCORE)
 	gamedata.InitCfg(CFG_CHAMPSHIP_RANK)
 	gamedata.InitCfg(CFG_CHAMPSHIP_JACKPOT)
+	gamedata.InitCfg(CFG_CHAMPSHIP_GROUP)
+}
+
+func GetGroupId(N int) int {
+	data, err := gamedata.GetData(CFG_CHAMPSHIP_GROUP)
+	if err != nil {
+		return 0
+	}
+	for k, v := range data {
+		if N >= gamedata.GetIntValue(v, "Min") && N <= gamedata.GetIntValue(v, "Max") {
+			return GoUtil.Int(k)
+		}
+	}
+	return 0
 }
 
 func GetChessScore(ChessLv int) int {
@@ -32,16 +47,46 @@ func GetReward(Reward, Score int) (int, []*item.Item) {
 		return Reward, nil
 	}
 	r := make([]*item.Item, 0)
+	NewReward := Reward
 	for k, v := range data {
 		Id := GoUtil.Int(k)
 		if Reward >= Id {
 			continue
 		}
-		Reward = max(Reward, Id)
-		if Score >= gamedata.GetIntValue(v, "Score") {
-			Items := item.ParseItem(gamedata.GetStringValue(v, "Items"))
+		if Score >= gamedata.GetIntValue(v, "Total") {
+			Items := item.ParseItem(gamedata.GetValue(v, "Items"))
 			r = item.Merge(r, Items)
+			NewReward = max(NewReward, Id)
 		}
 	}
-	return Reward, r
+	return NewReward, r
+}
+
+func GetRewardItems(Reward int) ([]*item.Item, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_CHAMPSHIP_JACKPOT, Reward)
+	if err != nil {
+		return nil, 0
+	}
+	return gamedata.GetItemList(data, "Items"), gamedata.GetIntValue(data, "Score")
+}
+
+func GetRewardTotalScore(Reward int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_CHAMPSHIP_JACKPOT, Reward)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Total")
+}
+
+func GetRankReward(Rank int) []*item.Item {
+	data, err := gamedata.GetData(CFG_CHAMPSHIP_RANK)
+	if err != nil {
+		return nil
+	}
+	for _, v := range data {
+		if Rank >= gamedata.GetIntValue(v, "Min") && Rank <= gamedata.GetIntValue(v, "Max") {
+			return gamedata.GetItemList(v, "Items")
+		}
+	}
+	return nil
 }

src/server/conf/charge/ChargeCfg.go

@@ -10,12 +10,15 @@ import (
 
 const (
 	CFG_CHARGE         = "Charge"
-	CFG_DIAMOND_SHOP = "DiamondShop"
-	CFG_ENERGY_SHOP  = "EnergyShop"
-	CFG_SEPCIAL_SHOP = "SpecialShop"
-	CFG_FREE_SHOP    = "FreeShop"
-	CFG_CHARGE_CONST = "ChargeConst"
-	CFG_CHARGE_GIFT  = "ChargeGift"
+	CFG_DIAMOND_SHOP   = "DiamondShop"   // 钻石商店
+	CFG_ENERGY_SHOP    = "EnergyShop"    // 体力商店
+	CFG_SEPCIAL_SHOP   = "SpecialShop"   // 特惠商店
+	CFG_FREE_SHOP      = "FreeShop"      // 免费商店
+	CFG_CHARGE_CONST   = "ChargeConst"   // 充值常量配置
+	CFG_CHARGE_GIFT    = "ChargeGift"    // 充值礼包
+	CFG_CHARGE_WISH    = "ChargeWish"    // 许愿配置
+	CFG_CHARGE_PETCOIN = "ChargePetCoin" // 宠物币充值配置
+	CFG_CHARGE_AD      = "ChargeAD"      // 广告充值配置
 )
 
 func init() {
@@ -26,6 +29,22 @@ func init() {
 	gamedata.InitCfg(CFG_FREE_SHOP)
 	gamedata.InitCfg(CFG_CHARGE_CONST)
 	gamedata.InitCfg(CFG_CHARGE_GIFT)
+	gamedata.InitCfg(CFG_CHARGE_WISH)
+	gamedata.InitCfg(CFG_CHARGE_PETCOIN)
+	gamedata.InitCfg(CFG_CHARGE_AD)
+}
+
+func GetADReward(ChargeId int) ([]*item.Item, int) {
+	data, err := gamedata.GetData(CFG_CHARGE_AD)
+	if err != nil {
+		return nil, 0
+	}
+	for _, v := range data {
+		if gamedata.GetIntValue(v, "ChargeId") == ChargeId {
+			return item.ParseItem(gamedata.GetValue(v, "Items")), gamedata.GetIntValue(v, "PetWork")
+		}
+	}
+	return nil, 0
 }
 
 func GetMoneyCharge(ChargeId int) float64 {
@@ -134,15 +153,15 @@ func GetSpecialShopGrade(Money float64, Type int) int {
 		})
 	}
 	sort.Slice(l, func(i, j int) bool {
-		return l[i].money < l[j].money
+		return l[i].money > l[j].money
 	})
 
 	for _, v := range l {
-		if Money < v.money {
+		if Money <= v.money {
 			return v.id
 		}
 	}
-	return 0
+	return l[0].id
 }
 
 func GetUnlockShopLv() int {
@@ -251,3 +270,24 @@ func GetChargeInfo(ChargeId int) (float64, string) {
 	}
 	return gamedata.GetFloatValue(data, "Money"), gamedata.GetStringValue(data, "Unit")
 }
+
+func GetWishCount(ItemId int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_CHARGE_WISH, ItemId)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Wish")
+}
+
+func GetPetCoinShopReward(ChargeId int) []*item.Item {
+	data, err := gamedata.GetData(CFG_CHARGE_PETCOIN)
+	if err != nil {
+		return nil
+	}
+	for _, v := range data {
+		if gamedata.GetIntValue(v, "ChargeId") == ChargeId {
+			return gamedata.GetItemList(v, "Items")
+		}
+	}
+	return nil
+}

src/server/conf/collect/CollectCfg.go

@@ -0,0 +1,53 @@
+package collectCfg
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	"server/gamedata"
+)
+
+const (
+	CFG_COLLECT         = "Collect"
+	CFG_COLLECT_JACKPOT = "CollectJackpot"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_COLLECT)
+	gamedata.InitCfg(CFG_COLLECT_JACKPOT)
+}
+
+func GetJackpotId() []int {
+	data, err := gamedata.GetData(CFG_COLLECT_JACKPOT)
+	if err != nil {
+		return nil
+	}
+	ret := make([]int, 0)
+	for k := range data {
+		ret = append(ret, GoUtil.Int(k))
+	}
+	return ret
+}
+
+func GetJackpotItems(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_COLLECT_JACKPOT, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "Items")
+}
+
+func GetRewardNeed(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_COLLECT, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Need")
+}
+
+func GetRewardType(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_COLLECT, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Type")
+}

src/server/conf/conf.go

@@ -11,7 +11,7 @@ var (
 
 	// gate conf
 	PendingWriteNum        = 2000
-	MaxMsgLen       uint32 = 16384 // 16KB
+	MaxMsgLen       uint32 = 65536 // 16KB
 	HTTPTimeout            = 10 * time.Second
 	LenMsgLen              = 2
 	LittleEndian           = false

src/server/conf/decorate/DecorateCfg.go

@@ -5,16 +5,21 @@ import (
 	"server/gamedata"
 	"server/pkg/github.com/name5566/leaf/log"
 	"strconv"
+	"strings"
 )
 
 const (
 	DECORATE_COST   = "DecorateCost"
 	INDOOR_PROGRESS = "IndoorProgress"
+	DECORATE_CONST  = "DecorateConst"
+	DECORATE_AREA   = "DecorateArea" // 装饰区域
 )
 
 func init() {
-	gamedata.InitCfg("DecorateCost")
-	gamedata.InitCfg("IndoorProgress")
+	gamedata.InitCfg(DECORATE_COST)
+	gamedata.InitCfg(INDOOR_PROGRESS)
+	gamedata.InitCfg(DECORATE_CONST)
+	gamedata.InitCfg(DECORATE_AREA)
 }
 
 func GetStarCost(AreaId, SortId int) int {
@@ -24,9 +29,8 @@ func GetStarCost(AreaId, SortId int) int {
 		return 0
 	}
 	for _, v := range data {
-		v1 := v.(map[string]interface{})
-		if gamedata.ParseInt(v1["AreaId"]) == AreaId && gamedata.ParseInt(v1["SortId"]) == SortId {
-			return gamedata.ParseInt(v1["CostCount"])
+		if gamedata.GetIntValue(v, "AreaId") == AreaId && gamedata.GetIntValue(v, "SortId") == SortId {
+			return gamedata.GetIntValue(v, "CostCount")
 		}
 	}
 	return 0
@@ -48,8 +52,7 @@ func GetNextAreaId(AreaId, SortId int) int {
 		return 0
 	}
 	for k, v := range data {
-		v1 := v.(map[string]interface{})
-		if gamedata.ParseInt(v1["AreaId"]) == AreaId && gamedata.ParseInt(v1["SortId"]) == SortId {
+		if gamedata.GetIntValue(v, "AreaId") == AreaId && gamedata.GetIntValue(v, "SortId") == SortId {
 			UnionKey, _ := strconv.Atoi(k)
 			nextId := UnionKey + 1
 			AreaId = GetAreaId(nextId)
@@ -67,9 +70,8 @@ func GetAllSortIdByAreaId(AreaId int) []int {
 	}
 	var SortIdList []int
 	for _, v := range data {
-		v1 := v.(map[string]interface{})
-		if gamedata.ParseInt(v1["AreaId"]) == AreaId {
-			Sort := gamedata.ParseInt(v1["SortId"])
+		if gamedata.GetIntValue(v, "AreaId") == AreaId {
+			Sort := gamedata.GetIntValue(v, "SortId")
 			if Sort == 0 {
 				continue
 			}
@@ -80,16 +82,125 @@ func GetAllSortIdByAreaId(AreaId int) []int {
 }
 
 func GetProgressReward(Scene, Lv int) []*item.Item {
-	value, err := gamedata.GetData("IndoorProgress")
+	value, err := gamedata.GetData(INDOOR_PROGRESS)
 	if err != nil {
 		log.Debug("IndoorProgress GetProgressReward not found")
 		return nil
 	}
 	for _, v := range value {
-		v1 := v.(map[string]interface{})
-		if gamedata.ParseInt(v1["Scene"]) == Scene && gamedata.ParseInt(v1["Lv"]) == Lv {
-			return item.ParseItem(v1["Item"])
+		if gamedata.GetIntValue(v, "Scene") == Scene && gamedata.GetIntValue(v, "Lv") == Lv {
+			return gamedata.GetItemList(v, "AreaReward")
 		}
 	}
 	return nil
 }
+
+func GetDecoarteReward(Scene int, Lv int) []*item.Item {
+	value, err := gamedata.GetData(INDOOR_PROGRESS)
+	if err != nil {
+		log.Debug("IndoorProgress GetDecoarteReward not found")
+		return nil
+	}
+	for _, v := range value {
+		if gamedata.GetIntValue(v, "Scene") == Scene && gamedata.GetIntValue(v, "Lv") == Lv {
+			return gamedata.GetItemList(v, "Item")
+		}
+	}
+	return nil
+}
+
+// 获取一键装饰的解锁等级
+func GetOneKeyDecorateUnlockLv() int {
+	data, err := gamedata.GetDataByKey(DECORATE_CONST, "OneKey")
+	if err != nil {
+		log.Debug("GetOneKeyDecorateUnlockLv err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+// 获取每次装饰增加的体力值
+func GetDecorateAddEnergy() int {
+	data, err := gamedata.GetDataByKey(DECORATE_CONST, "AddEnergy")
+	if err != nil {
+		log.Debug("GetDecorateAddEnergy not found")
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetAreaPerPExp(AreaId int) int {
+	data, err := gamedata.GetDataByIntKey(DECORATE_AREA, AreaId)
+	if err != nil {
+		log.Debug("DecorateArea GetAreaPerPExp not found AreaId:%v", AreaId)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "PerPExp")
+}
+
+func GetDecoratePExp(AreaId, SortId int) int {
+	data, err := gamedata.GetData(DECORATE_COST)
+	if err != nil {
+		log.Debug("DecorateArea GetDecoratePExp not found")
+		return 0
+	}
+	for _, v := range data {
+		if gamedata.GetIntValue(v, "AreaId") == AreaId && gamedata.GetIntValue(v, "SortId") == SortId {
+			return gamedata.GetIntValue(v, "PetExp")
+		}
+	}
+	return 0
+}
+
+func GetAllPartId() []int {
+	data, err := gamedata.GetDataByKey(DECORATE_CONST, "AllPartId")
+	if err != nil {
+		log.Debug("DecorateCost GetAllPartId not found")
+		return []int{1505, 1515, 1525, 1535}
+	}
+	var PartIdList []int
+	str := gamedata.GetStringValue(data, "Value")
+	r1 := strings.Split(str, "|")
+	for _, v := range r1 {
+		id, _ := strconv.Atoi(v)
+		PartIdList = append(PartIdList, id)
+	}
+	return PartIdList
+}
+
+func GetIdBySenceAndLv(Sence, Lv int) int {
+	data, err := gamedata.GetData(INDOOR_PROGRESS)
+	if err != nil {
+		log.Debug("DecorateArea GetIdBySenceAndLv not found")
+		return 0
+	}
+	for k, v := range data {
+		if gamedata.GetIntValue(v, "Scene") == Sence && gamedata.GetIntValue(v, "Lv") == Lv {
+			id, _ := strconv.Atoi(k)
+			return id
+		}
+	}
+	return 0
+}
+
+func GetPartNumByAreaId(AreaId int) map[int]int {
+	data, err := gamedata.GetData(INDOOR_PROGRESS)
+	if err != nil {
+		log.Debug("DecorateArea GetPartNumByAreaId not found AreaId:%v", AreaId)
+		return nil
+	}
+	res := make(map[int]int)
+	for k, v := range data {
+		Sence := gamedata.GetIntValue(v, "Scene")
+		if Sence != AreaId {
+			continue
+		}
+		id, _ := strconv.Atoi(k)
+		PartNum := gamedata.GetIntValue(v, "Part")
+		if PartNum == 0 {
+			continue
+		}
+		res[id] = PartNum
+	}
+	return res
+}

src/server/conf/emoji/emojiCfg.go

@@ -0,0 +1,49 @@
+package emojiCfg
+
+import (
+	"server/GoUtil"
+	"server/gamedata"
+)
+
+const (
+	CFG_EMOJI = "Emoji"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_EMOJI)
+}
+
+func GetInitList() []int {
+	data, err := gamedata.GetData(CFG_EMOJI)
+	if err != nil {
+		return nil
+	}
+	ret := make([]int, 0)
+	for k, v := range data {
+		Init := gamedata.GetIntValue(v, "Init")
+		if Init == 1 {
+			ret = append(ret, GoUtil.Int(k))
+		}
+	}
+	return ret
+}
+
+func GetAllList() []int {
+	data, err := gamedata.GetData(CFG_EMOJI)
+	if err != nil {
+		return nil
+	}
+	ret := make([]int, 0)
+	for k := range data {
+		ret = append(ret, GoUtil.Int(k))
+	}
+	return ret
+}
+
+func GetEmojiName(Id int) string {
+	data, err := gamedata.GetDataByIntKey(CFG_EMOJI, Id)
+	if err != nil {
+		return ""
+	}
+	return gamedata.GetStringValue(data, "Name")
+}

src/server/conf/endless/EndlessCfg.go

@@ -67,14 +67,14 @@ func GetPerDiamond(Id int) float64 {
 	return 0
 }
 
-func GetItemId(Diamond float64, Type int) []int {
+func GetItemId(Diamond float64, Type, Lv int) []int {
 	data, err := gamedata.GetData(CFG_ENDLESS_JACKPOT)
 	if err != nil {
 		return nil
 	}
 	var ItemId []int
 	for _, v := range data {
-		if Diamond >= gamedata.GetFloatValue(v, "Diamond") && Type != gamedata.GetIntValue(v, "Type") && gamedata.GetIntValue(v, "ItemId") != item.ITEM_ENERGY_ID {
+		if Lv >= gamedata.GetIntValue(v, "Lv") && Diamond >= gamedata.GetFloatValue(v, "Diamond") && Type != gamedata.GetIntValue(v, "Type") && gamedata.GetIntValue(v, "ItemId") != item.ITEM_ENERGY_ID {
 			ItemId = append(ItemId, gamedata.GetIntValue(v, "ItemId"))
 		}
 	}

src/server/conf/face/FaceCfg.go

@@ -40,3 +40,17 @@ func CheckExist(Id int) bool {
 	_, ok := data[strconv.Itoa(Id)]
 	return ok
 }
+
+func GetAllId() []int {
+	data, err := gamedata.GetData(CFG_FACE)
+	if err != nil {
+		log.Debug("GetAllId err: %v", err)
+		return nil
+	}
+	r := make([]int, 0)
+	for k := range data {
+		Id, _ := strconv.Atoi(k)
+		r = append(r, Id)
+	}
+	return r
+}

src/server/conf/friendTreasure/friendTreasureCfg.go

@@ -0,0 +1,87 @@
+package friendTreasureCfg
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	"server/gamedata"
+)
+
+const (
+	CFG_FRIEND_TREASURE_PROB  = "FriendTreasureProb"
+	CFG_FRIEND_TREASURE_CHEST = "FriendTreasureChest"
+	CFG_FRIEND_TREASURE_CONST = "FriendTreasureConst"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_FRIEND_TREASURE_PROB)
+	gamedata.InitCfg(CFG_FRIEND_TREASURE_CHEST)
+	gamedata.InitCfg(CFG_FRIEND_TREASURE_CONST)
+}
+
+func GetBigReward() []*item.Item {
+	data, err := gamedata.GetDataByKey(CFG_FRIEND_TREASURE_CONST, "big_reward")
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "Value")
+}
+
+func GetFriendTreasureProb(Num int) map[int]int {
+	data, err := gamedata.GetData(CFG_FRIEND_TREASURE_PROB)
+	if err != nil {
+		return nil
+	}
+	ProbMap := make(map[int]int)
+	for k, v := range data {
+		Id := GoUtil.Int(k)
+		Prob := gamedata.GetIntValue(v, "Prob")
+		ProbMap[Id] = Prob
+	}
+	AddProb := 0
+	n := 0
+	for k, v := range ProbMap {
+		if k > Num {
+			AddProb += v
+			n++
+			ProbMap[k] = 0
+		}
+	}
+	PerProb := AddProb / n
+	for k, v := range ProbMap {
+		if k <= Num && k != 1 {
+			ProbMap[k] = v + PerProb
+		}
+	}
+	return ProbMap
+}
+
+func GetProbAdd(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_FRIEND_TREASURE_PROB, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Add")
+}
+
+func GetChestProb() map[int]int {
+	data, err := gamedata.GetData(CFG_FRIEND_TREASURE_CHEST)
+	if err != nil {
+		return nil
+	}
+	ProbMap := make(map[int]int)
+	for k, v := range data {
+		Id := GoUtil.Int(k)
+		Prob := gamedata.GetIntValue(v, "Prob")
+		ProbMap[Id] = Prob
+	}
+	return ProbMap
+}
+
+func GetChestItems(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_FRIEND_TREASURE_CHEST, Id)
+	if err != nil {
+		return nil
+	}
+
+	return gamedata.GetItemList(data, "Items")
+}

src/server/conf/guessColor/guessColorCfg..go

@@ -0,0 +1,110 @@
+package guesscolorCfg
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	"server/gamedata"
+	"strings"
+)
+
+const (
+	CFG_GUESS_COLOR_TEMPLATE = "GuessColorTemplate"
+	CFG_GUESS_COLOR_REWARD   = "GuessColorReward"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_GUESS_COLOR_TEMPLATE)
+	gamedata.InitCfg(CFG_GUESS_COLOR_REWARD)
+}
+
+func GetFirstPass(Id int) map[int]int {
+	data, err := gamedata.GetDataByIntKey(CFG_GUESS_COLOR_TEMPLATE, Id)
+	if err != nil {
+		return nil
+	}
+	str := gamedata.GetStringValue(data, "FirstPass")
+	arr := strings.Split(str, "|")
+	ret := make(map[int]int)
+	for k, v := range arr {
+		ret[k+1] = GoUtil.Int(v)
+	}
+	return ret
+}
+
+func GetLoseItem(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_GUESS_COLOR_TEMPLATE, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "ItemCost")
+}
+
+func GetFirstItem(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_GUESS_COLOR_TEMPLATE, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "FirstItem")
+}
+
+func GetActivityItemId(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_GUESS_COLOR_TEMPLATE, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "ItemId")
+}
+
+func GetRewardItem(Id int, Type int) []*item.Item {
+	data, err := gamedata.GetData(CFG_GUESS_COLOR_REWARD)
+	if err != nil {
+		return nil
+	}
+	for k, v := range data {
+		min := GoUtil.Int(k)
+		max := gamedata.GetIntValue(v, "Max")
+		if Id >= min && Id <= max {
+			if Type == 1 {
+				return gamedata.GetItemList(v, "Items1")
+			}
+			return gamedata.GetItemList(v, "Items2")
+		}
+	}
+	return nil
+}
+
+func GetPassNum(Id int) int {
+	data, err := gamedata.GetData(CFG_GUESS_COLOR_REWARD)
+	if err != nil {
+		return 0
+	}
+	for k, v := range data {
+		min := GoUtil.Int(k)
+		max := gamedata.GetIntValue(v, "Max")
+		if Id >= min && Id <= max {
+			return gamedata.GetIntValue(v, "Num")
+		}
+	}
+	return 0
+}
+
+func GetWinTime(Id int) int {
+	data, err := gamedata.GetData(CFG_GUESS_COLOR_REWARD)
+	if err != nil {
+		return 0
+	}
+	for k, v := range data {
+		min := GoUtil.Int(k)
+		max := gamedata.GetIntValue(v, "Max")
+		if Id >= min && Id <= max {
+			Type := gamedata.GetIntValue(v, "Type")
+			if Type == 1 {
+				return gamedata.GetIntValue(v, "Win")
+			}
+			str := gamedata.GetStringValue(v, "Win")
+			arr := strings.Split(str, "|")
+			return GoUtil.RandNum(GoUtil.Int(arr[0]), GoUtil.Int(arr[1]))
+		}
+	}
+	return 0
+}

src/server/conf/guide/guideCfg.go

@@ -1,4 +1,4 @@
-package guildCfg
+package guidecfg
 
 import (
 	"server/game/mod/item"
@@ -7,15 +7,15 @@ import (
 )
 
 const (
-	GUILD_REWARD = "GuildReward"
+	GUIDE_REWARD = "GuideReward"
 )
 
 func init() {
-	gamedata.InitCfg(GUILD_REWARD)
+	gamedata.InitCfg(GUIDE_REWARD)
 }
 
-func GetGuildReward(Id int) ([]*item.Item, int) {
-	data, err := gamedata.GetDataByIntKey(GUILD_REWARD, Id)
+func GetGuideReward(Id int) ([]*item.Item, int) {
+	data, err := gamedata.GetDataByIntKey(GUIDE_REWARD, Id)
 	if err != nil {
 		log.Debug("GuildCfg GetGuildReward Id:%v not found", Id)
 		return nil, 0

src/server/conf/guideTask/GuideTaskCfg.go

@@ -0,0 +1,107 @@
+package GuideTaskCfg
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	"server/gamedata"
+	"server/pkg/github.com/name5566/leaf/log"
+	"strconv"
+)
+
+const (
+	GUIDE_TASK_CONST  = "GuideTaskConst"
+	GUIDE_TASK_TASK   = "GuideTaskTask"
+	GUIDE_TASK_ACTIVE = "GuideTaskActive"
+)
+
+func init() {
+	gamedata.InitCfg(GUIDE_TASK_CONST)
+	gamedata.InitCfg(GUIDE_TASK_TASK)
+	gamedata.InitCfg(GUIDE_TASK_ACTIVE)
+}
+
+func GetTaskRewardById(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(GUIDE_TASK_TASK, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "Items")
+}
+
+func GetTaskById(Id int) string {
+	data, err := gamedata.GetDataByIntKey(GUIDE_TASK_TASK, Id)
+	if err != nil {
+		return ""
+	}
+	return gamedata.GetStringValue(data, "Task")
+}
+
+func GetTaskActive(Id int) int {
+	data, err := gamedata.GetDataByIntKey(GUIDE_TASK_TASK, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Active")
+}
+func GetUnlock(Id int) int {
+	data, err := gamedata.GetDataByIntKey(GUIDE_TASK_TASK, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Unlock")
+}
+
+func GetActiveReward(Id int) ([]*item.Item, int) {
+	data, err := gamedata.GetDataByIntKey(GUIDE_TASK_ACTIVE, Id)
+	if err != nil {
+		return nil, 0
+	}
+	return gamedata.GetItemList(data, "Items"), gamedata.GetIntValue(data, "Active")
+}
+func GetActiveReward2(reward []int, Active int) []*item.Item {
+	data, err := gamedata.GetData(GUIDE_TASK_ACTIVE)
+	if err != nil {
+		return nil
+	}
+	for k, v := range data {
+		active := gamedata.GetIntValue(v, "Active")
+		if active < Active {
+			continue
+		}
+		if GoUtil.InArray(GoUtil.Int(k), reward) {
+			continue
+		}
+		return gamedata.GetItemList(v, "Items")
+	}
+	return nil
+}
+
+func GetUnlockLv() int {
+	data, err := gamedata.GetDataByKey(GUIDE_TASK_CONST, "UnlockLv")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetDays() int {
+	data, err := gamedata.GetDataByKey(GUIDE_TASK_CONST, "Days")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetTaskList(Lv int) map[int]string {
+	r := make(map[int]string)
+	data, err := gamedata.GetData(GUIDE_TASK_TASK)
+	if err != nil {
+		log.Debug("GetTaskList get data nil")
+		return r
+	}
+	for k, v := range data {
+		k1, _ := strconv.Atoi(k)
+		r[k1] = gamedata.GetStringValue(v, "Task")
+	}
+	return r
+}

src/server/conf/guideTask/GuideTaskCfg_test.go

@@ -0,0 +1,51 @@
+package GuideTaskCfg
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestGuideTaskCfg_NoPanic(t *testing.T) {
+	ids := []int{-1, 0, 1, 999999}
+	for _, id := range ids {
+		t.Run(fmt.Sprintf("Id=%d", id), func(t *testing.T) {
+			defer func() {
+				if r := recover(); r != nil {
+					t.Fatalf("unexpected panic: %v", r)
+				}
+			}()
+			_ = GetTaskRewardById(id)
+			_ = GetTaskActive(id)
+			_, _ = GetActiveReward(id)
+		})
+	}
+	_ = GetUnlockLv()
+	_ = GetDays()
+}
+
+// 以下 Example 用于文档与编译校验（无固定输出校验）
+
+func ExampleGetTaskRewardById() {
+	_ = GetTaskRewardById(1)
+	// Output:
+}
+
+func ExampleGetTaskActive() {
+	_ = GetTaskActive(1)
+	// Output:
+}
+
+func ExampleGetActiveReward() {
+	_, _ = GetActiveReward(1)
+	// Output:
+}
+
+func ExampleGetUnlockLv() {
+	_ = GetUnlockLv()
+	// Output:
+}
+
+func ExampleGetDays() {
+	_ = GetDays()
+	// Output:
+}

src/server/conf/handbook/handbookCfg.go

@@ -0,0 +1,35 @@
+package handbookCfg
+
+import (
+	"server/game/mod/item"
+	"server/gamedata"
+	"server/pkg/github.com/name5566/leaf/log"
+)
+
+const (
+	CFG_HANDBOOK       = "Handbook"
+	CFG_HANDBOOK_CONST = "HandbookConst"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_HANDBOOK)
+	gamedata.InitCfg(CFG_HANDBOOK_CONST)
+}
+
+func GetHandbookReward(Type string) []*item.Item {
+	data, err := gamedata.GetDataByKey(CFG_HANDBOOK, Type)
+	if err != nil {
+		log.Debug("GetHandbookReward err:%v", err)
+		return nil
+	}
+	return gamedata.GetItemList(data, "Items")
+}
+
+func GetHandbookCollectReward() []*item.Item {
+	data, err := gamedata.GetDataByKey(CFG_HANDBOOK_CONST, "collect_item")
+	if err != nil {
+		log.Debug("GetHandbookCollectReward err:%v", err)
+		return nil
+	}
+	return gamedata.GetItemList(data, "Value")
+}

src/server/conf/invite/inviteCfg.go

@@ -0,0 +1,23 @@
+package inviteCfg
+
+import (
+	"server/game/mod/item"
+	"server/gamedata"
+)
+
+const (
+	CFG_INVITE = "Invite"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_INVITE)
+}
+
+func GetInviteReward(index int) (int, []*item.Item) {
+	data, err := gamedata.GetDataByIntKey(CFG_INVITE, index)
+	if err != nil {
+		return 0, nil
+	}
+	return gamedata.GetIntValue(data, "Need"), gamedata.GetItemList(data, "Items")
+
+}

src/server/conf/item/ItemCfg.go

@@ -1,7 +1,9 @@
 package itemCfg
 
 import (
+	languageCfg "server/conf/language"
 	"server/gamedata"
+	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 	"strconv"
 	"strings"
@@ -46,3 +48,12 @@ func GetItemEffectList(Id int) []int {
 	}
 	return res
 }
+
+func GetItemName(Id int) (string, string) {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
+	if err != nil {
+		log.Debug("ItemCfg GetItemName Id:%v not found", Id)
+		return "", ""
+	}
+	return languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, gamedata.GetStringValue(data, "Name")), languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, gamedata.GetStringValue(data, "Name"))
+}

src/server/conf/json.go

@@ -9,6 +9,8 @@ import (
 )
 
 var Server struct {
+	AppID       int
+	AppPath     string
 	LogLevel    string
 	LogPath     string
 	WSAddr      string
@@ -28,6 +30,7 @@ var Server struct {
 	RedisAddr string
 	RedisPort string
 	RedisPwd  string
+	RedisDb   int
 
 	GameName   string
 	ServerType string
@@ -41,11 +44,25 @@ var Server struct {
 	CenterAddr string
 
 	RemoteAddr   string
+	GameConfPath string
+	TELOGDIR     string
+	GoogleVerify bool
+	Partition    int
+	KafkaHost    string
+	KafkaPort    string
+	Version      string
+	CountryCode  string
+	IdVerify     bool
 }
 
 func init() {
-	// data, err := ioutil.ReadFile("conf/server.json")
-	file, err := os.Open("conf/server.json")
+	filePath := "conf/server.json"
+	if len(os.Args) == 2 {
+		if os.Args[1] != "" {
+			filePath = os.Args[1]
+		}
+	}
+	file, err := os.Open(filePath)
 	if err != nil {
 		panic(err)
 	}

src/server/conf/language/languageCfg.go

@@ -0,0 +1,27 @@
+package languageCfg
+
+import (
+	"server/gamedata"
+	"server/msg"
+)
+
+const (
+	CFG_LANGUAGE = "LanguageData"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_LANGUAGE)
+}
+
+func GetLanguage(lang msg.LANG_TYPE, key string) string {
+	data, err := gamedata.GetDataByKey(CFG_LANGUAGE, key)
+	if err != nil {
+		return key
+	}
+	switch lang {
+	case msg.LANG_TYPE_LANG_EN:
+		return gamedata.GetStringValue(data, "English")
+	default:
+		return key
+	}
+}

src/server/conf/limitedTimeEvent/LimitedTimeEventCfg.go

@@ -5,7 +5,7 @@ import (
 	"server/game/mod/item"
 	"server/gamedata"
 	"server/pkg/github.com/name5566/leaf/log"
-	"strconv"
+	"sort"
 	"strings"
 )
 
@@ -18,7 +18,12 @@ const (
 	CFG_LIMITED_TIME_EVENT_SENCE_JACKPOT = "LimitedTimeEventSenceJackpot"
 	CFG_LIMITED_TIME_EVENT_FAST          = "LimitedTimeEventFast"
 	CFG_LIMITED_TIME_EVENT_JACKPOT       = "LimitedTimeEventJackpot"
+	CFG_LIMITED_TIME_EVENT_CHEST_JACKPOT = "LimitedTimeEventChestJackpot"
 	CFG_LIMITED_TIME_EVENT_CONST         = "LimitedTimeEventConst"
+	CFG_LIMITED_TIME_EVENT_BONUS         = "LimitedTimeEventBonus"
+	CFG_LIMITED_TIME_EVENT_MONEY         = "LimitedTimeEventMoney"
+	CFG_LIMITED_TIME_EVENT_LUCKY         = "LimitedTimeEventLucky"
+	CFG_LIMITED_TIME_EVENT_CAT_TRICK     = "LimitedTimeEventCatTrick"
 )
 
 func init() {
@@ -31,31 +36,25 @@ func init() {
 	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_FAST)
 	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_JACKPOT)
 	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_CONST)
+	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_BONUS)
+	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_CHEST_JACKPOT)
+	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_MONEY)
+	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_LUCKY)
+	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_CAT_TRICK)
 }
 
 // 获取限时事件触发列表
 func GetLimitedTimeEventCfg() []*gamedata.LimitedTimeEventData {
-	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT)
-	if err != nil {
-		log.Debug("GetLimitedTimeEventCfg err:%v", err)
 	return nil
+}
+
+func GetEventName(Id int) string {
+	data, err := gamedata.GetDataByIntKey(CFG_LIMITED_TIME_EVENT, Id)
+	if err != nil {
+		log.Debug("GetEventName err:%v", err)
+		return ""
 	}
-	var res []*gamedata.LimitedTimeEventData
-	Day, Hour := GoUtil.GetWeekdayAndHour()
-	for k, v := range data {
-		weekDay := gamedata.GetIntValue(v, "WeekDay")
-		startTime := gamedata.GetIntValue(v, "StartTime")
-		endTime := gamedata.GetIntValue(v, "EndTime")
-		if weekDay == Day && Hour >= startTime && Hour < endTime {
-			Id, _ := strconv.Atoi(k)
-			res = append(res, &gamedata.LimitedTimeEventData{
-				Id:       Id,
-				EventId:  gamedata.GetIntValue(v, "EventId"),
-				Duration: int64(gamedata.GetIntValue(v, "Duration")),
-			})
-		}
-	}
-	return res
+	return gamedata.GetStringValue(data, "Name")
 }
 
 // 获取流星雨加成
@@ -75,6 +74,7 @@ func GetChestReward(Star int) []*item.Item {
 		log.Debug("GetChestReward err:%v", err)
 		return nil
 	}
+
 	for _, v := range data {
 		Min := gamedata.GetIntValue(v, "Min")
 		Max := gamedata.GetIntValue(v, "Max")
@@ -83,6 +83,7 @@ func GetChestReward(Star int) []*item.Item {
 		}
 	}
 	return nil
+
 }
 
 // 获取超级订单奖励
@@ -117,6 +118,7 @@ func GetSceneDashReward(Sence, Progress int) (int, []*item.Item) {
 	return 0, nil
 }
 
+// 获取场景冲刺奖池
 func GetSenceJackpotProb() map[int]int {
 	r := make(map[int]int)
 	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_SENCE_JACKPOT)
@@ -131,6 +133,7 @@ func GetSenceJackpotProb() map[int]int {
 	return r
 }
 
+// 获取场景冲刺奖励
 func GetSenceJackpotReward(Id int) []*item.Item {
 	data, err := gamedata.GetDataByIntKey(CFG_LIMITED_TIME_EVENT_SENCE_JACKPOT, Id)
 	if err != nil {
@@ -155,15 +158,60 @@ func GetFastProduceReward(Times, Energy int) []*item.Item {
 	return nil
 }
 
-func GetProgressMax() int {
-	data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "Progress_max")
+// 获取连击快手最大次数
+func GetFastProduceMaxTimes() int {
+	Max := 0
+	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_FAST)
+	if err != nil {
+		log.Debug("GetSceneDashReward err:%v", err)
+		return 0
+	}
+	for _, v := range data {
+		Max = max(gamedata.GetIntValue(v, "Times"), Max)
+	}
+	return Max
+}
+
+// 获取进度最大值
+func GetProgressMax(Lv, Num int) int {
+	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_BONUS)
 	if err != nil {
 		log.Debug("GetProgressMax err:%v", err)
 		return 0
 	}
-	return gamedata.GetIntValue(data, "value")
+	for _, v := range data {
+		Min := gamedata.GetIntValue(v, "Min")
+		Max := gamedata.GetIntValue(v, "Max")
+		if Lv >= Min && Lv <= Max {
+			OrderNumStr := gamedata.GetStringValue(v, "OrderNum")
+			OrderNum := GoUtil.SplitInt(OrderNumStr, ",")
+			if Num >= len(OrderNum) {
+				return OrderNum[len(OrderNum)-1]
+			} else {
+				return OrderNum[Num]
+			}
+		}
+	}
+	return 0
 }
 
+func GetBonusLv(Lv int) int {
+	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_BONUS)
+	if err != nil {
+		log.Debug("GetProgressMax err:%v", err)
+		return 0
+	}
+	for k, v := range data {
+		Min := gamedata.GetIntValue(v, "Min")
+		Max := gamedata.GetIntValue(v, "Max")
+		if Lv >= Min && Lv <= Max {
+			return GoUtil.Int(k)
+		}
+	}
+	return 0
+}
+
+// 获取进度奖励随机
 func GetProgressRewardRand(Lv int) map[int]int {
 	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_JACKPOT)
 	if err != nil {
@@ -172,7 +220,7 @@ func GetProgressRewardRand(Lv int) map[int]int {
 	}
 	r := make(map[int]int)
 	for k, v := range data {
-		if Lv >= gamedata.GetIntValue(v, "Min") && Lv <= gamedata.GetIntValue(v, "Max") {
+		if Lv >= gamedata.GetIntValue(v, "BonusLv") {
 			Id := GoUtil.Int(k)
 			r[Id] = gamedata.GetIntValue(v, "Prob")
 		}
@@ -180,29 +228,39 @@ func GetProgressRewardRand(Lv int) map[int]int {
 	return r
 }
 
-func GetProgressSelectNum(Lv int) int {
-	data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "Progress_lv_num")
+func GetJackpotIdByType(Type int) int {
+	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_JACKPOT)
 	if err != nil {
-		log.Debug("GetProgressSelectNum err:%v", err)
+		log.Debug("GetJackpotIdByType err:%v", err)
 		return 0
 	}
-	Str := gamedata.GetStringValue(data, "value")
-	Strarr := strings.Split(Str, ";")
-	for _, v := range Strarr {
-		a := strings.Split(v, ",")
-		if len(a) != 3 {
-			continue
-		}
-		Min, _ := strconv.Atoi(a[0])
-		Max, _ := strconv.Atoi(a[1])
-		if Lv >= Min && Lv <= Max {
-			Num, _ := strconv.Atoi(a[2])
-			return Num
+	for k, v := range data {
+		Id := GoUtil.Int(k)
+		if Type == gamedata.GetIntValue(v, "Type") {
+			return Id
 		}
 	}
 	return 0
 }
 
+// 获取进度选择数量
+func GetProgressSelectNum(Lv int) int {
+	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_BONUS)
+	if err != nil {
+		log.Debug("GetProgressMax err:%v", err)
+		return 0
+	}
+	for _, v := range data {
+		Min := gamedata.GetIntValue(v, "Min")
+		Max := gamedata.GetIntValue(v, "Max")
+		if Lv >= Min && Lv <= Max {
+			return gamedata.GetIntValue(v, "Option")
+		}
+	}
+	return 0
+}
+
+// 获取进度奖励
 func GetProgressReward(RewardId int) []*item.Item {
 	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_JACKPOT)
 	if err != nil {
@@ -217,3 +275,145 @@ func GetProgressReward(RewardId int) []*item.Item {
 	}
 	return nil
 }
+
+// 获取进度奖励类型
+func GetProgressRewardType(RewardId int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_LIMITED_TIME_EVENT_JACKPOT, RewardId)
+	if err != nil {
+		log.Debug("GetProgressReward err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Type")
+}
+
+func GetUnlockLv() int {
+	data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "unlock_lv")
+	if err != nil {
+		log.Debug("GetUnlockLv err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetFirstEvent() int {
+	data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "First_Event")
+	if err != nil {
+		log.Debug("GetFirstEvent err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetFastCD() int {
+	data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "Fast_Cd")
+	if err != nil {
+		log.Debug("GetFirstEvent err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetPaybackDay() int {
+	data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "payback_day")
+	if err != nil {
+		log.Debug("GetPaybackDay err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetHighRollerNeedEnergy() int {
+	data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "High_Roller_Need_Energy")
+	if err != nil {
+		log.Debug("GetHighRollerNeedEnergy err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetThiefProb() int {
+	data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "Thief_Prob")
+	if err != nil {
+		log.Debug("GetThiefProb err:%v", err)
+		return 0
+	}
+	value := gamedata.GetStringValue(data, "Value")
+	a1 := strings.Split(value, "|")
+	prob := make(map[int]int)
+	for _, v := range a1 {
+		a2 := strings.Split(v, ":")
+		prob[GoUtil.Int(a2[0])] = GoUtil.Int(a2[1])
+	}
+	return GoUtil.RandMap(prob)
+}
+
+// 招财猫
+
+func GetMoneyCat(Id int) (float64, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_LIMITED_TIME_EVENT_MONEY, Id)
+	if err != nil {
+		log.Debug("GetMul err:%v", err)
+		return 0.0, 0
+	}
+	return gamedata.GetFloatValue(data, "Mul"), gamedata.GetIntValue(data, "Cd")
+}
+
+func GetMoneyCatMax() int {
+	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_MONEY)
+	if err != nil {
+		log.Debug("GetMul err:%v", err)
+		return 0
+	}
+	return len(data)
+}
+
+func GetLuckyCatMaxEarning(Remain int) int {
+	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_LUCKY)
+	if err != nil {
+		log.Debug("GetMul err:%v", err)
+		return 0
+	}
+	type d struct {
+		t int
+		e int
+	}
+	l := make([]d, 0)
+	for k, v := range data {
+		t := GoUtil.Int(k)
+		e := gamedata.GetIntValue(v, "Earn")
+		l = append(l, d{t, e})
+	}
+	sort.Slice(l, func(i, j int) bool {
+		return l[i].t < l[j].t
+	})
+	for _, v := range l {
+		if Remain <= v.t {
+			return v.e
+		}
+	}
+	return 0
+}
+
+func GetCatTrickType(Duartion int) int {
+	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_CAT_TRICK)
+	if err != nil {
+		log.Debug("GetCatTrick err:%v", err)
+		return 1
+	}
+	for k, v := range data {
+		D := gamedata.GetIntValue(v, "Duration")
+		if Duartion == D {
+			return GoUtil.Int(k)
+		}
+	}
+	return gamedata.GetIntValue(data, "Type")
+}
+
+func GetCatTrickDiamond(Type int) (int, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_LIMITED_TIME_EVENT_CAT_TRICK, Type)
+	if err != nil {
+		log.Debug("GetCatTrickDiamond err:%v", err)
+		return 0, 0
+	}
+	return gamedata.GetIntValue(data, "Diamond"), gamedata.GetIntValue(data, "Energy")
+}

src/server/conf/mail/mailCfg.go

@@ -0,0 +1,112 @@
+package mailCfg
+
+import (
+	"fmt"
+	"server/GoUtil"
+	languageCfg "server/conf/language"
+	"server/game/mod/item"
+	"server/gamedata"
+	"server/msg"
+	"strings"
+)
+
+const (
+	CFG_LOGIN_BACK = "LoginBack"
+	CFG_MAIL       = "Mail"
+
+	MAIL_RECALL_ID         = 12
+	MAIL_CHARGE_SEND_ID    = 13
+	MAIL_CHARGE_RECEIVE_ID = 14
+)
+
+type TriggerMail struct {
+	Id             int
+	Title          string
+	SubTitle       string
+	Content        string
+	EnglistTitle   string
+	SubTitleEn     string
+	EnglistContent string
+	Items          []*item.Item
+	Type           int
+	Trigger        []string
+}
+
+func init() {
+	gamedata.InitCfg(CFG_LOGIN_BACK)
+	gamedata.InitCfg(CFG_MAIL)
+}
+
+func GetLoginBack(Id string) (int, int) {
+	data, err := gamedata.GetDataByKey(CFG_LOGIN_BACK, Id)
+	if err != nil {
+		return 0, 0
+	}
+	return gamedata.GetIntValue(data, "Num1"), gamedata.GetIntValue(data, "Num2")
+}
+
+func GetTriggerMail() []*TriggerMail {
+	data, err := gamedata.GetData(CFG_MAIL)
+	if err != nil {
+		return nil
+	}
+	ret := make([]*TriggerMail, 0)
+	for k, v := range data {
+		T := gamedata.GetStringValue(v, "Trigger")
+		if T == "" {
+			continue
+		}
+		T1 := strings.Split(T, "|")
+		if len(T1) < 4 {
+			continue
+		}
+		data := &TriggerMail{
+			Id:             GoUtil.Int(k),
+			Title:          gamedata.GetStringValue(v, "Title"),
+			Content:        gamedata.GetStringValue(v, "Content"),
+			EnglistTitle:   gamedata.GetStringValue(v, "EnglistTitle"),
+			EnglistContent: gamedata.GetStringValue(v, "EnglistContent"),
+			Items:          gamedata.GetItemList(v, "Items"),
+			Type:           gamedata.GetIntValue(v, "Type"),
+			Trigger:        strings.Split(T, "|"),
+		}
+		ret = append(ret, data)
+	}
+	return ret
+}
+
+func GetRecallMail(Title, ItemName, TitleEn, ItemNameEn string) (string, string, string, string) {
+	data, err := gamedata.GetDataByIntKey(CFG_MAIL, 12)
+	if err != nil {
+		return "", "", "", ""
+	}
+	mt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, gamedata.GetStringValue(data, "Title"))
+	mc := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, gamedata.GetStringValue(data, "Content"))
+	mt_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, gamedata.GetStringValue(data, "Title"))
+	mc_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, gamedata.GetStringValue(data, "Content"))
+	return fmt.Sprintf(mt, Title), fmt.Sprintf(mc, Title, ItemName), fmt.Sprintf(mt_en, TitleEn), fmt.Sprintf(mc_en, Title, ItemNameEn)
+}
+
+func GetChargeSendMail(PlayerName string) (string, string, string, string) {
+	data, err := gamedata.GetDataByIntKey(CFG_MAIL, MAIL_CHARGE_SEND_ID)
+	if err != nil {
+		return "", "", "", ""
+	}
+	mt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, gamedata.GetStringValue(data, "Title"))
+	mc := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, gamedata.GetStringValue(data, "Content"))
+	mt_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, gamedata.GetStringValue(data, "Title"))
+	mc_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, gamedata.GetStringValue(data, "Content"))
+	return mt, fmt.Sprintf(mc, PlayerName), mt_en, fmt.Sprintf(mc_en, PlayerName)
+}
+
+func GetChargeReceiveMail(PlayerName string, Content string) (string, string, string, string) {
+	data, err := gamedata.GetDataByIntKey(CFG_MAIL, MAIL_CHARGE_RECEIVE_ID)
+	if err != nil {
+		return "", "", "", ""
+	}
+	mt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, gamedata.GetStringValue(data, "Title"))
+	mc := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, gamedata.GetStringValue(data, "Content"))
+	mt_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, gamedata.GetStringValue(data, "Title"))
+	mc_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, gamedata.GetStringValue(data, "Content"))
+	return fmt.Sprintf(mt, PlayerName), fmt.Sprintf(mc, Content), fmt.Sprintf(mt_en, PlayerName), fmt.Sprintf(mc_en, Content)
+}

src/server/conf/mergeData/MergeDataCfg.go

@@ -2,6 +2,8 @@ package mergeDataCfg
 
 import (
 	"errors"
+	"server/GoUtil"
+	"server/game/mod/item"
 	"server/gamedata"
 	"server/pkg/github.com/name5566/leaf/log"
 	"strconv"
@@ -11,16 +13,63 @@ import (
 const (
 	CFG_NAME            = "MergeData"
 	CONST_NAME          = "MergeDataConst"
+	CFG_MERGE_EMIT      = "MergeDataEmit"
+	CFG_MERGE_EMIT_TYPE = "MergeDataEmitType"
+	CFG_MERGE_COLOR     = "MergeDataColor"
 
 	// 棋子类型
 	CHESS_PRODUCT_MAIN_TYPE      = 1 // 主产物
-	CHESS_PRODUCT_SUB_TYPE      = 2 // 次产物
-	CHESS_PRODUCT_SUB_EMIT_TYPE = 3 // 次发射器产物
+	CHESS_PRODUCT_SECONDARY_TYPE = 2 // 次产物
+	CHESS_PRODUCT_SUB_TYPE       = 3 // 子发射器产物
 )
 
 func init() {
 	gamedata.InitCfg(CFG_NAME)
 	gamedata.InitCfg(CONST_NAME)
+	gamedata.InitCfg(CFG_MERGE_EMIT)
+	gamedata.InitCfg(CFG_MERGE_EMIT_TYPE)
+	gamedata.InitCfg(CFG_MERGE_COLOR)
+}
+
+func GetEmitTypeProduce(EmitType string) []string {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT_TYPE, EmitType)
+	if err != nil {
+		// log.Debug("GetEmitTypeProduce GetOne EmitType:%s not found", EmitType)
+		return []string{}
+	}
+	return strings.Split(gamedata.GetStringValue(data, "Produce"), ",")
+}
+
+func GetEmitTypeByColor(Color string) string {
+	data, err := gamedata.GetData(CFG_MERGE_EMIT)
+	if err != nil {
+		return ""
+	}
+	for k, v := range data {
+		ColorList := strings.Split(gamedata.GetStringValue(v, "Order_Type"), ",")
+		if GoUtil.InStringArray(Color, ColorList) {
+			return k
+		}
+	}
+	return ""
+}
+
+func GetEmitProduce(EmitType string) []string {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, EmitType)
+	if err != nil {
+		log.Debug("GetEmitProduce GetOne EmitType:%s not found", EmitType)
+		return []string{}
+	}
+	return strings.Split(gamedata.GetStringValue(data, "Product_Type"), ",")
+}
+
+func GetEmitOrderProduce(EmitType string) []string {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, EmitType)
+	if err != nil {
+		log.Debug("GetEmitProduce GetOne EmitType:%s not found", EmitType)
+		return []string{}
+	}
+	return strings.Split(gamedata.GetStringValue(data, "Order_Type"), ",")
 }
 
 // 获取单个数据
@@ -55,6 +104,15 @@ func GetStarById(Id int) int {
 	return gamedata.ParseInt(data["Star"])
 }
 
+func GetNameById(Id int) string {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
+	if err != nil {
+		log.Debug("MergeDataCfg GetOne Id:%v not found", Id)
+		return ""
+	}
+	return gamedata.GetStringValue(data, "Title")
+}
+
 // 根据等级和颜色获取棋子id
 func GetChessIdByLvAndColor(Lv int, Color string) int {
 	if Lv == 0 || Color == "" {
@@ -62,7 +120,7 @@ func GetChessIdByLvAndColor(Lv int, Color string) int {
 	}
 	data, err := gamedata.GetData(CFG_NAME)
 	if err != nil {
-		log.Debug("MergeDataCfg GetChessIdByLvAndColor lv:%v Color:%v not found", Lv, Color)
+		// log.Debug("MergeDataCfg GetChessIdByLvAndColor lv:%v Color:%v not found", Lv, Color)
 		return 0
 	}
 	for k, v := range data {
@@ -73,6 +131,7 @@ func GetChessIdByLvAndColor(Lv int, Color string) int {
 			return Id
 		}
 	}
+	// log.Debug("MergeDataCfg GetChessIdByLvAndColor lv:%v Color:%v not found", Lv, Color)
 	return 0
 }
 
@@ -96,6 +155,60 @@ func GetMaxLvById(Id int) int {
 	return gamedata.ParseInt(data["MaxLv"])
 }
 
+// 根据Id获取棋子最大等级
+func GetMaxLvByColor(Color string) int {
+	ChessId := GetChessIdByLvAndColor(1, Color)
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, ChessId)
+	if err != nil {
+		return 0
+	}
+	return gamedata.ParseInt(data["MaxLv"])
+}
+
+// 根据Id获取发射器最小等级
+func GetEmitMinLvById(Id string) int {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, Id)
+	if err != nil {
+		log.Debug("GetEmitMinLvById GetOne Id:%v not found", Id)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Emit_Min_Lv")
+}
+
+// 根据Id获取发射器修正系数
+func GetEmitRatio(Id string) float64 {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, Id)
+	if err != nil {
+		log.Debug("GetEmitRatio GetOne Id:%v not found", Id)
+		return 0
+	}
+	return gamedata.GetFloatValue(data, "Ratio")
+}
+
+func GetEmitRetire(Id string) int {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, Id)
+	if err != nil {
+		log.Debug("GetEmitRetire GetOne Id:%v not found", Id)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Retire")
+}
+
+func GetEmitProductNumByColor(Id string) int {
+	data, err := gamedata.GetData(CFG_MERGE_EMIT)
+	if err != nil {
+		log.Debug("GetEmitProductNumByColor GetOne Id:%v not found", Id)
+		return 0
+	}
+	for _, v := range data {
+		ColorList := strings.Split(gamedata.GetStringValue(v, "Product_Type"), ",")
+		if GoUtil.InStringArray(Id, ColorList) {
+			return len(strings.Split(gamedata.GetStringValue(v, "Product_Type"), ","))
+		}
+	}
+	return 0
+}
+
 // 根据Id获取棋子类型
 func GetTypeById(Id int) string {
 	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
@@ -116,26 +229,80 @@ func GetColorById(Id int) string {
 	return gamedata.ParseString(data["Color"])
 }
 
+// 根据Id获取棋子类型
+func GetSellNumById(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
+	if err != nil {
+		log.Debug("GetSellNumById GetOne Id:%v not found", Id)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "SellNum")
+}
+
 // 根据Id获取发射器产出类型
 func GetEmitProduceType(Id int) []string {
 	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
 	if err != nil {
-		log.Debug("GetTypeById GetOne Id:%v not found", Id)
+		log.Debug("GetEmitProduceType GetOne Id:%v not found", Id)
 		return []string{}
 	}
 	return strings.Split(gamedata.ParseString(data["Emit_Product"]), ",")
 }
 
+// 根据Id获取发射器产出类型
+func GetEmitProduceChessType(Id int) []string {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
+	if err != nil {
+		//log.Debug("GetEmitProduceChessType GetOne Id:%v not found", Id)
+		return []string{}
+	}
+	value := gamedata.ParseString(data["Product_Type"])
+	if value == "" {
+		return []string{}
+	}
+	return strings.Split(value, ",")
+}
+
 // 根据Id获取发射器Id
 func GetEmitId(Id int) string {
 	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
 	if err != nil {
-		log.Debug("GetTypeById GetOne Id:%v not found", Id)
+		log.Debug("GetEmitId GetOne Id:%v not found", Id)
 		return ""
 	}
 	return gamedata.ParseString(data["Emit_ID"])
 }
 
+func GetAllId() []int {
+	data, err := gamedata.GetData(CFG_NAME)
+	if err != nil {
+		return []int{}
+	}
+	key := make([]int, 0)
+	for k := range data {
+		key = append(key, GoUtil.Int(k))
+	}
+	return key
+}
+
+func GetEmitType(Id int) string {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
+	if err != nil {
+		log.Debug("GetEmitType GetOne Id:%v not found", Id)
+		return ""
+	}
+	return gamedata.ParseString(data["Emit_Type"])
+}
+
+func GetEmitN(EmitSeries string) int {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, EmitSeries)
+	if err != nil {
+		log.Debug("GetEmitN GetOne EmitSeries:%v not found", EmitSeries)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "N")
+}
+
 // 获取常量
 func GetConst(Key string) string {
 	data, err := gamedata.GetDataByKey(CONST_NAME, Key)
@@ -166,15 +333,6 @@ func GetExtraEmitId() map[string]struct{} {
 	return r
 }
 
-func GetProductType(Chess int) int {
-	data, err := gamedata.GetDataByIntKey(CFG_NAME, Chess)
-	if err != nil {
-		log.Debug("GetProductType GetOne Id:%v not found", Chess)
-		return 0
-	}
-	return gamedata.ParseInt(data["PType"])
-}
-
 func GetChessBagMaxGrid() int {
 	return GetConstInt("chess_bag_max")
 }
@@ -186,3 +344,269 @@ func GetChessBagBugNum() int {
 func GetChessBagInitNum() int {
 	return GetConstInt("chess_bag_init")
 }
+
+func GetSourceChestItem() []*item.Item {
+	data, err := gamedata.GetDataByKey(CONST_NAME, "source_chest_reward")
+	if err != nil {
+		log.Debug("GetSourceChestItem GetOne not found")
+		return nil
+	}
+	Str := gamedata.ParseString(data["Value"])
+	A1 := strings.Split(Str, "|")
+	var r []*item.Item
+	if len(A1) < 2 {
+		return r
+	}
+	A2 := strings.Split(A1[0], "/")
+	A3 := GoUtil.StringToInt(A2)
+	A4 := GoUtil.RandSlice(A3)
+	r = append(r, item.NewItem(item.ITEM_DIAMOND_ID, A4))
+
+	B2 := strings.Split(A1[1], "/")
+	B3 := GoUtil.StringToInt(B2)
+	B4 := GoUtil.RandSlice(B3)
+	r = append(r, item.NewItem(item.ITEM_ENERGY_ID, B4))
+	return r
+}
+
+func GetHighSourceChestItem() []*item.Item {
+	data, err := gamedata.GetDataByKey(CONST_NAME, "high_source_chest_reward")
+	if err != nil {
+		log.Debug("GetHighSourceChestItem GetOne not found")
+		return nil
+	}
+	Str := gamedata.ParseString(data["Value"])
+	A1 := strings.Split(Str, "|")
+	var r []*item.Item
+	if len(A1) < 2 {
+		return r
+	}
+	A2 := strings.Split(A1[0], "/")
+	A3 := GoUtil.StringToInt(A2)
+	A4 := GoUtil.RandSlice(A3)
+	r = append(r, item.NewItem(item.ITEM_DIAMOND_ID, A4))
+
+	B2 := strings.Split(A1[1], "/")
+	B3 := GoUtil.StringToInt(B2)
+	B4 := GoUtil.RandSlice(B3)
+	r = append(r, item.NewItem(item.ITEM_ENERGY_ID, B4))
+	return r
+}
+func DynamicLevRev(Lv int, EmitId int, Color string) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
+	if err != nil {
+		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
+		return Lv
+	}
+	DynamicLv := gamedata.GetStringValue(data, "Dynamic")
+	if DynamicLv == "" {
+		return Lv
+	}
+	Arr := strings.Split(DynamicLv, ",")
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		if len(Arr2) != 2 {
+			continue
+		}
+		if Color == Arr2[0] {
+			NewLv, _ := strconv.Atoi(Arr2[1])
+			return Lv + NewLv
+		}
+	}
+	return Lv
+}
+func DynamicLev(Lv int, EmitId int, Color string) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
+	if err != nil {
+		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
+		return Lv
+	}
+	DynamicLv := gamedata.GetStringValue(data, "Dynamic")
+	if DynamicLv == "" {
+		return Lv
+	}
+	Arr := strings.Split(DynamicLv, ",")
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		if len(Arr2) != 2 {
+			continue
+		}
+		if Color == Arr2[0] {
+			NewLv, _ := strconv.Atoi(Arr2[1])
+			return Lv - NewLv
+		}
+	}
+	return Lv
+}
+func DynamicLev2(Lv int, EmitId int, Color1 string, Color2 string) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
+	if err != nil {
+		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
+		return Lv
+	}
+	DynamicLv := gamedata.GetStringValue(data, "Dynamic")
+	if DynamicLv == "" {
+		return Lv
+	}
+	Arr := strings.Split(DynamicLv, ",")
+	BaseLv := Lv
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		if len(Arr2) != 2 {
+			continue
+		}
+		if Color1 == Arr2[0] {
+			NewLv, _ := strconv.Atoi(Arr2[1])
+			BaseLv = Lv + NewLv
+		}
+	}
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		if len(Arr2) != 2 {
+			continue
+		}
+		if Color2 == Arr2[0] {
+			NewLv, _ := strconv.Atoi(Arr2[1])
+			return BaseLv - NewLv
+		}
+	}
+	return Lv
+}
+
+func DynamicAdjust(EmitId int, Color string) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
+	if err != nil {
+		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
+		return 0
+	}
+	DynamicLv := gamedata.GetStringValue(data, "Dynamic")
+	if DynamicLv == "" {
+		return 0
+	}
+	Arr := strings.Split(DynamicLv, ",")
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		if len(Arr2) != 2 {
+			continue
+		}
+		if Color == Arr2[0] {
+			NewLv, _ := strconv.Atoi(Arr2[1])
+			return NewLv
+		}
+	}
+	return 0
+}
+
+func GetAdjust(EmitId int, Color string) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
+	if err != nil {
+		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
+		return 0
+	}
+	AdjustLv := gamedata.GetStringValue(data, "Dynamic")
+	if AdjustLv == "" {
+		return 0
+	}
+	Arr := strings.Split(AdjustLv, ",")
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		if len(Arr2) != 2 {
+			continue
+		}
+		if Color == Arr2[0] {
+			NewLv, _ := strconv.Atoi(Arr2[1])
+			return NewLv
+		}
+	}
+	return 0
+}
+
+func GetSellDiamondMul(EmitId int, Color string) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
+	if err != nil {
+		log.Debug("GetSellDiamondMul GetOne EmitId:%v not found", EmitId)
+		return 0
+	}
+	ProductEmit := gamedata.GetStringValue(data, "Emit_Product")
+	if ProductEmit == "" {
+		return 1
+	}
+	Arr := strings.Split(ProductEmit, ",")
+	if Color == Arr[0] {
+		return 1
+	}
+	if !GoUtil.InStringArray(Color, Arr) {
+		return 1
+	}
+	Emit_List := gamedata.GetStringValue(data, "Emit_List")
+	MainProb := getColorProb(Emit_List, Arr[0])
+	SubProb := getColorProb(Emit_List, Color)
+	return int(MainProb / SubProb)
+}
+
+func getColorProb(Emit_List string, Color string) float64 {
+	Arr := strings.Split(Emit_List, ",")
+	Prob := 0.0
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		A1 := GoUtil.Int(Arr2[0])
+		A2, _ := strconv.ParseFloat(Arr2[1], 64)
+		A1Color := GetColorById(A1)
+		if A1Color != Color {
+			continue
+		}
+		Prob += A2 * float64(A1%10)
+	}
+	return Prob
+}
+
+func GetColorType(Color string) int {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_COLOR, Color)
+	if err != nil {
+		log.Debug("GetColorType GetOne Color:%s not found", Color)
+		return 0
+	}
+	Type := gamedata.GetStringValue(data, "Type")
+	switch Type {
+	case "main":
+		return CHESS_PRODUCT_MAIN_TYPE
+	case "secondary":
+		return CHESS_PRODUCT_SECONDARY_TYPE
+	case "sub":
+		return CHESS_PRODUCT_SUB_TYPE
+	}
+	return CHESS_PRODUCT_MAIN_TYPE
+}
+
+func GetMergeStar(MergeList []int) int {
+	Star := 0
+	for _, v := range MergeList {
+		Star += GetStarById(v)
+	}
+	return Star
+}
+
+func GetAllChessBySeries(Series string) []int {
+	data, err := gamedata.GetData(CFG_NAME)
+	ProductList := GetEmitProduce(Series)
+	if err != nil {
+		return []int{}
+	}
+	var r []int
+	for k, v := range data {
+		Type := gamedata.GetStringValue(v, "Type")
+		if Type == "Emitter" {
+			EmitId := gamedata.GetStringValue(v, "Emit_ID")
+			if EmitId == Series {
+				r = append(r, GoUtil.Int(k))
+			}
+		}
+		if Type == "Product" {
+			Color := gamedata.GetStringValue(v, "Color")
+			if GoUtil.InStringArray(Color, ProductList) {
+				r = append(r, GoUtil.Int(k))
+			}
+		}
+	}
+	return r
+}

src/server/conf/mining/miningCfg.go

@@ -0,0 +1,97 @@
+package miningCfg
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	"server/gamedata"
+	"strconv"
+	"strings"
+)
+
+const (
+	CFG_MINING_TEMPLATE = "MiningTemplate"
+	CFG_MINING_JACKPOT  = "MiningJackpot"
+	CFG_MINING_GEM      = "MiningGem"
+	CFG_MINING_PASS     = "MiningPass"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_MINING_TEMPLATE)
+	gamedata.InitCfg(CFG_MINING_JACKPOT)
+	gamedata.InitCfg(CFG_MINING_GEM)
+	gamedata.InitCfg(CFG_MINING_PASS)
+}
+
+func GetTemplate(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_MINING_TEMPLATE, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Template")
+}
+
+func GetActivityItemId(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_MINING_TEMPLATE, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "ItemId")
+}
+
+func GetLoseItem(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_MINING_TEMPLATE, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "ItemCost")
+}
+
+func GetPassArea(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_MINING_PASS, Id)
+	if err != nil {
+		return 0
+	}
+	Area := gamedata.GetStringValue(data, "Area")
+	strArr := strings.Split(Area, "*")
+	a, _ := strconv.Atoi(strArr[0])
+	b, _ := strconv.Atoi(strArr[1])
+	return a * b
+}
+
+func GetPassGem(Id int) []int {
+	data, err := gamedata.GetDataByIntKey(CFG_MINING_PASS, Id)
+	if err != nil {
+		return nil
+	}
+	Gem := gamedata.GetStringValue(data, "Gem")
+	strArr := strings.Split(Gem, "|")
+	result := make([]int, 0)
+	for _, v := range strArr {
+		a, _ := strconv.Atoi(v)
+		result = append(result, a)
+	}
+	return result
+}
+
+func GetRandItem() []*item.Item {
+	data, err := gamedata.GetData(CFG_MINING_JACKPOT)
+	if err != nil {
+		return nil
+	}
+	ProbMap := make(map[int]int)
+	for k, v := range data {
+		Id := GoUtil.Int(k)
+		ProbMap[Id] = gamedata.GetIntValue(v, "Prob")
+	}
+	RandId := GoUtil.RandMap(ProbMap)
+	Info, _ := gamedata.GetDataByIntKey(CFG_MINING_JACKPOT, RandId)
+	return gamedata.GetItemList(Info, "Items")
+}
+
+func GetPassItem(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_MINING_PASS, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "Items")
+}

src/server/conf/order/orderCfg.go

@@ -2,16 +2,55 @@ package orderCfg
 
 import (
 	"server/gamedata"
+	"sort"
+	"strconv"
 )
 
 const (
 	CFG_ORDER_DATA       = "OrderData"
 	CFG_ORDER_CHESS_DATA = "OrderChessData"
+	CFG_ORDER_NUM_DATA   = "OrderNumData"
+	CFG_START_ORDER      = "StartOrder"
+	CFG_CONST            = "OrderConst"
+	CFG_ORDER_SCENE      = "OrderScene"
+	CFG_ORDER_K          = "OrderK"
 )
 
 func init() {
 	gamedata.InitCfg(CFG_ORDER_DATA)
 	gamedata.InitCfg(CFG_ORDER_CHESS_DATA)
+	gamedata.InitCfg(CFG_ORDER_NUM_DATA)
+	gamedata.InitCfg(CFG_START_ORDER)
+	gamedata.InitCfg(CFG_CONST)
+	gamedata.InitCfg(CFG_ORDER_SCENE)
+	gamedata.InitCfg(CFG_ORDER_K)
+}
+
+func GetOrderK(Lv int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_ORDER_K, Lv)
+	if err != nil {
+		return 0
+	}
+	Energy := gamedata.GetIntValue(data, "Energy")
+	K := gamedata.GetFloatValue(data, "K")
+	a := float64(Energy)*K/10 + 0.5
+	return int(a) * 10
+}
+
+func GetOrderFactor(Scene int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_ORDER_SCENE, Scene)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Factor")
+}
+
+func GetEmitExtraOrder() string {
+	data, err := gamedata.GetDataByKey(CFG_CONST, "EmitId_Extra_Order")
+	if err != nil {
+		return ""
+	}
+	return gamedata.GetStringValue(data, "Value")
 }
 
 func GetLvMin(EnergyMul int) int {
@@ -23,16 +62,129 @@ func GetLvMin(EnergyMul int) int {
 }
 
 func GetLvMax(EnergyMul, N int) int {
-	if v, ok := gamedata.G_AllConfigsJsonData["OrderChessData"]; ok {
-		data := v.GetData()
+	data, err := gamedata.GetData(CFG_ORDER_CHESS_DATA)
+	if err != nil {
+		return 0
+	}
 	for _, v := range data {
 		dEnergy := gamedata.GetIntValue(v, "EnergyMul")
 		Min := gamedata.GetIntValue(v, "MinN")
 		Max := gamedata.GetIntValue(v, "MaxN")
-			if dEnergy == EnergyMul && N >= Min && N <= Max {
+		if dEnergy == EnergyMul {
+			if N >= Min && N <= Max {
 				return gamedata.GetIntValue(v, "MaxLv")
 			}
 		}
 	}
 	return 0
 }
+
+func GetOrderNum(Level int) int {
+	data, err := gamedata.GetData(CFG_ORDER_NUM_DATA)
+	if err != nil {
+		return 0
+	}
+	for _, v := range data {
+		Min := gamedata.GetIntValue(v, "Min")
+		Max := gamedata.GetIntValue(v, "Max")
+		if Level >= Min && Level <= Max {
+			return gamedata.GetIntValue(v, "Num")
+		}
+	}
+	return 0
+}
+
+func GetStartOrderInfo(Id int) (int, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_START_ORDER, Id)
+	if err != nil {
+		return -1, -1
+	}
+	return gamedata.GetIntValue(data, "group"), gamedata.GetIntValue(data, "step")
+}
+
+func GetStartOrderList() []*gamedata.StartOrderData {
+	ret := make([]*gamedata.StartOrderData, 0)
+	data, err := gamedata.GetData(CFG_START_ORDER)
+	if err != nil {
+		return ret
+	}
+	for k, v := range data {
+		OrderId, _ := strconv.Atoi(k)
+		ret = append(ret, &gamedata.StartOrderData{
+			Id:        OrderId,
+			MergeList: gamedata.GetIntSliceValue(v, "merge_id_list"),
+			Appear:    gamedata.GetStringValue(v, "appear"),
+			Preview:   gamedata.GetStringValue(v, "preview"),
+			Items:     gamedata.GetItemList(v, "reward"),
+			Group:     gamedata.GetIntValue(v, "group"),
+			Step:      gamedata.GetIntValue(v, "step"),
+		})
+	}
+	sort.Slice(ret, func(i, j int) bool {
+		return ret[i].Id < ret[j].Id
+	})
+	return ret
+}
+
+func GetStartOrderByStep(id int) []*gamedata.StartOrderData {
+	ret := make([]*gamedata.StartOrderData, 0)
+	data, err := gamedata.GetData(CFG_START_ORDER)
+	if err != nil {
+		return ret
+	}
+	for k, v := range data {
+		stepVal := gamedata.GetIntValue(v, "step")
+		if int(stepVal) == id {
+			OrderId, _ := strconv.Atoi(k)
+			ret = append(ret, &gamedata.StartOrderData{
+				Id:        OrderId,
+				Step:      int(stepVal),
+				MergeList: gamedata.GetIntSliceValue(v, "merge_id_list"),
+			})
+		}
+	}
+	sort.Slice(ret, func(i, j int) bool {
+		return ret[i].Id < ret[j].Id
+	})
+	return ret
+}
+
+func GetStartOrderById(id int) *gamedata.StartOrderData {
+	data, err := gamedata.GetData(CFG_START_ORDER)
+	if err != nil {
+		return nil
+	}
+	v, ok := data[strconv.Itoa(id)]
+	if !ok {
+		return nil
+	}
+	stepVal := gamedata.GetIntValue(v, "step")
+	return &gamedata.StartOrderData{
+		Id:        id,
+		Step:      int(stepVal),
+		MergeList: gamedata.GetIntSliceValue(v, "merge_id_list"),
+	}
+}
+
+func GetMaxStep() int {
+	data, err := gamedata.GetData(CFG_START_ORDER)
+	if err != nil {
+		return 0
+	}
+	max := 0
+	for _, v := range data {
+		stepVal := gamedata.GetIntValue(v, "step")
+		if int(stepVal) > max {
+			max = int(stepVal)
+		}
+	}
+	return max
+}
+
+func GetOrderType(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_START_ORDER, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "type")
+}

src/server/conf/playroom/playroomCfg.go

@@ -0,0 +1,650 @@
+package playroomCfg
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	"server/gamedata"
+	"server/pkg/github.com/name5566/leaf/log"
+	"strings"
+)
+
+const (
+	CFG_PLAYROOM_CONST           = "PlayroomConst"
+	CFG_PLAYROOM_DECORATE        = "PlayroomDecorate"
+	CFG_PLAYROOM_MOOD            = "PlayroomMood"
+	CFG_PLAYROOM_PHYSIOLOGY      = "PlayroomPhysiology"
+	CFG_PLAYROOM_PHYSIOLOGY_TYPE = "PlayroomPhysiologyType"
+	CFG_PLAYROOM_SHOP            = "PlayroomShop"
+	CFG_PLAYROOM_DRESS           = "PlayroomDress"
+	CFG_PLAYROOM_AIR             = "PlayroomAir"
+	CFG_PLAYROOM_LOCK            = "PlayroomLock"
+	CFG_PLAYROOM_DAILYTASK       = "PlayroomDailyTask"
+	CFG_PLAYROOM_DAILYTASKREWARD = "PlayroomDailyTaskReward"
+	CFG_PLAYROOM_TASKJACKPOT     = "PlayroomTaskJackpot"
+	CFG_PLAYROOM_ORDERITEM       = "PlayroomOrderItem" // 订单物品
+)
+
+func init() {
+	gamedata.InitCfg(CFG_PLAYROOM_CONST)
+	gamedata.InitCfg(CFG_PLAYROOM_DECORATE)
+	gamedata.InitCfg(CFG_PLAYROOM_MOOD)
+	gamedata.InitCfg(CFG_PLAYROOM_PHYSIOLOGY)
+	gamedata.InitCfg(CFG_PLAYROOM_PHYSIOLOGY_TYPE)
+	gamedata.InitCfg(CFG_PLAYROOM_SHOP)
+	gamedata.InitCfg(CFG_PLAYROOM_DRESS)
+	gamedata.InitCfg(CFG_PLAYROOM_AIR)
+	gamedata.InitCfg(CFG_PLAYROOM_LOCK)
+	gamedata.InitCfg(CFG_PLAYROOM_DAILYTASK)
+	gamedata.InitCfg(CFG_PLAYROOM_DAILYTASKREWARD)
+	gamedata.InitCfg(CFG_PLAYROOM_TASKJACKPOT)
+	gamedata.InitCfg(CFG_PLAYROOM_ORDERITEM)
+}
+
+func GetShopItem(Id int) (int, []*item.Item) {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_SHOP, Id)
+	if err != nil {
+		return 0, nil
+	}
+	return gamedata.GetIntValue(data, "ItemId"), gamedata.GetItemList(data, "Cost")
+}
+
+func GetShopWish(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_SHOP, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Wish")
+}
+
+func GetUnLockLv() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "Lv")
+	if err != nil {
+		return 999
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetGameOutline() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "GameOutline")
+	if err != nil {
+		return 999
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetChipNum() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "ChipNum")
+	if err != nil {
+		return 12
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetOrderStar() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "Star")
+	if err != nil {
+		return 1000
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetRewardStar() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "RewardStar")
+	if err != nil {
+		return 1000
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetTriggerCd() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "CD")
+	if err != nil {
+		return 1000
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetFoodItem() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "Food")
+	if err != nil {
+		return []int{}
+	}
+	for _, v := range strings.Split(gamedata.GetStringValue(data, "Value"), ",") {
+		if v == "" {
+			continue
+		}
+		Id := GoUtil.Int(v)
+		r = append(r, Id)
+	}
+	return r
+}
+
+func GetCleanItem() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "Clean")
+	if err != nil {
+		return []int{}
+	}
+	for _, v := range strings.Split(gamedata.GetStringValue(data, "Value"), ",") {
+		if v == "" {
+			continue
+		}
+		Id := GoUtil.Int(v)
+		r = append(r, Id)
+	}
+	return r
+}
+func GetToyItem() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "Toy")
+	if err != nil {
+		return []int{}
+	}
+	for _, v := range strings.Split(gamedata.GetStringValue(data, "Value"), ",") {
+		if v == "" {
+			continue
+		}
+		Id := GoUtil.Int(v)
+		r = append(r, Id)
+	}
+	return r
+}
+func GetDailyItem() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "Daily")
+	if err != nil {
+		return []int{}
+	}
+	for _, v := range strings.Split(gamedata.GetStringValue(data, "Value"), ",") {
+		if v == "" {
+			continue
+		}
+		Id := GoUtil.Int(v)
+		r = append(r, Id)
+	}
+	return r
+}
+
+func GetPremiumItem() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "PremiumItem")
+	if err != nil {
+		return []int{}
+	}
+	for _, v := range strings.Split(gamedata.GetStringValue(data, "Value"), ",") {
+		if v == "" {
+			continue
+		}
+		Id := GoUtil.Int(v)
+		r = append(r, Id)
+	}
+	return r
+}
+
+func GetInteractNum() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "InteractNum")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetInteractUnlock() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "InteractUnlock")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetVisitorItem() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "VisitorItem")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+func GetWorkItem() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "WorkItem")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetWorkChargeId() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "WorkChargeId")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetJackpotNum() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "Jackpot")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetInteract(Id, Type int) (int, []*item.Item, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_MOOD, Id)
+	if err != nil {
+		return 0, nil, 0
+	}
+	if Type == 1 {
+		return gamedata.GetIntValue(data, "Type"), gamedata.GetItemList(data, "Cost"), gamedata.GetIntValue(data, "Effect")
+	}
+	return gamedata.GetIntValue(data, "Type"), gamedata.GetItemList(data, "Cost2"), gamedata.GetIntValue(data, "Effect")
+}
+
+func GetInteractPhysiology(Id int) (int, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_MOOD, Id)
+	if err != nil {
+		return 0, 0
+	}
+	return gamedata.GetIntValue(data, "PType"), gamedata.GetIntValue(data, "PEffect")
+}
+
+func GetInteractPExp(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_MOOD, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "PExp")
+}
+
+func GetInitDecorate() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetData(CFG_PLAYROOM_DECORATE)
+	if err != nil {
+		return []int{}
+	}
+	for k, v := range data {
+		if gamedata.GetIntValue(v, "Init") == 1 {
+			r = append(r, GoUtil.Int(k))
+		}
+	}
+	return r
+}
+
+func GetDecorateList() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetData(CFG_PLAYROOM_DECORATE)
+	if err != nil {
+		return []int{}
+	}
+	for k := range data {
+		r = append(r, GoUtil.Int(k))
+	}
+	return r
+}
+
+func GetBuyItem(Id int) ([]*item.Item, []*item.Item) {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_MOOD, Id)
+	if err != nil {
+		return nil, nil
+	}
+	return gamedata.GetItemList(data, "Cost2"), gamedata.GetItemList(data, "Buy")
+}
+
+func GetPhysiologyMax(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_PHYSIOLOGY_TYPE, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Max")
+}
+
+func GetPhysiologyDuration(Id int, Num int) int {
+	data, err := gamedata.GetData(CFG_PLAYROOM_PHYSIOLOGY)
+	if err != nil {
+		return 0
+	}
+	for _, v := range data {
+		Type := gamedata.GetIntValue(v, "Type")
+		if Type != Id {
+			continue
+		}
+		Min := gamedata.GetIntValue(v, "Min")
+		Max := gamedata.GetIntValue(v, "Max")
+		if Num >= Min && Num <= Max {
+			return gamedata.GetIntValue(v, "Per") * 60
+		}
+	}
+	return 0
+}
+
+func GetPhysiologyTypeList() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetData(CFG_PLAYROOM_PHYSIOLOGY_TYPE)
+	if err != nil {
+		return []int{}
+	}
+	for k := range data {
+		r = append(r, GoUtil.Int(k))
+	}
+	return r
+}
+
+func GetMoodEffect(Id int) (int, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_PHYSIOLOGY_TYPE, Id)
+	if err != nil {
+		return 0, 0
+	}
+	return gamedata.GetIntValue(data, "MType"), gamedata.GetIntValue(data, "MEffect")
+}
+
+func IsStokeCat(Id int) bool {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "StokeCatId")
+	if err != nil {
+		return false
+	}
+	return gamedata.GetIntValue(data, "Value") == Id
+}
+
+func IsTakeCat(Id int) bool {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "TakeCatId")
+	if err != nil {
+		return false
+	}
+	Ids := gamedata.GetIntSliceValue(data, "Value")
+	return GoUtil.InArray(Id, Ids)
+}
+
+func GetRoomPointInvite() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "RoomPointInvite")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetRoomPointAdd() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "RoomPointAdd")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func IsPlayCat(Id int) bool {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "PlayCatId")
+	if err != nil {
+		return false
+	}
+	Ids := gamedata.GetIntSliceValue(data, "Value")
+	return GoUtil.InArray(Id, Ids)
+}
+
+func GetInitAirList() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetData(CFG_PLAYROOM_AIR)
+	if err != nil {
+		return []int{}
+	}
+	for k, v := range data {
+		if gamedata.GetIntValue(v, "Init") == 1 {
+			r = append(r, GoUtil.Int(k))
+		}
+	}
+	return r
+}
+
+func GetAirList() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetData(CFG_PLAYROOM_AIR)
+	if err != nil {
+		return []int{}
+	}
+	for k := range data {
+		r = append(r, GoUtil.Int(k))
+	}
+	return r
+}
+
+func GetInitDressList() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetData(CFG_PLAYROOM_DRESS)
+	if err != nil {
+		return []int{}
+	}
+	for k, v := range data {
+		if gamedata.GetIntValue(v, "Init") == 1 {
+			r = append(r, GoUtil.Int(k))
+		}
+	}
+	return r
+}
+
+func GetDressList() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetData(CFG_PLAYROOM_DRESS)
+	if err != nil {
+		return []int{}
+	}
+	for k := range data {
+		r = append(r, GoUtil.Int(k))
+	}
+	return r
+}
+
+func GetDressPart(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_DRESS, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "IPart")
+}
+
+func GetDressName(Id int) string {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_DRESS, Id)
+	if err != nil {
+		return ""
+	}
+	return gamedata.GetStringValue(data, "Name")
+}
+
+func GetUnlockNeed(Type int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_LOCK, Type)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Need")
+}
+
+func GetUnlockName(Type int) string {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_LOCK, Type)
+	if err != nil {
+		return ""
+	}
+	return gamedata.GetStringValue(data, "Name")
+}
+
+func GetDailyTask(Type int) map[int]string {
+	data, err := gamedata.GetData(CFG_PLAYROOM_DAILYTASK)
+	if err != nil {
+		return nil
+	}
+	r := make(map[int]string)
+	r1 := make([]int, 0)
+	r2 := make(map[int]string)
+	for k, v := range data {
+		if gamedata.GetIntValue(v, "Type") == Type {
+			k1 := GoUtil.Int(k)
+			r[k1] = gamedata.GetStringValue(v, "Task")
+			r1 = append(r1, k1)
+		}
+	}
+	r3 := GoUtil.RandSliceNum(r1, 6)
+	for _, v := range r3 {
+		r2[v] = r[v]
+	}
+	return r2
+}
+
+func GetDailyTaskType(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_DAILYTASK, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Type")
+}
+
+func GetDailyTaskReward(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_DAILYTASKREWARD, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "Items")
+}
+
+// 获取场景冲刺奖池
+func GetTaskJackpotProb() map[int]int {
+	r := make(map[int]int)
+	data, err := gamedata.GetData(CFG_PLAYROOM_TASKJACKPOT)
+	if err != nil {
+		log.Debug("GetTaskJackpotProb err:%v", err)
+		return nil
+	}
+	for k, v := range data {
+		Id := GoUtil.Int(k)
+		r[Id] = gamedata.GetIntValue(v, "Prob")
+	}
+	return r
+}
+
+// 获取场景冲刺奖励
+func GetTaskJackpotReward(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_TASKJACKPOT, Id)
+	if err != nil {
+		log.Debug("GetTaskJackpotReward err:%v", err)
+		return nil
+	}
+	return gamedata.GetItemList(data, "Items")
+}
+
+func GetPhysiologyList(MoodType int) []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetData(CFG_PLAYROOM_PHYSIOLOGY_TYPE)
+	if err != nil {
+		return []int{}
+	}
+	for k, v := range data {
+		if gamedata.GetIntValue(v, "MType") == MoodType {
+			r = append(r, GoUtil.Int(k))
+		}
+	}
+	return r
+}
+
+func GetInteractIdBath() []int {
+	return []int{11, 12, 13}
+}
+
+func GetOrderItem(Star int) map[int][]gamedata.PetOrderItem {
+	data, err := gamedata.GetData(CFG_PLAYROOM_ORDERITEM)
+	if err != nil {
+		log.Debug("GetOrderItem err:%v", err)
+		return nil
+	}
+	r := make(map[int][]gamedata.PetOrderItem)
+	for k, v := range data {
+		ItemStar := gamedata.GetIntValue(v, "Star")
+		if ItemStar > 0 && ItemStar > Star {
+			continue
+		}
+		Id := GoUtil.Int(k)
+		Type := gamedata.GetIntValue(v, "Type")
+		if Type == 0 {
+			continue
+		}
+		if _, ok := r[Type]; !ok {
+			r[Type] = make([]gamedata.PetOrderItem, 0)
+		}
+		if Id == 0 {
+			log.Debug("GetOrderItem Id is 0, Type:%v", Type)
+			continue
+		}
+		r[Type] = append(r[Type], gamedata.PetOrderItem{
+			Id:   Id,
+			Star: ItemStar,
+		})
+	}
+	return r
+}
+
+func GetOrderItemList() []int {
+	data, err := gamedata.GetData(CFG_PLAYROOM_ORDERITEM)
+	if err != nil {
+		log.Debug("GetOrderItemList err:%v", err)
+		return nil
+	}
+	r := make([]int, 0)
+	for k := range data {
+		Id := GoUtil.Int(k)
+		if Id == 0 {
+			log.Debug("GetOrderItemList Id is 0")
+			continue
+		}
+		r = append(r, Id)
+	}
+	return r
+}
+
+func GetPetOrderItemExpByList(ItemList []*item.Item) int {
+	r := 0
+	for _, v := range ItemList {
+		data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_ORDERITEM, v.Id)
+		if err != nil {
+			// log.Debug("GetPetOrderItemExpByList err:%v", err)
+			continue
+		}
+		Star := gamedata.GetIntValue(data, "Star")
+		r += Star * v.Num
+	}
+	return r
+}
+
+func GetShopItemAdNum(Id int) int {
+	data, err := gamedata.GetData(CFG_PLAYROOM_SHOP)
+	if err != nil {
+		log.Debug("GetShopItemAdNum err:%v", err)
+		return 0
+	}
+	for _, v := range data {
+		if gamedata.GetIntValue(v, "ItemId") == Id {
+			return gamedata.GetIntValue(v, "Dailystorage")
+		}
+	}
+	return 0
+}
+
+func GetDecoInfo(Id int) (int, string) {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_DECORATE, Id)
+	if err != nil {
+		log.Debug("GetDecoInfo err:%v", err)
+		return 0, ""
+	}
+	Type := gamedata.GetIntValue(data, "TypeEnum")
+	Name := gamedata.GetStringValue(data, "Chinese")
+	return Type, Name
+}
+
+func GetDailyTaskListById(Id int) []int {
+	data, err := gamedata.GetData(CFG_PLAYROOM_DAILYTASK)
+	if err != nil {
+		log.Debug("GetDailyTaskListById err:%v", err)
+		return nil
+	}
+	Type := GetDailyTaskType(Id)
+	r := make([]int, 0)
+	for k, v := range data {
+		if gamedata.GetIntValue(v, "Type") == Type {
+			r = append(r, GoUtil.Int(k))
+		}
+	}
+	return r
+}

src/server/conf/race/raceCfg.go

@@ -0,0 +1,78 @@
+package raceCfg
+
+import (
+	"server/game/mod/item"
+	"server/gamedata"
+)
+
+const (
+	CFG_RACE_TEMPLATE = "RaceTemplate"
+	CFG_RACE_PASS     = "RacePass"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_RACE_TEMPLATE)
+	gamedata.InitCfg(CFG_RACE_PASS)
+}
+
+func GetRaceNum(Pass int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_RACE_PASS, Pass)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Num")
+}
+
+func GetRaceNeed(Pass int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_RACE_PASS, Pass)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Need")
+}
+
+func GetMaxPass(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_RACE_TEMPLATE, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "PassNum")
+}
+func GetActivityItemId(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_RACE_TEMPLATE, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "ItemId")
+}
+func GetCD(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_RACE_PASS, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Cd")
+}
+
+func GetCoin(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_RACE_TEMPLATE, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "ItemId")
+}
+
+func GetExtraReward(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_RACE_PASS, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "ExtraReward")
+}
+
+func GetReward(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_RACE_PASS, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "Reward")
+}

src/server/conf/randname/randnameCfg.go

@@ -0,0 +1,52 @@
+package randnameCfg
+
+import (
+	"server/GoUtil"
+	"server/gamedata"
+	"strconv"
+)
+
+const (
+	CFG_RAND_NAME = "RandName"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_RAND_NAME)
+}
+
+func GetRandName() string {
+	data, _ := gamedata.GetData(CFG_RAND_NAME)
+	Id := GoUtil.RandNum(1, len(data))
+	v, err := gamedata.GetDataByIntKey(CFG_RAND_NAME, Id)
+	if err != nil {
+		return "Lily"
+	}
+	return gamedata.GetStringValue(v, "EnName")
+}
+
+func GetRandNames(n int) []string {
+	rs := make([]string, 0)
+	data, err := gamedata.GetData(CFG_RAND_NAME)
+	if err != nil {
+		for i := 0; i < n; i++ {
+			id := strconv.Itoa(i + 1)
+			rs[i] = "Lily" + id
+		}
+	}
+	all := make([]int, len(data))
+	index := 0
+	for k := range data {
+		ik := GoUtil.Int(k)
+		all[index] = ik
+		index++
+	}
+	ids := GoUtil.RandSliceNumNonAdjacent(all, n)
+	for _, v := range ids {
+		v, err := gamedata.GetDataByIntKey(CFG_RAND_NAME, v)
+		if err != nil {
+			rs = append(rs, "Lucy")
+		}
+		rs = append(rs, gamedata.GetStringValue(v, "EnName"))
+	}
+	return rs
+}

src/server/conf/server.json

@@ -1,19 +1,21 @@
 {
+	"AppID": 1,
 	"LogLevel": "debug", 
-	"LogPath": "",
-	"TCPAddr": ":3565",
+	"LogPath": "./log",
+	"TCPAddr": ":3601",
 	"WSAddr": ":3566",
 	"MySqlAddr": "127.0.0.1",
 	"MySqlPort": "3306",
 	"MySqlUsr": "root",
-	"MySqlPwd": "root",
+	"MySqlPwd": "IOagNEq3C84c-20CmHEin5iODVc=",
 	"MaxConnNum": 20000,
-	"DbName": "Merge_Pet",
+	"DbName": "Merge_Pet_1",
 	"HttpPort": ":8081",
-	"RemoteAddr":"host.docker.internal:9001",
+	"AppPath": "./app",
+	"TELOGDIR" : "./teLog/",
+
+	"GameName": "Merge_Pet_Local",
 
-	"GameName": "Merge_Pet",
-	"GameID": 1,
 	"ServerType":"node",
 
 	"ServerID": 1,
@@ -21,12 +23,17 @@
 	"ServerName": "Merge_Pet",
 	"ServerStatus" : 1,
 	"ServerCenter" : 1,
-
+	"GameConfPath": "D:/Github/pet_home_server/src/server/gamedata/config/",
 	
 	"RedisAddr":"127.0.0.1",
 	"RedisPort" :"6379",
 	"RedisPwd"  :"",
-
-	"ListenAddr": ":9001",
-	"CenterAddr": ":3560"
+	"GoogleVerify":false,
+	"RemoteAddr":"host.docker.internal:9001",
+	"Partition":3,
+	"KafkaHost":"kafka-server",
+	"CountryCode":"004",
+	"KafkaPort":"9092",
+	"Version":"1.0.0",
+	"IdVerify":false
 }

src/server/conf/user/UserData.go

@@ -6,10 +6,14 @@ import (
 	"server/pkg/github.com/name5566/leaf/log"
 )
 
-var CFG_NAME = "UserData"
+const (
+	CFG_NAME       = "UserData"
+	CFG_NANE_CONST = "UserDataConst"
+)
 
 func init() {
 	gamedata.InitCfg(CFG_NAME)
+	gamedata.InitCfg(CFG_NANE_CONST)
 }
 
 // 获取用户能量倍数
@@ -22,6 +26,15 @@ func GetEnergyMulByLv(lv int) int {
 	return gamedata.GetIntValue(data, "EnergyMul")
 }
 
+func GetEnergyMax(Lv int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, Lv)
+	if err != nil {
+		log.Debug("UserDataCfg GetEnergyMax lv:%v not found", Lv)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "MaxEnergy")
+}
+
 // 获取七天登录加成
 func GetSevenloginAdd(Lv int) int {
 	data, err := gamedata.GetDataByIntKey(CFG_NAME, Lv)
@@ -43,13 +56,45 @@ func GetOrderNByLv(lv int) (int, error) {
 }
 
 // 获取升级经验
-func GetLevUpExp(lv int) int {
+func GetLevUpExp(lv int) (int, int) {
 	data, err := gamedata.GetDataByIntKey(CFG_NAME, lv)
 	if err != nil {
 		log.Debug("UserDataCfg GetLevUpExp lv:%v not found", lv)
-		return 0
+		return 0, 0
 	}
-	return gamedata.GetIntValue(data, "Exp")
+	return gamedata.GetIntValue(data, "Exp"), gamedata.GetIntValue(data, "PExp")
+}
+
+func GetNewLevUpExp(lv int, Exp int, PetExt int) (int, int) {
+	ExpLv := lv
+	PetLv := lv
+	for {
+		data1, err := gamedata.GetDataByIntKey(CFG_NAME, ExpLv)
+		if err != nil {
+			break
+		}
+		ExpNeed := gamedata.GetIntValue(data1, "Exp")
+		if Exp >= ExpNeed {
+			Exp -= ExpNeed
+			ExpLv++
+		} else {
+			break
+		}
+	}
+	for {
+		data2, err := gamedata.GetDataByIntKey(CFG_NAME, PetLv)
+		if err != nil {
+			break
+		}
+		PetNeed := gamedata.GetIntValue(data2, "PExp")
+		if PetExt >= PetNeed {
+			PetExt -= PetNeed
+			PetLv++
+		} else {
+			break
+		}
+	}
+	return ExpLv, PetLv
 }
 
 // 获取能量回复时间
@@ -83,3 +128,41 @@ func GetLevUpReward(lv int) []*item.Item {
 	itemList := item.ParseItem(itemMap)
 	return itemList
 }
+
+func GetUnlock(Lv int) string {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, Lv)
+	if err != nil {
+		log.Debug("UserDataCfg GetUnlock lv:%v not found", Lv)
+		return ""
+	}
+	s1 := gamedata.GetStringValue(data, "Unlock_1")
+	s2 := gamedata.GetStringValue(data, "Unlock_2")
+	return s1 + "," + s2
+}
+
+func GetInitEnergy() int {
+	data, err := gamedata.GetDataByKey(CFG_NANE_CONST, "Energy")
+	if err != nil {
+		log.Debug("UserDataCfg GetInitEnergy not found")
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetInitDiamond() int {
+	data, err := gamedata.GetDataByKey(CFG_NANE_CONST, "Diamond")
+	if err != nil {
+		log.Debug("UserDataCfg GetInitDiamond not found")
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetInitStar() int {
+	data, err := gamedata.GetDataByKey(CFG_NANE_CONST, "Star")
+	if err != nil {
+		log.Debug("UserDataCfg GetInitStar not found")
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}

src/server/cron/parser.go

@@ -67,7 +67,6 @@ type Parser struct {
 //	// Same as above, just makes Dow optional
 //	subsParser := NewParser(Dom | Month | DowOptional)
 //	sched, err := specParser.Parse("15 */3")
-//
 func NewParser(options ParseOption) Parser {
 	optionals := 0
 	if options&DowOptional > 0 {
@@ -193,7 +192,7 @@ func normalizeFields(fields []string, options ParseOption) ([]string, error) {
 	if min < max && len(fields) == min {
 		switch {
 		case options&DowOptional > 0:
-			fields = append(fields, defaults[5]) // TODO: improve access to default
+			fields = append(fields, defaults[5])
 		case options&SecondOptional > 0:
 			fields = append([]string{defaults[0]}, fields...)
 		default:
@@ -247,7 +246,9 @@ func getField(field string, r bounds) (uint64, error) {
 }
 
 // getRange returns the bits indicated by the given expression:
+//
 //	number | number "-" number [ "/" number ]
+//
 // or error parsing range.
 func getRange(expr string, r bounds) (uint64, error) {
 	var (

src/server/db/Mysql.go

@@ -25,7 +25,8 @@ var SqlDb *sqlx.DB
 
 func InitDB() {
 	//"用户名:密码@[连接方式](主机名:端口号)/数据库名"
-	connect := fmt.Sprintf("%s:%s@(%s:%s)/%s", conf.Server.MySqlUsr, conf.Server.MySqlPwd, conf.Server.MySqlAddr, conf.Server.MySqlPort, conf.Server.DbName)
+	MysqlPwd, _ := GoUtil.Decrypt(conf.Server.MySqlPwd)
+	connect := fmt.Sprintf("%s:%s@(%s:%s)/%s", conf.Server.MySqlUsr, MysqlPwd, conf.Server.MySqlAddr, conf.Server.MySqlPort, conf.Server.DbName)
 	SqlDb = sqlx.MustConnect("mysql", connect) // 设置连接数据库的参数
 	SqlDb.SetMaxOpenConns(20)                  // 设置最大打开的连接数
 	log.Debug("connect mysql success")
@@ -145,7 +146,7 @@ func FormatAllMemUpdateDb(u interface{}, tableName string, Exclude string) (err
 			if k == reflect.String {
 				keyValue = ufield.String()
 			}
-			if k == reflect.Int32 || k == reflect.Int {
+			if k == reflect.Int32 || k == reflect.Int || k == reflect.Int64 {
 				keyValue = ufield.Int()
 			}
 		}
@@ -187,6 +188,9 @@ func FormatAllMemInsertDb(u interface{}, tableName string) (insertID int64, err
 		if k == reflect.Int32 {
 			Values[i] = ufield.Int()
 		}
+		if k == reflect.Int64 {
+			Values[i] = ufield.Int()
+		}
 	}
 	for i := range Fields {
 		Fields[i] = "`" + Fields[i] + "`"
@@ -239,6 +243,16 @@ func GetAccountInfoFromDb(name string) *Db_Account {
 	return &res
 }
 
+func UpdateAccountInfoToDb(account *Db_Account) (err error) {
+	_, err = SqlDb.Exec("UPDATE t_account SET user_password = ? WHERE user_name = ?", account.UserPassword, account.UserName)
+	return
+}
+
+func UpdateAccountInfoDeviceToDb(account *Db_Account) (err error) {
+	_, err = SqlDb.Exec("UPDATE t_account SET device_id = ? WHERE user_name = ?", account.DeviceId, account.UserName)
+	return
+}
+
 func FormatAllMemLoadDb(u interface{}, tableName string, Exclude string) (err error) {
 	t := reflect.TypeOf(u)
 	len := t.Elem().NumField()
@@ -430,10 +444,10 @@ func GetServerMailData(data *[]*SqlServerMailStruct) error {
 	return err
 }
 
-func CreateOrderSn(Uid, ChargeId int, OrderSn, Platform, Channel string, Price float64, Currency string) error {
-	sql := "insert into t_player_charge (`Uid`,`OrderId`, `ProductId`, `Price`,`Currency`, `CreateTime`, `PayPlatform`, `PayChannel`) Values (?,?,?,?,?,?,?,?)"
+func CreateOrderSn(Uid, ChargeId int, OrderSn, Platform, Channel string, Price float64, Currency, Extra string) error {
+	sql := "insert into t_player_charge (`Uid`,`OrderId`, `ProductId`, `Price`,`Currency`, `CreateTime`, `PayPlatform`, `PayChannel`, `PayChannelExtra`) Values (?,?,?,?,?,?,?,?,?)"
 	Now := GoUtil.Now()
-	_, err := SqlDb.Exec(sql, Uid, OrderSn, ChargeId, Price, Currency, Now, Platform, Channel)
+	_, err := SqlDb.Exec(sql, Uid, OrderSn, ChargeId, Price, Currency, Now, Platform, Channel, Extra)
 	return err
 }
 
@@ -444,8 +458,22 @@ func GetPlayerChargeData(OrderSn string) (*SqlChargeOrderStruct, error) {
 	return data, err
 }
 
+func GetPlayerPayChannelOrderId(OrderSn string) (*SqlChargeOrderStruct, error) {
+	sql := "select * from t_player_charge where PayChannelOrderId = ?"
+	data := &SqlChargeOrderStruct{}
+	err := SqlDb.Get(data, sql, OrderSn)
+	return data, err
+}
+
 func UpdatePlayerChargeData(data *SqlChargeOrderStruct) error {
 	sql := "update t_player_charge set PayTime = ?, PayStatus = ?, PayChannelOrderId = ? where OrderId = ?"
 	_, err := SqlDb.Exec(sql, data.PayTime, data.PayStatus, data.PayChannelOrderId, data.OrderId)
 	return err
 }
+
+func SearchPlayer(key string) ([]*ResPlayerBaseInfo, error) {
+	sql := "select * from t_player_baseinfo where nick_name like ? limit 10"
+	data := &[]*ResPlayerBaseInfo{}
+	err := SqlDb.Select(data, sql, "%"+key+"%")
+	return *data, err
+}

src/server/db/Redis.go

@@ -17,7 +17,7 @@ func InitRedis() {
 	rdb := redis.NewClient(&redis.Options{
 		Addr:     conf.Server.RedisAddr + ":" + conf.Server.RedisPort,
 		Password: conf.Server.RedisPwd, // no password set
-		DB:       0,
+		DB:       conf.Server.RedisDb,
 	})
 
 	_, err := rdb.Ping(ctx).Result()
@@ -66,7 +66,6 @@ func RedisUnlock(key string, value string) bool {
 func RedisGetKey(key string) (string, error) {
 	val, err := Rdb.Get(ctx, key).Result()
 	if err != nil {
-		log.Debug("redis get failed, err:%v\n", err)
 		return "", err
 	}
 	return val, nil
@@ -85,3 +84,38 @@ func RedisZAdd(key string, member string, score float64) {
 		log.Debug("redis zadd failed, err:%v\n", err)
 	}
 }
+
+func RedisZRangeWithScores(key string, start, stop int64) ([]redis.Z, error) {
+	val, err := Rdb.ZRangeWithScores(ctx, key, start, stop).Result()
+	if err != nil {
+		return nil, err
+	}
+	return val, nil
+}
+
+func RedisZRevRangeWithScores(key string, start, stop int64) ([]redis.Z, error) {
+	val, err := Rdb.ZRevRangeWithScores(ctx, key, start, stop).Result()
+	if err != nil {
+		return nil, err
+	}
+	return val, nil
+}
+
+func RedisZRankWithScores(key, member string) (int64, float64, error) {
+	val, err := Rdb.ZRank(ctx, key, member).Result()
+	if err != nil {
+		return 0, 0, err
+	}
+	score, err := Rdb.ZScore(ctx, key, member).Result()
+	if err != nil {
+		return 0, 0, err
+	}
+	return val, score, nil
+}
+
+func RedisDel(key string) {
+	err := Rdb.Del(ctx, key).Err()
+	if err != nil {
+		log.Debug("redis del failed, err:%v\n", err)
+	}
+}

src/server/db/SqlStruct.go

@@ -20,10 +20,12 @@ type Db_Account struct {
 	Channel      string `db:"channel"`
 	DeviceId     string `db:"device_id"`
 	AutoId       int    `db:"auto_id"`
+	IdName       string `db:"id_name"`
+	IdNum        string `db:"id_num"`
 }
 
 type ResPlayerBaseInfo struct {
-	DwUin             int32  `db:"dwUin"`
+	DwUin             int64  `db:"dwUin"`
 	Energy            int32  `db:"energy"`
 	Star              int32  `db:"star"`
 	RecoverTime       int32  `db:"recover_time"`
@@ -37,6 +39,7 @@ type ResPlayerBaseInfo struct {
 	LastPlayTime      int32  `db:"last_play_time"`
 	EnergyBuyCount    int32  `db:"EnergyBuyCount"`
 	UserName          string `db:"user_name"`
+	NickName          string `db:"nick_name"`
 	LoginTime         int32  `db:"login_time"`
 	LogoutTime        int32  `db:"logout_time"`
 	Todayolinetime    int32  `db:"todayolinetime"`
@@ -458,7 +461,7 @@ type SqlAddFriendStruct struct {
 }
 
 type SqlModStruct struct {
-	DwUin      int32  `db:"dwUin"`
+	DwUin      int64  `db:"dwUin"`
 	ModData    []byte `db:"mData"`
 	UpdataTime int32  `db:"updateTime"`
 }
@@ -474,12 +477,18 @@ type SqlServerMailStruct struct {
 	Id            int    `db:"mail_id"`
 	Title         string `db:"title"`
 	Content       string `db:"content"`
+	SubTitle      string `db:"subTitle"`
+	SubTitleEn    string `db:"subTitle_en"`
+	TitleEn       string `db:"title_en"`
+	ContentEn     string `db:"content_en"`
 	Items         string `db:"items"`
 	Start_time    int64  `db:"start_time"`
 	Register_time int64  `db:"register_time"`
 	End_time      int64  `db:"end_time"`
 	Mail_type     int    `db:"mail_type"`
+	Send_type     int    `db:"send_type"`
 	To_uids       string `db:"to_uids"`
+	CreateTime    int64  `db:"create_time"`
 }
 
 type SqlChargeOrderStruct struct {

src/server/game/ActivityFunc.go

@@ -0,0 +1,285 @@
+package game
+
+import (
+	"server/GoUtil"
+	activityCfg "server/conf/activity"
+	guesscolorCfg "server/conf/guessColor"
+	itemCfg "server/conf/item"
+	mailCfg "server/conf/mail"
+	miningCfg "server/conf/mining"
+	raceCfg "server/conf/race"
+	"server/game/mod/activity"
+	"server/game/mod/item"
+	"server/game/mod/mail"
+	"server/msg"
+)
+
+// 活动模块 登录
+func ActivityLogin(p *Player) {
+	ItemMod := p.PlayMod.getItemMod()
+	// 挖矿
+	ActivityId := GetActivityId(p, activity.ACT_TYPE_MINING)
+	MiningMod := p.PlayMod.getMiningMod()
+	OldId := MiningMod.Login(ActivityId)
+	if OldId != 0 {
+		ItemId := guesscolorCfg.GetActivityItemId(OldId)
+		ItemNum := ItemMod.GetItem(ItemId)
+		if ItemNum != 0 {
+			ItemMod.AddItem(ItemId, -ItemNum)
+			SendActivityMail(p, ItemId, ItemNum, ActivityId)
+		}
+	}
+	// 猜颜色
+	ActivityId = GetActivityId(p, activity.ACT_TYPE_GUESS_COLOR)
+	GuessColorMod := p.PlayMod.getGuessColorMod()
+	OldId = GuessColorMod.Login(ActivityId)
+	if OldId != 0 {
+		ItemId := guesscolorCfg.GetActivityItemId(OldId)
+		ItemNum := ItemMod.GetItem(ItemId)
+		if ItemNum != 0 {
+			ItemMod.AddItem(ItemId, -ItemNum)
+			SendActivityMail(p, ItemId, ItemNum, ActivityId)
+		}
+	}
+
+	// 赛跑
+	ActivityId = GetActivityId(p, activity.ACT_TYPE_RACE)
+	RaceMod := p.PlayMod.getRaceMod()
+	OldId = RaceMod.Login(ActivityId)
+	if OldId != 0 {
+		ItemId := guesscolorCfg.GetActivityItemId(OldId)
+		ItemNum := ItemMod.GetItem(ItemId)
+		if ItemNum != 0 {
+			ItemMod.AddItem(ItemId, -ItemNum)
+			SendActivityMail(p, ItemId, ItemNum, ActivityId)
+		}
+	}
+}
+
+func SendActivityMail(p *Player, ItemId, ItemNum, ActivityId int) {
+	MailMod := p.PlayMod.getMailMod()
+	ItemName, ItemNameEn := itemCfg.GetItemName(ItemId)
+	ActivityTitle, ActivityTitleEn := activityCfg.GetActivityTitle(ActivityId)
+	mt, mc, mt_en, mc_en := mailCfg.GetRecallMail(ActivityTitle, ActivityTitleEn, ItemName, ItemNameEn)
+	Items := []*item.Item{item.NewItem(ItemId, ItemNum)}
+	MailMod.Send(mt, "", mc, mt_en, "", mc_en, Items, mail.MAIL_TYPE_NORMAL)
+}
+
+// 活动模块 零点更新
+func ActivityZeroUpdate(p *Player) {
+	ActivityInfo := GetActivityInfo(p, activity.ACT_TYPE_MINING)
+	if ActivityInfo != nil {
+		MiningMod := p.PlayMod.getMiningMod()
+		MiningMod.ZeroUpdate(ActivityInfo.Id)
+	}
+	ActivityInfo = GetActivityInfo(p, activity.ACT_TYPE_GUESS_COLOR)
+	if ActivityInfo != nil {
+		GuessColorMod := p.PlayMod.getGuessColorMod()
+		GuessColorMod.ZeroUpdate(ActivityInfo.Id)
+	}
+	ActivityInfo = GetActivityInfo(p, activity.ACT_TYPE_RACE)
+	if ActivityInfo != nil {
+		RaceMod := p.PlayMod.getRaceMod()
+		RaceMod.ZeroUpdate(ActivityInfo.Id)
+	}
+}
+
+func GetActivityInfo(p *Player, actType int) *ActivityInfo {
+	for _, v := range p.activity {
+		if v.Type == actType {
+			return v
+		}
+	}
+	return nil
+}
+
+func GetActivityId(p *Player, actType int) int {
+	for _, v := range p.activity {
+		if v.Type == actType {
+			return v.Id
+		}
+	}
+	return 0
+}
+
+func GetActivityInfoById(p *Player, Id int) *ActivityInfo {
+	for _, v := range p.activity {
+		if v.Id == Id {
+			return v
+		}
+	}
+	return nil
+}
+
+func GetActivityStatus(p *Player, actType int) int {
+	ActivityInfo := GetActivityInfo(p, actType)
+	if ActivityInfo == nil {
+		return 0
+	}
+	Now := GoUtil.Now()
+	if Now < ActivityInfo.StartT {
+		return 0
+	}
+	if Now > ActivityInfo.EndT {
+		return 2
+	}
+	return 1
+}
+
+func MiningBackData(p *Player) {
+	ActivityInfo := GetActivityInfo(p, activity.ACT_TYPE_MINING)
+	if ActivityInfo == nil {
+		return
+	}
+	Status := GetActivityStatus(p, activity.ACT_TYPE_MINING)
+	Template := miningCfg.GetTemplate(ActivityInfo.Id)
+	MiningMod := p.PlayMod.getMiningMod()
+	p.PushClientRes(&msg.ResMining{
+		Id:       int32(ActivityInfo.Id),
+		Status:   int32(Status),
+		EndTime:  int32(ActivityInfo.EndT),
+		Template: int32(Template),
+		Pass:     int32(MiningMod.GetPass()),
+		Gem:      GoUtil.IntToInt32(MiningMod.GetGem()),
+		Map:      MiningMod.GetMap(),
+		Mining:   int32(MiningMod.GetMining()),
+	})
+}
+
+func GuessColorBackData(p *Player) {
+	ActivityInfo := GetActivityInfo(p, activity.ACT_TYPE_GUESS_COLOR)
+	if ActivityInfo == nil {
+		return
+	}
+
+	Status := GetActivityStatus(p, activity.ACT_TYPE_GUESS_COLOR)
+	GuessColorMod := p.PlayMod.getGuessColorMod()
+	MapList := make([]*msg.GuessColorInfo, 0)
+	for _, v := range GuessColorMod.MapList {
+		MapList = append(MapList, &msg.GuessColorInfo{
+			Map: v,
+		})
+	}
+	p.PushClientRes(&msg.ResGuessColor{
+		Id:      int32(ActivityInfo.Id),
+		Status:  int32(Status),
+		EndTime: int32(ActivityInfo.EndT),
+		Pass:    int32(GuessColorMod.Pass),
+		Opponent: &msg.Opponent{
+			Name:     GuessColorMod.Opponent.Name,
+			Face:     int32(GuessColorMod.Opponent.Face),
+			Avatar:   int32(GuessColorMod.Opponent.Avatar),
+			Progress: int32(GuessColorMod.Opponent.Progress),
+		},
+		WinTime: int32(GuessColorMod.WinTime),
+		MapList: MapList,
+		OMap:    GuessColorMod.OMap,
+	})
+}
+
+func RaceBackData(p *Player) {
+	ActivityInfo := GetActivityInfo(p, activity.ACT_TYPE_RACE)
+	if ActivityInfo == nil {
+		return
+	}
+	Status := GetActivityStatus(p, activity.ACT_TYPE_RACE)
+	RaceMod := p.PlayMod.getRaceMod()
+	Opponent := make([]*msg.Raceopponent, 0)
+	for _, v := range RaceMod.Opponent {
+		Opponent = append(Opponent, &msg.Raceopponent{
+			Id:       int32(v.Id),
+			Name:     v.Name,
+			Face:     int32(v.Face),
+			Avatar:   int32(v.Avatar),
+			Progress: int32(v.Progress),
+		})
+	}
+	p.PushClientRes(&msg.ResRace{
+		Id:            int32(ActivityInfo.Id),
+		Status:        int32(Status),
+		EndTime:       int32(ActivityInfo.EndT),
+		Pass:          int32(RaceMod.Pass),
+		GameStartTime: int32(RaceMod.StartTime),
+		Progress:      int32(RaceMod.Progress),
+		GameEndTime:   int32(RaceMod.EndTime),
+		Opponent:      Opponent,
+		Rank:          int32(RaceMod.Rank),
+	})
+}
+
+func RedBackData(p *Player) {
+	result := make(map[int32]int32)
+	Now := GoUtil.Now()
+	for _, v := range p.activity {
+		if v.StartT < Now && v.EndT > Now {
+			result[int32(v.Type)] = int32(p.GetRed(v))
+		}
+	}
+	p.PushClientRes(&msg.ResActRed{Red: result})
+}
+
+func GetActivityItem(p *Player, ActType []int) []*item.Item {
+	Items := make([]*item.Item, 0)
+	for _, v := range ActType {
+		Status := GetActivityStatus(p, v)
+		ActivityInfo := GetActivityInfo(p, v)
+		if ActivityInfo == nil {
+			continue
+		}
+		if Status != ACT_STATUS_START {
+			continue
+		}
+		switch v {
+		case activity.ACT_TYPE_MINING:
+			Item := miningCfg.GetLoseItem(ActivityInfo.Id)
+			Items = item.Merge(Items, Item)
+		case activity.ACT_TYPE_GUESS_COLOR:
+			Item := guesscolorCfg.GetLoseItem(ActivityInfo.Id)
+			Items = item.Merge(Items, Item)
+		case activity.ACT_TYPE_RACE:
+			ItemId := raceCfg.GetCoin(ActivityInfo.Id)
+			Item := item.NewItem(ItemId, 1)
+			Items = append(Items, Item)
+		}
+	}
+	return Items
+}
+
+func (p *Player) CatnipBackData() {
+	CatnipMod := p.PlayMod.getCatnipMod()
+	Status := GetActivityStatus(p, activity.ACT_TYPE_CATNIP)
+	if CatnipMod == nil {
+		return
+	}
+	GameList := make([]*msg.CatnipGame, 0)
+	for _, v := range CatnipMod.Game {
+		GameInfo := &msg.CatnipGame{
+			Id:       int32(v.Id),
+			Progress: int32(v.Progress),
+			Status:   int32(v.Status),
+		}
+		if v.Partner != 0 {
+			PlayerData := G_getGameLogic().GetResSimplePlayerByUid(v.Partner)
+			if PlayerData != nil {
+				GameInfo.Partner = PlayerData
+			}
+		}
+		GameList = append(GameList, GameInfo)
+	}
+	res := &msg.ResCatnip{
+		Id:       int32(CatnipMod.Id),
+		Status:   int32(Status),
+		GameList: GameList,
+	}
+	p.PushClientRes(res)
+}
+
+func (p *Player) SetCatnipGameLock(Uid int, GameId int) error {
+	ActivityInfo := GetActivityInfoById(p, activity.ACT_TYPE_CATNIP)
+	return G_GameLogicPtr.SetDataSync(int(p.M_DwUin), VAR_OP_CATNIP_LOCK, CatnipLock{
+		Uid:     int(p.M_DwUin),
+		Partner: Uid,
+		GameId:  GameId,
+		End:     int(ActivityInfo.EndT), // 锁
+	})
+}

src/server/game/BanMgr.go

@@ -0,0 +1,69 @@
+package game
+
+import (
+	"encoding/gob"
+	"server/GoUtil"
+)
+
+type BanMgr struct {
+	*ServerMod
+}
+
+type BanData struct {
+	NewBanList map[int64]*BanInfo // 新增的封禁列表
+}
+
+type BanInfo struct {
+	UserId  int64  // 玩家ID
+	EndTime int64  // 封禁结束时间，0表示永久封禁
+	Reason  string // 封禁原因
+}
+
+func (f *BanMgr) Init() {
+	gob.Register(&BanData{})
+	f.key = BAN_MGR_KEY
+	f.data = &BanData{
+		NewBanList: make(map[int64]*BanInfo),
+	}
+	// 注册处理函数
+	f.init()
+	if f.data.(*BanData).NewBanList == nil {
+		f.data.(*BanData).NewBanList = make(map[int64]*BanInfo)
+	}
+}
+
+func (f *BanMgr) IsBanned(userId int64) bool {
+	if f.data.(*BanData).NewBanList == nil {
+		return false
+	}
+	Info, banned := f.data.(*BanData).NewBanList[userId]
+	if !banned {
+		return false
+	}
+	return Info.EndTime > GoUtil.Now() || Info.EndTime == -1 // 如果EndTime为0，表示永久封禁
+}
+
+func (f *BanMgr) GetBanInfo(userId int64) *BanInfo {
+	if f.data.(*BanData).NewBanList == nil {
+		return &BanInfo{}
+	}
+	Info, banned := f.data.(*BanData).NewBanList[userId]
+	if !banned {
+		return &BanInfo{}
+	}
+	return Info
+}
+
+func (f *BanMgr) BanUser(userId int64, endTime int64, reason string) {
+	f.data.(*BanData).NewBanList[userId] = &BanInfo{
+		UserId:  userId,
+		EndTime: endTime,
+		Reason:  reason,
+	}
+	f.SaveData()
+}
+
+func (f *BanMgr) UnbanUser(userId int64) {
+	delete(f.data.(*BanData).NewBanList, userId)
+	f.SaveData()
+}

src/server/game/ChampshipMgr.go

@@ -0,0 +1,734 @@
+package game
+
+import (
+	"math"
+	"server/GoUtil"
+	champshipCfg "server/conf/champship"
+	randnameCfg "server/conf/randname"
+	"server/game/mod/msg"
+	proto "server/msg"
+	"server/pkg/github.com/name5566/leaf/log"
+	"sort"
+	"time"
+)
+
+const (
+	RANK_PLAYER_ROBOT = 2
+)
+
+type ChampshipMgr struct {
+	*ServerMod
+}
+
+type ChampshipData struct {
+	AutoId       int
+	RobotId      int
+	Rank         map[int][]*ChampshipRank // 锦标赛排行榜
+	PreRank      map[int][]*ChampshipRank // 锦标赛排行榜 备份
+	Pool         map[int]*GroupInfo       // 锦标赛未分配玩家
+	GroupInfo    map[int]int              // 锦标赛分组信息
+	PreGroupInfo map[int]int              // 锦标赛分组信息 备份
+	Robot        map[int]*ChampshipRobot  // 机器人
+	PreRobot     map[int]*ChampshipRobot  // 机器人 备份
+	ZeroTime     int64
+}
+
+type ChampshipRank struct {
+	Uid   int
+	Score float64
+	Time  int64
+	Type  int
+}
+
+type ChampshipRobot struct {
+	Max      float64
+	Type     int
+	Name     string
+	Avatar   int
+	Face     int
+	Level    int
+	GroupId  int
+	Time     int64
+	Score    float64
+	PerScore float64
+}
+
+type GroupInfo struct {
+	Uid   int
+	Score float64
+	Time  int64
+	N     int
+	H     int
+}
+
+type CRank struct {
+	Uid   int
+	Score float64
+	N     int
+	H     int
+}
+
+func (c *ChampshipMgr) Init() {
+	c.key = CHAMPSHIP_MGR_KEY
+	c.data = &ChampshipData{
+		Rank:         make(map[int][]*ChampshipRank, 0),
+		PreRank:      make(map[int][]*ChampshipRank, 0),
+		Pool:         make(map[int]*GroupInfo, 0),
+		GroupInfo:    make(map[int]int),
+		PreGroupInfo: make(map[int]int),
+		Robot:        make(map[int]*ChampshipRobot, 0),
+		PreRobot:     make(map[int]*ChampshipRobot, 0),
+	}
+	// 注册处理函数
+	c.init()
+	c.RegisterHandler(msg.HANDLE_TYPE_CHAMPSHIP_GROUP, c.group)
+	c.RegisterHandler(msg.HANDLE_TYPE_CHAMPSHIP_INRANK, c.inRank)
+	c.RegisterHandler(msg.HANDLE_TYPE_CHAMPSHIP_AI, c.ai)
+	c.RegisterHandler(msg.SERVER_ZERO_UPDATE, c.ZeroUpdate)
+	c.RegisterHandler(msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY2, c.NotifyAll)
+
+	Now := GoUtil.Now()
+	ZeroTime := GoUtil.ZeroTimestamp()
+	if c.getData().ZeroTime != ZeroTime {
+		c.ZeroUpdate(&msg.Msg{})
+	}
+	Remain := Now - ZeroTime
+	Remain1 := 1800 - Remain%1800
+
+	c.mDispatr.AfterFunc(time.Duration(Remain1)*time.Second, func() { // 30分钟后重新分组
+		c.Send(&msg.Msg{
+			Type: msg.HANDLE_TYPE_CHAMPSHIP_GROUP,
+		})
+	})
+
+	c.mDispatr.AfterFunc(time.Duration(60)*time.Second, func() {
+		c.Send(&msg.Msg{
+			Type: msg.HANDLE_TYPE_CHAMPSHIP_AI,
+		})
+	})
+
+	c.mDispatr.AfterFunc(time.Duration(GoUtil.NextZeroTimestampDuration())*time.Second, func() {
+		c.Send(&msg.Msg{
+			Type: msg.SERVER_ZERO_UPDATE,
+		})
+	})
+}
+
+func (c *ChampshipMgr) NotifyAll(m *msg.Msg) (interface{}, error) {
+	G_GameLogicPtr.NotifyAll(&msg.Msg{
+		Type: msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY,
+	})
+	return nil, nil
+}
+
+func (c *ChampshipMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {
+	log.Debug("ChampshipMgr ZeroUpdate")
+	c.getData().ZeroTime = GoUtil.ZeroTimestamp()
+	c.getData().PreRank = c.getData().Rank
+	c.getData().PreRobot = c.getData().Robot
+	c.getData().PreGroupInfo = c.getData().GroupInfo
+
+	c.getData().Robot = make(map[int]*ChampshipRobot, 0)
+	c.getData().Rank = make(map[int][]*ChampshipRank, 0)
+	c.getData().GroupInfo = make(map[int]int, 0)
+	c.update = true
+	c.mDispatr.AfterFunc(time.Duration(GoUtil.NextZeroTimestampDuration())*time.Second, func() {
+		c.Send(&msg.Msg{
+			Type: msg.SERVER_ZERO_UPDATE,
+		})
+	})
+	c.NotifyPlayer()
+	c.mDispatr.AfterFunc(time.Duration(1800)*time.Second, func() {
+		c.Send(&msg.Msg{
+			Type: msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY2,
+		})
+	})
+	return nil, nil
+}
+
+func (c *ChampshipMgr) NotifyPlayer() {
+	List := c.getData().PreRank
+	for _, v := range List {
+		for i := 0; i < 3; i++ {
+			if v[i].Type == RANK_PLAYER_ROBOT {
+				continue
+			}
+			NotifyChampshipResult(v[i].Uid, i+1)
+		}
+	}
+}
+
+func (c *ChampshipMgr) ai(m *msg.Msg) (interface{}, error) {
+	ChampshipData := c.getData()
+	Now := GoUtil.Now()
+	for k, v := range ChampshipData.Rank {
+		Notify := make(map[int]int)
+		for e, r := range v {
+			if r.Type == RANK_PLAYER_ROBOT {
+				AddScore := 0.0
+				Robot := ChampshipData.Robot[r.Uid]
+				if Robot == nil {
+					continue
+				}
+
+				if Robot.Type == 2 && Robot.Time+60 < Now {
+					AddScore = Robot.PerScore
+					Robot.Time = Now
+				}
+				if Robot.Type == 3 && Robot.Time+1800 < Now {
+					AddScore = Robot.PerScore
+					Robot.Time = Now
+				}
+				r.Score += AddScore
+			} else {
+				Notify[r.Uid] = e
+			}
+		}
+		sort.Slice(v, func(i, j int) bool { // 排序 从大到小 数值相等按时间排序
+			if v[i].Score > v[j].Score {
+				return true
+			} else if v[i].Score == v[j].Score {
+				return v[i].Time < v[j].Time
+			}
+			return false
+		})
+		for e, r := range v {
+			if r.Type == RANK_PLAYER_ROBOT {
+				continue
+			}
+			if Notify[r.Uid] != e {
+				NotifyPlayer(r.Uid, &msg.Msg{
+					Type: msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY,
+				})
+			}
+		}
+		ChampshipData.Rank[k] = v
+	}
+	c.mDispatr.AfterFunc(time.Duration(60)*time.Second, func() {
+		c.Send(&msg.Msg{
+			Type: msg.HANDLE_TYPE_CHAMPSHIP_AI,
+		})
+	})
+	return nil, nil
+}
+func (c *ChampshipMgr) GetPreRankMsg(Uid int) *proto.ResChampshipPreRank {
+	ChampshipData := c.getData()
+	GroupId := ChampshipData.PreGroupInfo[Uid]
+	if GroupId == 0 {
+		return &proto.ResChampshipPreRank{}
+	}
+	RankList, ok := ChampshipData.PreRank[GroupId]
+	if !ok {
+		return &proto.ResChampshipPreRank{}
+	}
+	MyRank := 0
+	MyScore := 0.0
+	RL := make(map[int32]*proto.ResPlayerRank, 0)
+	for k, v := range RankList {
+		if v.Uid == Uid {
+			MyRank = k + 1
+			MyScore = v.Score
+		}
+		if v.Type == RANK_PLAYER_ROBOT {
+			Robot := ChampshipData.PreRobot[v.Uid]
+			if Robot == nil {
+				continue
+			}
+			RL[int32(k+1)] = &proto.ResPlayerRank{
+				Uid:    int64(v.Uid),
+				Score:  float32(v.Score),
+				Name:   Robot.Name,
+				Avatar: int32(Robot.Avatar),
+				Face:   int32(Robot.Face),
+				Level:  int32(Robot.Level),
+			}
+		} else {
+			SimplePlayer := G_GameLogicPtr.GetResSimplePlayerByUid(v.Uid)
+			if SimplePlayer == nil {
+				continue
+			}
+			RL[int32(k+1)] = &proto.ResPlayerRank{
+				Uid:    int64(v.Uid),
+				Score:  float32(v.Score),
+				Name:   SimplePlayer.Name,
+				Avatar: int32(SimplePlayer.Avatar),
+				Face:   int32(SimplePlayer.Face),
+				Level:  int32(SimplePlayer.Level),
+			}
+		}
+	}
+
+	return &proto.ResChampshipPreRank{
+		MyRank:   int32(MyRank),
+		MyScore:  float32(MyScore),
+		RankList: RL,
+	}
+}
+func (c *ChampshipMgr) GetRankMsg(Uid int) *proto.ResChampshipRank {
+	ChampshipData := c.getData()
+	GroupId := ChampshipData.GroupInfo[Uid]
+	if GroupId == 0 {
+		return &proto.ResChampshipRank{}
+	}
+	RankList, ok := ChampshipData.Rank[GroupId]
+	if !ok {
+		return &proto.ResChampshipRank{}
+	}
+	MyRank := 0
+	MyScore := 0.0
+	RL := make(map[int32]*proto.ResPlayerRank, 0)
+	for k, v := range RankList {
+		if v.Uid == Uid {
+			MyRank = k + 1
+			MyScore = v.Score
+		}
+		if v.Type == RANK_PLAYER_ROBOT {
+			Robot := ChampshipData.Robot[v.Uid]
+			if Robot == nil {
+				continue
+			}
+			RL[int32(k+1)] = &proto.ResPlayerRank{
+				Uid:    int64(v.Uid),
+				Score:  float32(v.Score),
+				Name:   Robot.Name,
+				Avatar: int32(Robot.Avatar),
+				Face:   int32(Robot.Face),
+				Level:  int32(Robot.Level),
+			}
+		} else {
+			SimplePlayer := G_GameLogicPtr.GetResSimplePlayerByUid(v.Uid)
+			if SimplePlayer == nil {
+				continue
+			}
+			RL[int32(k+1)] = &proto.ResPlayerRank{
+				Uid:    int64(v.Uid),
+				Score:  float32(v.Score),
+				Name:   SimplePlayer.Name,
+				Avatar: int32(SimplePlayer.Avatar),
+				Face:   int32(SimplePlayer.Face),
+				Level:  int32(SimplePlayer.Level),
+			}
+		}
+	}
+
+	return &proto.ResChampshipRank{
+		MyRank:   int32(MyRank),
+		MyScore:  float32(MyScore),
+		RankList: RL,
+	}
+}
+
+// 分组
+func (c *ChampshipMgr) group(m *msg.Msg) (interface{}, error) {
+	c.mDispatr.AfterFunc(time.Duration(1800)*time.Second, func() { // 30分钟后重新分组
+		c.Send(&msg.Msg{
+			Type: msg.HANDLE_TYPE_CHAMPSHIP_GROUP,
+		})
+	})
+	Now := GoUtil.Now()
+	Zero := GoUtil.ZeroTimestamp()
+	if Now-Zero < 1800 { // 0点30分钟内不分组
+		return nil, nil
+	}
+	ChampshipData := c.getData()
+	if len(ChampshipData.Pool) == 0 { // 未分配玩家池为空
+		return nil, nil
+	}
+	log.Debug("ChampshipMgr group, player num:%d", len(ChampshipData.Pool))
+	g := make(map[int][]int, 0)
+	for k, v := range ChampshipData.Pool { // step 1:根据数值分配玩家
+		x := 0
+		n := champshipCfg.GetGroupId(v.N)
+		h := champshipCfg.GetGroupId(v.H)
+		if n < h {
+			x = min(max(n-1, h-2), 1)
+		} else {
+			x = n
+		}
+		_, ok := g[x]
+		if !ok {
+			g[x] = make([]int, 0)
+		}
+		g[x] = append(g[x], k)
+	}
+
+	for i := 11; i > 0; i-- {
+		if len(g[i]) == 0 {
+			continue
+		}
+		if len(g[i]) < 10 && i > 1 {
+			g[i-1] = append(g[i-1], g[i]...)
+		}
+		ChampshipData.AutoId++
+		StartId := ChampshipData.AutoId
+		for j := 0; j < len(g[i]); j++ {
+			ChampshipData.GroupInfo[g[i][j]] = ChampshipData.AutoId
+			UserData := ChampshipData.Pool[g[i][j]]
+			ChampshipData.Rank[ChampshipData.AutoId] = append(ChampshipData.Rank[ChampshipData.AutoId], &ChampshipRank{
+				Uid:   UserData.Uid,
+				Score: UserData.Score,
+				Time:  UserData.Time,
+			})
+			sort.Slice(ChampshipData.Rank[ChampshipData.AutoId], func(i, j int) bool { // 排序 从大到小 数值相等按时间排序
+				if ChampshipData.Rank[ChampshipData.AutoId][i].Score > ChampshipData.Rank[ChampshipData.AutoId][j].Score {
+					return true
+				} else if ChampshipData.Rank[ChampshipData.AutoId][i].Score == ChampshipData.Rank[ChampshipData.AutoId][j].Score {
+					return ChampshipData.Rank[ChampshipData.AutoId][i].Time < ChampshipData.Rank[ChampshipData.AutoId][j].Time
+				}
+				return false
+			})
+			if len(ChampshipData.Rank[ChampshipData.AutoId]) == 10 {
+				ChampshipData.AutoId++
+			}
+		}
+		for j := StartId; j <= ChampshipData.AutoId; j++ { // 填充机器人
+			RobotNum := 30 - len(ChampshipData.Rank[j])
+			RobotList := CreateRobotList(i, RobotNum, j)
+			for _, v := range RobotList {
+				ChampshipData.Robot[ChampshipData.RobotId] = v
+				ChampshipData.Rank[j] = append(ChampshipData.Rank[j], &ChampshipRank{
+					Uid:   ChampshipData.RobotId,
+					Score: v.Score,
+					Time:  v.Time,
+					Type:  RANK_PLAYER_ROBOT,
+				})
+				sort.Slice(ChampshipData.Rank[j], func(x, y int) bool { // 排序 从大到小 数值相等按时间排序
+					if ChampshipData.Rank[j][x].Score > ChampshipData.Rank[j][y].Score {
+						return true
+					} else if ChampshipData.Rank[j][x].Score == ChampshipData.Rank[j][y].Score {
+						return ChampshipData.Rank[j][x].Time < ChampshipData.Rank[j][y].Time
+					}
+					return false
+				})
+				ChampshipData.RobotId++
+			}
+		}
+	}
+
+	for k := range ChampshipData.Pool { // 分组完成通知
+		NotifyPlayer(k, &msg.Msg{
+			Type: msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY,
+		})
+	}
+	c.getData().Pool = make(map[int]*GroupInfo) // 清空未分配池
+	return nil, nil
+}
+
+// 获取分组ID
+
+func (c *ChampshipMgr) getGroupId(Uid int) int {
+	ChampshipData := c.getData()
+	GroupId, ok := ChampshipData.GroupInfo[Uid]
+	if ok {
+		return GroupId
+	}
+	return 0
+}
+
+// 进去榜单
+func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
+	ChampshipData := c.getData()
+	data := m.Extra.(CRank)
+	GroupId := c.getGroupId(data.Uid)
+	if GroupId == 0 {
+		ChampshipData.Pool[data.Uid] = &GroupInfo{
+			Uid:   data.Uid,
+			Score: data.Score,
+			Time:  GoUtil.Now(),
+			N:     data.N,
+			H:     data.H,
+		}
+		return nil, nil
+	}
+	RankList, ok := ChampshipData.Rank[GroupId]
+	if !ok {
+		ChampshipData.Rank[GroupId] = make([]*ChampshipRank, 0)
+	}
+	inRank := false
+	Notify := make(map[int]int)
+	for k, v := range RankList {
+		if v.Uid == data.Uid {
+			if v.Score < data.Score {
+				v.Score = data.Score
+				v.Time = GoUtil.Now()
+				inRank = true
+				break
+			}
+			return nil, nil
+		}
+		Notify[v.Uid] = k
+	}
+	if !inRank {
+		RankList = append(RankList, &ChampshipRank{
+			Uid:   data.Uid,
+			Score: data.Score,
+			Time:  GoUtil.Now(),
+		})
+	}
+	sort.Slice(RankList, func(i, j int) bool { // 排序 从大到小 数值相等按时间排序
+		if RankList[i].Score > RankList[j].Score {
+			return true
+		} else if RankList[i].Score == RankList[j].Score {
+			return RankList[i].Time < RankList[j].Time
+		}
+		return false
+	})
+	for k, v := range RankList {
+		if Notify[v.Uid] != k {
+			NotifyPlayer(v.Uid, &msg.Msg{
+				Type: msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY,
+			})
+		}
+	}
+
+	ChampshipData.Rank[GroupId] = RankList
+	return nil, nil
+}
+
+func (c *ChampshipMgr) getMyRank(Uid int) int {
+	ChampshipData := c.getData()
+	GroupId := ChampshipData.GroupInfo[Uid]
+	if GroupId == 0 {
+		return 0
+	}
+	RankList, ok := ChampshipData.Rank[GroupId]
+	if !ok {
+		return 0
+	}
+	for k, v := range RankList {
+		if v.Uid == Uid {
+			return k + 1
+		}
+	}
+	return 0
+}
+
+func (c *ChampshipMgr) getLastMyRank(Uid int) int {
+	ChampshipData := c.getData()
+	GroupId := ChampshipData.PreGroupInfo[Uid]
+	if GroupId == 0 {
+		return 0
+	}
+	RankList, ok := ChampshipData.PreRank[GroupId]
+	if !ok {
+		return 0
+	}
+	for k, v := range RankList {
+		if v.Uid == Uid {
+			return k + 1
+		}
+	}
+	return 0
+}
+
+func (c *ChampshipMgr) getData() *ChampshipData {
+	return c.data.(*ChampshipData)
+}
+
+func CreateRobotList(G, Num, GroupId int) []*ChampshipRobot {
+	r := make([]*ChampshipRobot, 0)
+	switch G {
+	case 1:
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
+		for i := 0; i < 6; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
+		}
+		for i := 0; i < 5; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
+		}
+		Last := Num - len(r)
+		for i := 0; i < Last; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
+		}
+	case 2:
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
+		for i := 0; i < 6; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
+		}
+		n := Num - 10
+
+		for i := 0; i < int(float64(n)*0.1); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
+		}
+		Last := Num - len(r)
+		for i := 0; i < Last; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
+		}
+	case 3:
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
+		for i := 0; i < 6; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
+		}
+		n := Num - 10
+		for i := 0; i < int(float64(n)*0.05); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.15); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
+		}
+		Last := Num - len(r)
+		for i := 0; i < Last; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
+		}
+	case 4:
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
+
+		n := Num - 4
+		for i := 0; i < int(float64(n)*0.35); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.1); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.1); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
+		}
+		Last := Num - len(r)
+		for i := 0; i < Last; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
+		}
+	case 5:
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
+
+		n := Num - 3
+		for i := 0; i < int(float64(n)*0.05); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.3); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.1); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.2); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
+		}
+		Last := Num - len(r)
+		for i := 0; i < Last; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
+		}
+	case 6:
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
+
+		n := Num - 2
+		for i := 0; i < int(float64(n)*0.05); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.05); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.3); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.1); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.25); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
+		}
+		Last := Num - len(r)
+		for i := 0; i < Last; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
+		}
+	case 7:
+		r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
+		n := Num - 1
+		for i := 0; i < int(float64(n)*0.05); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.05); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.1); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.3); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.1); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.2); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
+		}
+		Last := Num - len(r)
+		for i := 0; i < Last; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
+		}
+	case 8, 9, 10, 11:
+		M10 := GoUtil.RandMap(map[int]int{0: 98, 1: 2})
+		if M10 == 1 {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(35131, 64980)), GroupId))
+		}
+		n := Num
+		for i := 0; i < int(float64(n)*0.05); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.05); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.05); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.1); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.3); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.15); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
+		}
+		for i := 0; i < int(float64(n)*0.2); i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
+		}
+		Last := Num - len(r)
+		for i := 0; i < Last; i++ {
+			r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
+		}
+
+	}
+	return r
+}
+
+func CreateRobot(M float64, GroupId int) *ChampshipRobot {
+	Type := GoUtil.RandMap(map[int]int{1: 25, 2: 50, 3: 25})
+	Score := M / 10
+	PerScore := 0.0
+	if Type == 2 {
+		PerScore = math.Round((M/10*0.34)/(float64(GoUtil.NextZeroTimestampDuration())/60)*100) / 100
+		Score = M / 10 * 0.66
+	}
+	if Type == 3 {
+		PerScore = math.Round((M/10*0.34)/(float64(GoUtil.NextZeroTimestampDuration())/1800)*100) / 100
+		Score = 2
+	}
+
+	return &ChampshipRobot{
+		Max:      M / 10,
+		Type:     Type,
+		Name:     randnameCfg.GetRandName(),
+		Avatar:   GoUtil.RandNum(1, 10),
+		Face:     GoUtil.RandNum(1, 10),
+		Level:    GoUtil.RandNum(1, 10),
+		GroupId:  GroupId,
+		Time:     GoUtil.Now(),
+		Score:    Score,
+		PerScore: PerScore,
+	}
+}

src/server/game/ChampshipsManager.go

@@ -1,785 +0,0 @@
-package game
-
-import (
-	"fmt"
-	"math"
-	"math/rand"
-	"server/GoUtil"
-	"server/MergeConst"
-	"server/db"
-	"server/msg"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/robfig/cron/v3"
-
-	"google.golang.org/protobuf/proto"
-)
-
-type ChampshipsManager struct {
-	MStatus             int32
-	MChampshipMap       map[int32]*db.SqlChampshipsStruct
-	MChampshipPlayerMap map[int32][]*msg.ChampshipsPlayerInfo
-	IsSettle            int32
-	IsLoadDB            bool
-	MUpdateNotifyList   []int32
-	McronSave           *cron.Cron
-	McronSaveID         cron.EntryID
-	RobotCronID         cron.EntryID
-	RobotCronID10s      cron.EntryID
-	MPlayerBaseInfoMap  map[int32]*db.ResPlayerBaseInfo
-}
-
-func (p *ChampshipsManager) SaveDataFromDB(Key interface{}) bool {
-
-	return true
-}
-
-func (p *ChampshipsManager) AIGrow1() {
-
-}
-
-func (p *ChampshipsManager) DeleteOutLineChampship(CurChampshipsId int32) {
-	sqlStr := "DELETE FROM t_championships_data WHERE CurChampshipsId = ?"
-
-	for k, v := range p.MChampshipPlayerMap {
-		if v[0].CurChampshipsId == CurChampshipsId {
-			delete(p.MChampshipPlayerMap, k)
-		}
-	}
-	result, err := db.SqlDb.Exec(sqlStr, CurChampshipsId)
-	if err != nil {
-		fmt.Printf("exec failed, err:%v\n", err)
-		return
-	}
-	affectedRows, err := result.RowsAffected()
-	if err != nil {
-		fmt.Printf("get affected failed, err:%v\n", err)
-		return
-	} else {
-		fmt.Printf("delete t_championships_data affectedRows:%d\n", affectedRows)
-	}
-}
-
-func (p *ChampshipsManager) DeleteUneffectPlayer(deleteIds []int32) {
-	sqlStr := "DELETE FROM t_player_baseinfo WHERE dwUin = ?"
-
-	for i := 0; i < len(deleteIds); i++ {
-		_, err := db.SqlDb.Exec(sqlStr, deleteIds[i])
-		if err != nil {
-			fmt.Printf("exec failed, err:%v\n", err)
-		}
-
-	}
-}
-
-func (p *ChampshipsManager) GetFriendListId(id int32) []int32 {
-
-	sqlStr := "SELECT * FROM t_player_Friend_Data WHERE dwUin = ?"
-	sqlStruck := db.SqlFriendStruct{}
-	ret := []int32{}
-
-	if err := db.SqlDb.Get(&sqlStruck, sqlStr, id); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
-
-	} else {
-		if sqlStruck.FriendList != "" {
-			arr := strings.Split(sqlStruck.FriendList, "_")
-			for i := 0; i < len(arr); i++ {
-				id, _ := strconv.ParseInt(arr[i], 10, 32)
-				ret = append(ret, int32(id))
-			}
-		}
-	}
-	return ret
-}
-
-func (p *ChampshipsManager) NotifyOpenNewChampShip(args []interface{}) {
-	go func() {
-		G_GameLogicPtr.M_SvrGlobal.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId + 1
-		G_GameLogicPtr.M_SvrGlobal.StartChampshipsSvrTime = args[0].(int32)
-	}()
-}
-
-func (p *ChampshipsManager) OpenNewChampShip(args []interface{}) {
-
-	G_GameLogicPtr.M_SvrGlobal.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId + 1
-	G_GameLogicPtr.M_SvrGlobal.StartChampshipsSvrTime = args[0].(int32)
-	p.MUpdateNotifyList = []int32{}
-
-	sqlStr := "SELECT * FROM t_player_baseinfo"
-	sqlStrucks := []db.ResPlayerBaseInfo{}
-	if err := db.SqlDb.Select(&sqlStrucks, sqlStr); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
-		return
-	} else {
-
-	}
-	deleteIds := []int32{}
-	sqlStrucksList := []db.ResPlayerBaseInfo{}
-	for i := 0; i < len(sqlStrucks); i++ {
-		if sqlStrucks[i].UserName == "" {
-			deleteIds = append(deleteIds, sqlStrucks[i].DwUin)
-		} else {
-			sqlStrucksList = append(sqlStrucksList, sqlStrucks[i])
-		}
-	}
-	sqlStrucks = sqlStrucksList
-	p.DeleteUneffectPlayer(deleteIds)
-
-	sort.Slice(sqlStrucks, func(i, j int) bool {
-		if sqlStrucks[i].Level != sqlStrucks[j].Level {
-			return sqlStrucks[i].Level < sqlStrucks[j].Level
-		} else {
-			return sqlStrucks[i].Exp < sqlStrucks[j].Exp
-		}
-
-	})
-	var playerCnt int = 15
-	groups := int(math.Ceil((float64)(len(sqlStrucks)) / float64(playerCnt)))
-	StartRobotUin := 200000
-	p.MStatus = 1
-	rand.Seed(time.Now().Unix())
-	for i := 0; i < groups; i++ {
-		if i < groups-1 {
-			temp := db.SqlChampshipsStruct{}
-			temp.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-			CSPlayerInfo := []*msg.ChampshipsPlayerInfo{}
-
-			strr := []string{}
-			for j := 0; j < int(playerCnt); j++ {
-				dwUin := sqlStrucks[i*int(playerCnt)+j].DwUin
-				res := strconv.Itoa(int(dwUin)) + "_" + "1" + "_" + "0" + "_" + "0" + "_" + "1" + "_" + strconv.Itoa(int(G_GameLogicPtr.M_SvrGlobal.CurChampshipsId)) + "_0"
-				strr = append(strr, res)
-				playerinfo := &msg.ChampshipsPlayerInfo{}
-				playerinfo.DwUin = dwUin
-				playerinfo.IsGet = 0
-				playerinfo.IsPlayer = 1
-				playerinfo.Score = 0
-				playerinfo.Times = 1
-				playerinfo.AIEnum = 0
-				playerinfo.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-				CSPlayerInfo = append(CSPlayerInfo, playerinfo)
-			}
-			for j := int(playerCnt); j < 30; j++ {
-				StartRobotUin = StartRobotUin + 1
-				dwUin := StartRobotUin
-				enum := rand.Intn(4) + 1
-				res := strconv.Itoa(int(dwUin)) + "_" + "0" + "_" + "0" + "_" + "0" + "_" + "1" + "_" + strconv.Itoa(int(G_GameLogicPtr.M_SvrGlobal.CurChampshipsId)) + "_" + strconv.Itoa(enum)
-				strr = append(strr, res)
-				playerinfo := &msg.ChampshipsPlayerInfo{}
-				playerinfo.DwUin = int32(dwUin)
-				playerinfo.IsGet = 0
-				playerinfo.IsPlayer = 0
-				playerinfo.Score = 0
-				playerinfo.Times = 1
-				playerinfo.AIEnum = int32(enum)
-				playerinfo.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-				CSPlayerInfo = append(CSPlayerInfo, playerinfo)
-			}
-			temp.GroupRankData = strings.Join(strr, ";")
-			insertId, _ := db.FormatAllMemInsertDb(&temp, "t_championships_data")
-
-			p.MChampshipPlayerMap[int32(insertId)] = CSPlayerInfo
-
-			for j := 0; j < int(playerCnt); j++ {
-				dwUin := sqlStrucks[i*int(playerCnt)+j].DwUin
-				player, ok := G_GameLogicPtr.M_Players[dwUin]
-				if ok {
-					player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).SetChampshipID(int32(insertId), true)
-				} else {
-					player = G_GameLogicPtr.FindOfflinePlayer(dwUin)
-					if player != nil {
-						player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).SetChampshipID(int32(insertId), false)
-					} else {
-						sqlStrucks[i*int(playerCnt)+j].LastChampGroupID = sqlStrucks[i*int(playerCnt)+j].ChampshipsGroupID
-						sqlStrucks[i*int(playerCnt)+j].ChampshipsGroupID = int32(insertId)
-						db.FormatAllMemUpdateDb(&sqlStrucks[i*int(playerCnt)+j], "t_player_baseinfo", "dwUin")
-					}
-				}
-			}
-		} else {
-			remain := len(sqlStrucks) - (groups-1)*int(playerCnt)
-			cnt := 0
-			strr := []string{}
-			temp := db.SqlChampshipsStruct{}
-			temp.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-
-			CSPlayerInfo := []*msg.ChampshipsPlayerInfo{}
-
-			for j := 0; j < remain; j++ {
-				dwUin := sqlStrucks[i*int(playerCnt)+j].DwUin
-				res := strconv.Itoa(int(dwUin)) + "_" + "1" + "_" + "0" + "_" + "0" + "_" + "1" + "_" + strconv.Itoa(int(G_GameLogicPtr.M_SvrGlobal.CurChampshipsId)) + "_0"
-				strr = append(strr, res)
-				cnt = cnt + 1
-				playerinfo := &msg.ChampshipsPlayerInfo{}
-				playerinfo.DwUin = dwUin
-				playerinfo.IsGet = 0
-				playerinfo.IsPlayer = 1
-				playerinfo.Score = 0
-				playerinfo.Times = 1
-				playerinfo.AIEnum = 0
-				playerinfo.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-				CSPlayerInfo = append(CSPlayerInfo, playerinfo)
-			}
-			for j := cnt; j < 30; j++ {
-				StartRobotUin = StartRobotUin + 1
-				dwUin := StartRobotUin
-				enum := rand.Intn(4) + 1
-				res := strconv.Itoa(int(dwUin)) + "_" + "0" + "_" + "0" + "_" + "0" + "_" + "1" + "_" + strconv.Itoa(int(G_GameLogicPtr.M_SvrGlobal.CurChampshipsId)) + "_" + strconv.Itoa(enum)
-				strr = append(strr, res)
-				playerinfo := &msg.ChampshipsPlayerInfo{}
-				playerinfo.DwUin = int32(dwUin)
-				playerinfo.IsGet = 0
-				playerinfo.IsPlayer = 0
-				playerinfo.Score = 0
-				playerinfo.Times = 1
-				playerinfo.AIEnum = int32(enum)
-				playerinfo.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-				CSPlayerInfo = append(CSPlayerInfo, playerinfo)
-			}
-			temp.GroupRankData = strings.Join(strr, ";")
-			insertId, _ := db.FormatAllMemInsertDb(&temp, "t_championships_data")
-			p.MChampshipPlayerMap[int32(insertId)] = CSPlayerInfo
-			for j := 0; j < remain; j++ {
-				dwUin := sqlStrucks[i*int(playerCnt)+j].DwUin
-				player, ok := G_GameLogicPtr.M_Players[dwUin]
-				if ok {
-					player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).SetChampshipID(int32(insertId), true)
-				} else {
-					player = G_GameLogicPtr.FindOfflinePlayer(dwUin)
-					if player != nil {
-						player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).SetChampshipID(int32(insertId), false)
-					} else {
-
-						sqlStrucks[i*int(playerCnt)+j].LastChampGroupID = sqlStrucks[i*int(playerCnt)+j].ChampshipsGroupID
-						sqlStrucks[i*int(playerCnt)+j].ChampshipsGroupID = int32(insertId)
-						db.FormatAllMemUpdateDb(&sqlStrucks[i*int(playerCnt)+j], "t_player_baseinfo", "dwUin")
-					}
-				}
-			}
-		}
-	}
-	p.IsLoadDB = true
-
-	p.AIScoreGrowth1h()
-	db.FormatAllMemUpdateDb(&G_GameLogicPtr.M_SvrGlobal, "t_server_global_data", "Id")
-
-}
-
-func (p *ChampshipsManager) OpenChampShipTimes(args []interface{}) {
-	p.MStatus = 2
-	notify := &msg.NotifyChampshipTimesOpen{}
-	notify.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-	data, _ := proto.Marshal(notify)
-	G_GameLogicPtr.broadcastInfoAllPlayer("NotifyChampshipTimesOpen", data)
-}
-
-func (p *ChampshipsManager) CloseChampShipTimes(args []interface{}) {
-	p.MStatus = 1
-	notify := &msg.NotifyChampshipTimesClose{}
-	notify.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-	data, _ := proto.Marshal(notify)
-	G_GameLogicPtr.broadcastInfoAllPlayer("NotifyChampshipTimesClose", data)
-}
-
-func (p *ChampshipsManager) Notify_Clock_Tick_Sec(args []interface{}) {
-	timeStamp := args[0].(int64)
-	t := time.Unix(timeStamp, 0).Local()
-	zero := timeStamp - (int64)(t.Hour()*3600+t.Minute()*60+t.Second())
-	OpenTime := zero + MergeConst.G_Champion_Start_Offset
-	OpenTimesTime := zero + MergeConst.G_Champion_Start_Effect_Time
-	CloseTimesTime := zero + MergeConst.G_Champion_Start_Effect_Time + MergeConst.G_Champion_Start_Effect_Durtion
-	DeleteLastTimesTime := zero + MergeConst.G_Champion_settlement_Duration
-	if G_GameLogicPtr.M_SvrGlobal.StartChampshipsSvrTime < int32(OpenTime) { //今日没有开启
-		if timeStamp >= OpenTime { //开启
-			GoUtil.CallEvent(MergeConst.Notify_Champion_Renew, []interface{}{int32(OpenTime)})
-		} else {
-			//开启时间未到
-			if p.MStatus == 1 {
-				GoUtil.CallEvent(MergeConst.Notify_EndChampShip, []interface{}{int32(OpenTime)})
-			}
-
-		}
-	} else {
-		if p.MStatus == 0 {
-			p.MStatus = 1
-		}
-
-		if !p.IsLoadDB {
-			p.LoadDbDataByGroupId(G_GameLogicPtr.M_SvrGlobal.CurChampshipsId)
-			if G_GameLogicPtr.M_SvrGlobal.LastChampshipsId > 0 {
-				p.LoadDbDataByGroupId(G_GameLogicPtr.M_SvrGlobal.LastChampshipsId)
-			}
-			p.IsLoadDB = true
-		}
-	}
-
-	if p.MStatus == 1 {
-		if timeStamp >= OpenTimesTime && timeStamp <= CloseTimesTime {
-			GoUtil.CallEvent(MergeConst.Notify_OpenChampShipTimes, []interface{}{int32(OpenTime)})
-		}
-
-	}
-	if p.MStatus == 2 {
-		if timeStamp > CloseTimesTime {
-			GoUtil.CallEvent(MergeConst.Notify_CloseChampShipTimes, []interface{}{int32(OpenTime)})
-		}
-	}
-	if p.IsSettle == 0 {
-		if timeStamp <= DeleteLastTimesTime {
-			p.IsSettle = 1
-		} else {
-			if G_GameLogicPtr.M_SvrGlobal.LastChampshipsId > 0 {
-				p.DeleteOutLineChampship(G_GameLogicPtr.M_SvrGlobal.LastChampshipsId)
-				G_GameLogicPtr.M_SvrGlobal.LastChampshipsId = 0
-				db.FormatAllMemUpdateDb(&G_GameLogicPtr.M_SvrGlobal, "t_server_global_data", "Id")
-			}
-		}
-	}
-	if p.IsSettle == 1 {
-		if timeStamp > DeleteLastTimesTime {
-			notify := &msg.NotifyChampshipSettleClose{}
-			notify.LastChampshipsId = G_GameLogicPtr.M_SvrGlobal.LastChampshipsId
-			data, _ := proto.Marshal(notify)
-			G_GameLogicPtr.broadcastInfoAllPlayer("NotifyChampshipSettleClose", data)
-			p.IsSettle = 0
-			if G_GameLogicPtr.M_SvrGlobal.LastChampshipsId > 0 {
-				p.DeleteOutLineChampship(G_GameLogicPtr.M_SvrGlobal.LastChampshipsId)
-				G_GameLogicPtr.M_SvrGlobal.LastChampshipsId = 0
-				db.FormatAllMemUpdateDb(&G_GameLogicPtr.M_SvrGlobal, "t_server_global_data", "Id")
-			}
-
-		}
-	}
-}
-
-func (p *ChampshipsManager) EndChampShip(args []interface{}) {
-	p.MStatus = 0
-	G_GameLogicPtr.M_SvrGlobal.LastChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-	db.FormatAllMemUpdateDb(&G_GameLogicPtr.M_SvrGlobal, "t_server_global_data", "Id")
-
-	notify := &msg.NotifyChampshipSettleOpen{}
-	notify.LastChampshipsId = G_GameLogicPtr.M_SvrGlobal.LastChampshipsId
-	data, _ := proto.Marshal(notify)
-	G_GameLogicPtr.broadcastInfoAllPlayer("NotifyChampshipSettleOpen", data)
-
-	notify1 := &msg.NotifyChampshipClose{}
-	notify1.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-	data1, _ := proto.Marshal(notify1)
-	G_GameLogicPtr.broadcastInfoAllPlayer("NotifyChampshipClose", data1)
-
-	p.NotifyRenewChampshipData()
-}
-
-func (p *ChampshipsManager) NotifyRenewChampshipData() {
-	for i := 0; i < len(p.MUpdateNotifyList); i++ {
-		groupid := p.MUpdateNotifyList[i]
-		playerlist, ok := p.MChampshipPlayerMap[groupid]
-		if ok {
-			for j := 0; j < len(playerlist); j++ {
-				if playerlist[j].IsPlayer == 1 {
-					dwUin := playerlist[j].DwUin
-					player, ok1 := G_GameLogicPtr.M_Players[dwUin]
-					if ok1 {
-						agent := player.GetAgentByPlayer()
-						notify := &msg.NotifyUpdateChampshipRank{}
-						notify.ChampshipsGroupID = groupid
-						notify.GroupRankDataList = playerlist
-						data, _ := proto.Marshal(notify)
-						G_getGameLogic().PackResInfo(agent, "NotifyUpdateChampshipRank", data)
-					} else {
-
-					}
-				}
-			}
-		}
-	}
-	p.MUpdateNotifyList = p.MUpdateNotifyList[0:0]
-}
-
-func (p *ChampshipsManager) ReqChampshipData(player *Player, buf []byte) {
-	req := &msg.ReqChampshipData{}
-	proto.Unmarshal(buf, req)
-	res := &msg.ResChampshipData{}
-	_, ok := p.MChampshipPlayerMap[req.ChampshipsGroupID]
-	if ok {
-		res.GroupRankDataList = p.MChampshipPlayerMap[req.ChampshipsGroupID]
-	}
-	res.ChampshipsGroupID = req.ChampshipsGroupID
-	res.Status = p.MStatus
-	res.IsSettle = p.IsSettle
-	res.EndTime = G_GameLogicPtr.M_SvrGlobal.StartChampshipsSvrTime + MergeConst.G_Champion_Duration
-	res.EndSettleTime = G_GameLogicPtr.M_SvrGlobal.StartChampshipsSvrTime - MergeConst.G_Champion_Start_Offset + MergeConst.G_Champion_Start_Effect_Time + MergeConst.G_Champion_Start_Effect_Durtion
-	agent := player.GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResChampshipData", data)
-}
-
-func (p *ChampshipsManager) InitManager() {
-	GoUtil.RegisterEvent(MergeConst.Notify_Champion_Renew, p.OpenNewChampShip, p)
-	GoUtil.RegisterEvent(MergeConst.Notify_OpenChampShipTimes, p.OpenChampShipTimes, p)
-	GoUtil.RegisterEvent(MergeConst.Notify_CloseChampShipTimes, p.CloseChampShipTimes, p)
-	GoUtil.RegisterEvent(MergeConst.Notify_EndChampShip, p.EndChampShip, p)
-	GoUtil.RegisterEvent(MergeConst.Notify_Clock_Tick_Sec, p.Notify_Clock_Tick_Sec, p)
-	p.MChampshipMap = make(map[int32]*db.SqlChampshipsStruct)
-	p.MChampshipPlayerMap = make(map[int32][]*msg.ChampshipsPlayerInfo)
-	p.MStatus = 0
-	p.IsSettle = 0
-	p.IsLoadDB = false
-	p.MUpdateNotifyList = []int32{}
-	p.McronSave = cron.New()
-	p.McronSaveID, _ = p.McronSave.AddFunc("@every 70s", func() {
-		p.NotifyRenewChampshipData()
-	})
-	p.RobotCronID, _ = p.McronSave.AddFunc("@every 1h", func() {
-		p.AIScoreGrowth1h()
-	})
-
-	p.RobotCronID10s, _ = p.McronSave.AddFunc("@every 15m", func() {
-		if p.MStatus == 2 {
-			p.RobotIntervalAddScore15m()
-		}
-	})
-	p.McronSave.Start()
-}
-
-func (p *ChampshipsManager) RobotIntervalAddScore() {
-	seed := time.Now().Unix()
-	rand.Seed(seed)
-	needToUpdateDb := []int32{}
-	for k, v := range p.MChampshipPlayerMap {
-		ishaveRobot := false
-		for i := 0; i < len(v); i++ {
-			if v[i].IsPlayer == 0 {
-				ishaveRobot = true
-				addScore := 3
-				ran := rand.Intn(100) + 1
-				if ran <= 25 {
-					addScore = addScore + 1
-				} else {
-					if ran <= 50 {
-						addScore = addScore + 2
-					}
-				}
-				v[i].Score = v[i].Score + int32(addScore)
-			}
-		}
-		if ishaveRobot {
-			sort.Slice(v, func(i, j int) bool { return v[i].Score > v[j].Score })
-			isAdd := false
-			for i := 0; i < len(p.MUpdateNotifyList); i++ {
-				if p.MUpdateNotifyList[i] == k {
-					isAdd = true
-					break
-				}
-			}
-			if !isAdd {
-				p.MUpdateNotifyList = append(p.MUpdateNotifyList, k)
-			}
-			needToUpdateDb = append(needToUpdateDb, k)
-
-		}
-
-	}
-	for i := 0; i < len(needToUpdateDb); i++ {
-		p.SaveDbDataByGroupId(needToUpdateDb[i])
-	}
-}
-
-func (p *ChampshipsManager) GetMinGroupId() int32 {
-	var Min int32 = 0
-	for k := range p.MChampshipPlayerMap {
-		if Min == 0 {
-			Min = k
-			continue
-		}
-		if k < Min {
-			Min = k
-		}
-	}
-	return Min
-}
-
-func (p *ChampshipsManager) AIScoreGrowth1h() {
-	seed := time.Now().Unix()
-	rand.Seed(seed)
-	needToUpdateDb := []int32{}
-	// MinGroupId := p.GetMinGroupId()
-	for k, v := range p.MChampshipPlayerMap {
-		ishaveRobot := false
-		groupId := 0 //k - MinGroupId + 1
-		for i := 0; i < len(v); i++ {
-			if v[i].IsPlayer == 0 {
-				ishaveRobot = true
-				addScore := 0
-				if v[i].AIEnum == 1 {
-					var num1 float64 = 0.5
-					var num2 float64 = 5.5
-					groupId = rand.Intn(7) + 1
-					addScore = addScore + int(math.Floor(float64(groupId-1)*num1*num2))
-				}
-				if v[i].AIEnum == 2 {
-					addScore = 16
-
-					ran := rand.Intn(100) + 1
-					if ran <= 25 {
-						addScore = addScore + 6
-					} else {
-						if ran <= 50 {
-							addScore = addScore + 10
-						}
-					}
-				}
-				if v[i].AIEnum == 3 {
-					addScore = 16
-
-					ran := rand.Intn(100) + 1
-					if ran <= 25 {
-						addScore = addScore + 10
-					} else {
-						if ran <= 75 {
-							addScore = addScore + 6
-						}
-					}
-					var num1 float64 = 0.5
-					var num2 float64 = 5.5
-					groupId = rand.Intn(7) + 1
-					addScore = addScore + int(math.Floor(float64(groupId-1)*num1*num2))
-				}
-				if v[i].AIEnum == 4 {
-					var num1 float64 = 0.5
-					var num2 float64 = 5.5
-					groupId = rand.Intn(7) + 1
-					addScore = addScore + int(math.Floor(float64(groupId-1)*num1*num2))
-					score := rand.Intn(23)
-					addScore = addScore + score
-				}
-				v[i].Score = v[i].Score + int32(addScore)
-			}
-		}
-		if ishaveRobot {
-			sort.Slice(v, func(i, j int) bool { return v[i].Score > v[j].Score })
-			isAdd := false
-			for i := 0; i < len(p.MUpdateNotifyList); i++ {
-				if p.MUpdateNotifyList[i] == k {
-					isAdd = true
-					break
-				}
-			}
-			if !isAdd {
-				p.MUpdateNotifyList = append(p.MUpdateNotifyList, k)
-			}
-			needToUpdateDb = append(needToUpdateDb, k)
-
-		}
-
-	}
-	for i := 0; i < len(needToUpdateDb); i++ {
-		p.SaveDbDataByGroupId(needToUpdateDb[i])
-	}
-}
-
-func (p *ChampshipsManager) RobotIntervalAddScore15m() {
-	seed := time.Now().Unix()
-	rand.Seed(seed)
-	needToUpdateDb := []int32{}
-	for k, v := range p.MChampshipPlayerMap {
-		ishaveRobot := false
-		for i := 0; i < len(v); i++ {
-			if v[i].IsPlayer == 0 {
-
-				addScore := 0
-				if v[i].AIEnum == 1 {
-
-					ran := rand.Intn(100) + 1
-					if ran <= 25 {
-						addScore = addScore + 10
-					} else {
-						if ran <= 75 {
-							addScore = addScore + 6
-						}
-					}
-					ran = rand.Intn(100) + 1
-					if ran <= 25 {
-						addScore = addScore + 5
-					} else {
-						if ran <= 50 {
-							addScore = addScore + 10
-						}
-					}
-					if addScore > 0 {
-						ishaveRobot = true
-						v[i].Score = v[i].Score + int32(addScore)
-					}
-
-				}
-
-			}
-		}
-		if ishaveRobot {
-			sort.Slice(v, func(i, j int) bool { return v[i].Score > v[j].Score })
-			isAdd := false
-			for i := 0; i < len(p.MUpdateNotifyList); i++ {
-				if p.MUpdateNotifyList[i] == k {
-					isAdd = true
-					break
-				}
-			}
-			if !isAdd {
-				p.MUpdateNotifyList = append(p.MUpdateNotifyList, k)
-			}
-			needToUpdateDb = append(needToUpdateDb, k)
-
-		}
-
-	}
-	for i := 0; i < len(needToUpdateDb); i++ {
-		p.SaveDbDataByGroupId(needToUpdateDb[i])
-	}
-}
-func (p *ChampshipsManager) SaveDbDataByGroupId(GroupId int32) {
-	_, ok := p.MChampshipPlayerMap[GroupId]
-	if ok {
-		List := p.MChampshipPlayerMap[GroupId]
-		strr := []string{}
-		for i := 0; i < len(List); i++ {
-			Item := List[i]
-			unit := strconv.Itoa(int(Item.DwUin)) + "_" + strconv.Itoa(int(Item.IsPlayer)) + "_" + strconv.Itoa(int(Item.Score)) + "_" + strconv.Itoa(int(Item.IsGet)) + "_" + strconv.Itoa(int(Item.Times)) + "_" + strconv.Itoa(int(Item.CurChampshipsId)) + "_" + strconv.Itoa(int(Item.AIEnum))
-			strr = append(strr, unit)
-		}
-		data := strings.Join(strr, ";")
-		sqlStruct := &db.SqlChampionshipsStruct{}
-		sqlStruct.ChampshipsGroupID = GroupId
-		sqlStruct.GroupRankData = data
-		sqlStruct.CurChampshipsId = List[0].CurChampshipsId
-		db.FormatAllMemUpdateDb(sqlStruct, "t_championships_data", "ChampshipsGroupID")
-	}
-}
-
-func (p *ChampshipsManager) LoadDbDataByGroupId(ChampshipsId int32) {
-
-	sqlStr := "SELECT * FROM t_championships_data WHERE CurChampshipsId = ?"
-
-	sqlStruck := []db.SqlChampionshipsStruct{}
-
-	if err := db.SqlDb.Select(&sqlStruck, sqlStr, ChampshipsId); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
-
-	} else {
-		for m := 0; m < len(sqlStruck); m++ {
-			units := strings.Split(sqlStruck[m].GroupRankData, ";")
-			list := []*msg.ChampshipsPlayerInfo{}
-			for i := 0; i < len(units); i++ {
-				item := units[i]
-				strr := strings.Split(item, "_")
-				temp := &msg.ChampshipsPlayerInfo{}
-				dwuin, _ := strconv.Atoi(strr[0])
-				temp.DwUin = int32(dwuin)
-				IsPlayer, _ := strconv.Atoi(strr[1])
-				temp.IsPlayer = int32(IsPlayer)
-				Score, _ := strconv.Atoi(strr[2])
-				temp.Score = int32(Score)
-				IsGet, _ := strconv.Atoi(strr[3])
-				temp.IsGet = int32(IsGet)
-				Times, _ := strconv.Atoi(strr[4])
-				temp.Times = int32(Times)
-				CS, _ := strconv.Atoi(strr[5])
-				temp.CurChampshipsId = int32(CS)
-				AI, _ := strconv.Atoi(strr[6])
-				temp.AIEnum = int32(AI)
-				list = append(list, temp)
-			}
-			p.MChampshipPlayerMap[sqlStruck[m].ChampshipsGroupID] = list
-		}
-	}
-
-}
-
-func (p *ChampshipsManager) ReqChampshipAddScore(player *Player, buf []byte) {
-	req := &msg.ReqChampshipAddScore{}
-	proto.Unmarshal(buf, req)
-	res := &msg.ResChampshipAddScore{}
-
-	if p.MStatus == 0 {
-		res.ResultCode = MergeConst.Protocol_Champship_End
-	} else {
-		_, ok := p.MChampshipPlayerMap[req.GroupId]
-		if ok {
-			List := p.MChampshipPlayerMap[req.GroupId]
-			isHave := false
-			for i := 0; i < len(List); i++ {
-				if List[i].DwUin == player.M_DwUin {
-					List[i].Score = List[i].Score + req.AddScore
-					res.ResultCode = 0
-					isHave = true
-					break
-				}
-			}
-			sort.Slice(List, func(i, j int) bool { return List[i].Score > List[j].Score })
-			if !isHave {
-				res.ResultCode = MergeConst.Protocol_Champship_No_Join
-			} else {
-				res.GroupRankDataList = List
-				isAdd := false
-				for i := 0; i < len(p.MUpdateNotifyList); i++ {
-					if p.MUpdateNotifyList[i] == req.GroupId {
-						isAdd = true
-						break
-					}
-				}
-				if !isAdd {
-					p.MUpdateNotifyList = append(p.MUpdateNotifyList, req.GroupId)
-				}
-
-				p.SaveDbDataByGroupId(req.GroupId)
-			}
-		} else {
-			res.ResultCode = MergeConst.Protocol_Champship_No_Exsit
-		}
-	}
-
-	res.GroupId = req.GroupId
-	agent := player.GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResChampshipAddScore", data)
-}
-
-func (p *ChampshipsManager) ReqChampshipAddTime(player *Player, buf []byte) {
-	req := &msg.ReqChampshipAddTime{}
-	proto.Unmarshal(buf, req)
-	res := &msg.ResChampshipAddTime{}
-	if p.MStatus == 0 {
-		res.ResultCode = MergeConst.Protocol_Champship_End
-	} else {
-		_, ok := p.MChampshipPlayerMap[req.GroupId]
-		if ok {
-			List := p.MChampshipPlayerMap[req.GroupId]
-			isHave := false
-			for i := 0; i < len(List); i++ {
-				if List[i].DwUin == player.M_DwUin {
-					List[i].Times = List[i].Times + req.AddTimes
-					res.ResultCode = 0
-					isHave = true
-					break
-				}
-			}
-			sort.Slice(List, func(i, j int) bool { return List[i].Score > List[j].Score })
-			if !isHave {
-				res.ResultCode = MergeConst.Protocol_Champship_No_Join
-			} else {
-				res.GroupRankDataList = List
-				p.SaveDbDataByGroupId(req.GroupId)
-			}
-		} else {
-			res.ResultCode = MergeConst.Protocol_Champship_No_Exsit
-		}
-	}
-	res.GroupId = req.GroupId
-
-	agent := player.GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResChampshipAddTime", data)
-}

src/server/game/ChargeFunc.go

@@ -1,30 +1,123 @@
 package game
 
-import "server/pkg/github.com/name5566/leaf/log"
+import (
+	"server/GoUtil"
+	activityCfg "server/conf/activity"
+	"server/game/mod/item"
+	MsgMod "server/game/mod/msg"
+	"server/game/mod/piggyBank"
+	"server/game/mod/quest"
+	"server/msg"
+	"server/pkg/github.com/name5566/leaf/log"
+)
 
 func Charge(p *Player, ChargeId int) {
 	ChargeFire(p, ChargeId)    // 充值
 	EndlessFire(p, ChargeId)   // 无尽礼包
 	PiggyBankFire(p, ChargeId) // 猪猪银行
+	PlayroomFire(p, ChargeId)  // 游乐场
+	ActivityFire(p, ChargeId)  // 活动礼包
+	ADPetWorkFire(p, ChargeId) // 广告宠物工作
+	OrderMod := p.PlayMod.getOrderMod()
+	OrderMod.SetIsCharge() // 设置订单模块为充值状态
+	p.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_PURCHASE, A: []interface{}{}})
+}
+
+func SendCharge(p *Player, d *ChargeExtra) {
+	G_GameLogicPtr.FriendMgrSend(&MsgMod.Msg{
+		From:  int(p.M_DwUin),
+		Type:  MsgMod.HANDLE_TYPE_SEND_CHARGE,
+		To:    int(d.Uid),
+		SendT: GoUtil.Now(),
+		Extra: d,
+	})
+}
+
+func ADPetWorkFire(p *Player, ChargeId int) {
+	ChargeMod := p.PlayMod.getChargeMod()
+	Item := ChargeMod.FireAdReward(ChargeId)
+	if Item == nil {
+		return
+	}
+	err := p.HandleItem(Item, msg.ITEM_POP_LABEL_ActivityGift.String())
+	if err != nil {
+		log.Debug("ChargeFire err : %s", err)
+		return
+	}
+	p.PlayMod.save()
+	p.PushClientRes(ChargeMod.BackData())
+}
+
+func ActivityFire(p *Player, ChargeId int) {
+	ActivityMod := p.PlayMod.getActivityMod()
+	ActivityId := activityCfg.GetActivityGiftId(ChargeId)
+	ActivityInfo := GetActivityInfoById(p, ActivityId)
+	if ActivityInfo == nil {
+		log.Debug("ActivityFire ActivityInfo nil : player id :%d, charge id:%d", p.M_DwUin, ChargeId)
+		return
+	}
+	Item, err := ActivityMod.Fire(ChargeId)
+	if err != nil {
+		log.Debug("ActivityFire err : %s", err)
+		return
+	}
+	if Item == nil {
+		return
+	}
+	err = p.HandleItem(Item, msg.ITEM_POP_LABEL_ActivityGift.String())
+	if err != nil {
+		log.Debug("ChargeFire err : %s", err)
+		return
+	}
+	p.PlayMod.save()
+	p.initAcitivity()
+	p.BackDataActivity()
+}
+
+func PlayroomFire(p *Player, ChargeId int) {
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	Item := PlayroomMod.Fire(ChargeId)
+	if Item == nil {
+		return
+	}
+	err := p.HandleItem(Item, msg.ITEM_POP_LABEL_Playroom.String())
+	if err != nil {
+		log.Debug("ChargeFire err : %s", err)
+	}
+	p.TeLog("get_assist_battery", map[string]interface{}{
+		"assist_battery _type": "charge",
+	})
+	p.PlayMod.save()
 }
 
 func PiggyBankFire(p *Player, ChargeId int) {
 	PiggyBankMod := p.PlayMod.getPiggyBankMod()
 	Item := PiggyBankMod.Fire(ChargeId)
-	err := p.HandleItem(Item, "PiggyBank")
+	if Item == nil {
+		return
+	}
+	err := p.HandleItem(Item, msg.ITEM_POP_LABEL_PiggyBank.String())
 	if err != nil {
 		log.Debug("ChargeFire err : %s", err)
 	}
 	LimitedTimePiggyBankTrigger(p)
+	p.TeLog("piggy_bank_open", map[string]interface{}{
+		"piggy_bank_type": piggyBank.PIGGY_BANK_TYPE_CHARGE,
+		"item_list":       Item,
+		"open_cost":       ChargeId,
+	})
 	p.PlayMod.save()
-	p.PushClientRes(PiggyBankMod.BackData())
+
 }
 
 // 处理玩家充值
 func ChargeFire(p *Player, ChargeId int) {
 	ChargeMod := p.PlayMod.getChargeMod()
 	Item := ChargeMod.Fire(ChargeId)
-	err := p.HandleItem(Item, "Charge")
+	if Item == nil {
+		return
+	}
+	err := p.HandleItem(Item, msg.ITEM_POP_LABEL_Charge.String())
 	if err != nil {
 		log.Debug("ChargeFire err : %s", err)
 	}
@@ -32,6 +125,12 @@ func ChargeFire(p *Player, ChargeId int) {
 	p.PushClientRes(ChargeMod.BackData())
 }
 
+func ChargeItem(p *Player, ChargeId int) []*item.Item {
+	ChargeMod := p.PlayMod.getChargeMod()
+	Item := ChargeMod.Fire(ChargeId)
+	return Item
+}
+
 // 处理玩家充值
 func EndlessFire(p *Player, ChargeId int) {
 	EndlessMod := p.PlayMod.getEndlessMod()
@@ -39,7 +138,7 @@ func EndlessFire(p *Player, ChargeId int) {
 	if Item == nil {
 		return
 	}
-	err := p.HandleItem(Item, "Endless")
+	err := p.HandleItem(Item, msg.ITEM_POP_LABEL_Endless.String())
 	if err != nil {
 		log.Debug("ChargeFire err : %s", err)
 	}

src/server/game/ClusterMgr.go

@@ -3,7 +3,6 @@ package game
 import (
 	mergeCluster "server/cluster"
 	"server/game/mod/msg"
-	"server/pkg/github.com/name5566/leaf/log"
 )
 
 var clusterHandler map[int]func(*msg.Msg) error
@@ -19,11 +18,10 @@ func ClusterMgrInit() {
 }
 
 func clusterHandlerProcess(m *msg.Msg) {
-	log.Debug("clusterHandlerProcess m %v", m)
 	if fun, ok := clusterHandler[m.Type]; ok {
 		fun(m)
 	} else {
-		log.Debug("clusterHandlerProcess not found handler %d", m.Type)
+		FriendMgrSend(m)
 	}
 }
 

src/server/game/CompensationFunc.go

@@ -0,0 +1,34 @@
+package game
+
+import (
+	"server/game/mod/compensation"
+	"server/game/mod/mail"
+)
+
+func (p *Player) Compensation() {
+	p.Compensation20250910()
+}
+
+func (p *Player) Compensation20250910() {
+	compensationMod := p.PlayMod.getCompensationMod()
+	if compensationMod.Is20250910() {
+		return // 已经领取过补偿
+	}
+	PlayerBaseMod := p.GetPlayerBaseMod()
+	items := compensationMod.Compensation20250910(PlayerBaseMod.GetName())
+	if len(items) == 0 {
+		return // 没有补偿物品
+	}
+	MailMod := p.PlayMod.getMailMod()
+	MailMod.SendMail(&mail.MailStruct{
+		Title:      compensation.Compensation20250910_Mail_Config.Title,
+		SubTitle:   "",
+		Content:    compensation.Compensation20250910_Mail_Config.Content,
+		TitleEn:    compensation.Compensation20250910_Mail_Config.Title,
+		SubTitleEn: "",
+		ContentEn:  compensation.Compensation20250910_Mail_Config.Content,
+		Items:      items,
+		Type:       mail.MAIL_TYPE_NORMAL,
+	})
+	p.PlayMod.save()
+}

src/server/game/FriendMgr.go

@@ -1,10 +1,14 @@
 package game
 
 import (
+	"encoding/gob"
 	"fmt"
 	"server/GoUtil"
+	"server/MergeConst"
 	mergeCluster "server/cluster"
 	"server/conf"
+	"server/game/mod/card"
+	"server/game/mod/item"
 	"server/game/mod/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 )
@@ -14,12 +18,17 @@ type FriendMgr struct {
 }
 
 type FirendData struct {
-	List       map[int][]*msg.Msg
-	ClusterMsg map[int][]*msg.Msg
+	Id         int64
+	List       map[int][]*msg.Msg // 本服信箱
+	ClusterMsg map[int][]*msg.Msg // 集群信箱
 }
 
 func (f *FriendMgr) Init() {
 
+	gob.Register(card.CardInfo{})
+	gob.Register(item.Item{})
+	gob.Register([]*item.Item{}) // 注册 []*item.Item 类型
+
 	f.key = FRIEND_MGR_KEY
 	f.data = &FirendData{
 		List:       make(map[int][]*msg.Msg),
@@ -27,10 +36,19 @@ func (f *FriendMgr) Init() {
 	}
 	// 注册处理函数
 	f.init()
+	if f.data.(*FirendData).List == nil {
+		f.data.(*FirendData).List = make(map[int][]*msg.Msg)
+	}
+	if f.data.(*FirendData).ClusterMsg == nil {
+		f.data.(*FirendData).ClusterMsg = make(map[int][]*msg.Msg)
+	}
 	f.RegisterHandler(msg.HANDLE_TYPE_APPLY, f.sendToPlayer)
 	f.RegisterHandler(msg.HADNLE_TYPE_AGREE, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_DEL, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_SYNC, f.sync)
+	f.RegisterHandler(msg.HANDLE_TYPE_REFUSE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_INVITE_ADD_FRIEND, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_INVITE_FRIEND, f.sendToPlayer)
 
 	// 卡牌消息
 	f.RegisterHandler(msg.HANDLE_TYPE_REQ_CARD, f.sendToPlayer)
@@ -43,49 +61,167 @@ func (f *FriendMgr) Init() {
 	f.RegisterHandler(msg.HANDLE_TYPE_ARGREE_EX_CARD, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_REFUSE_SELECT_CARD, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_REFUSE_EX_CARD, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_SEND_CARD, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_PLAYROOM_LOSE, f.sendToPlayer)
 
+	f.RegisterHandler(msg.FRIEND_TREASURE_HANDLE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_HANDBOOK_COLLECTION, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_HANDBOOK_UPVOTE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_SEND_CHARGE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_CHARGE_RECEIVE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_WISHLIST_SEND, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_WISHLIST_AGREE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_PLAYROOM_UPVOTE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_CHAMPSHIP_RESULT, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_TREASURE_RESULT, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_FACEBOOK_UNBIND, f.sendToPlayer)
+
+	f.RegisterHandler(msg.HANDLE_TYPE_CATNIP_INVITE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_CATNIP_AGREE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_CATNIP_REFUSE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_CATNIP_GROWTH, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_CATNIP_AGREE_DEL, f.sendToPlayer)
+
+	f.RegisterHandler(msg.HANDLE_TYPE_PLAYROOM_KISS, f.sendToPlayerOnline)
+	f.RegisterHandler(msg.HANDLE_TYPE_PLAYROOM_GAME, f.sendToPlayer)
+
+	f.RegisterHandler(msg.HANDLE_TYPE_VAR_USER_GET, f.GetVarUserData)
+	f.RegisterHandler(msg.HANDLE_TYPE_VAR_USER_SET, f.SetVarUserData)
+
+	f.RegisterHandler(msg.HANDLE_TYPE_VAR_EXPIRE_SET, f.SetExpireVarData)
 }
 
 func (f *FriendMgr) getData() *FirendData {
 	return f.data.(*FirendData)
 }
 
+func (f *FriendMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {
+	Now := GoUtil.Now()
+	for k, v := range f.getData().List {
+		for j, msg := range v {
+			if msg.End < Now-7*24*3600 {
+				f.getData().List[k] = append(f.getData().List[k][:j], f.getData().List[k][j+1:]...)
+			}
+		}
+	}
+	return nil, nil
+}
+
 // 通知玩家
 func (f *FriendMgr) sendToPlayer(m *msg.Msg) (interface{}, error) {
+	f.getData().Id++
+	m.Id = f.getData().Id
 	err := sendToPlayer(m)
-	if err != nil {
-		log.Debug("send to player error : %s\n", err)
+	if err == nil {
+		m.H = 1
+	}
 	ToServerId := GoUtil.GetServerIdByUid(m.To)
 	if ToServerId != conf.Server.ServerID {
 		f.getData().ClusterMsg[m.To] = append(f.getData().ClusterMsg[m.To], m) // 保存到集群消息
 	} else {
 		f.getData().List[m.To] = append(f.getData().List[m.To], m) // 保存到本地消息
 	}
-		f.update = true
-		return nil, err
-	}
-	log.Debug("send to player success")
+	log.Debug("send to player %d success, msg :%v", m.To, m)
+	return nil, nil
+}
+
+// 通知玩家
+func (f *FriendMgr) sendToPlayerOnline(m *msg.Msg) (interface{}, error) {
+	f.getData().Id++
+	m.Id = f.getData().Id
+	sendToPlayerOnline(m)
 	return nil, nil
 }
 
 // 同步信息
 func (f *FriendMgr) sync(m *msg.Msg) (interface{}, error) {
 	data := f.getData().List[m.From]
-	f.getData().List[m.From] = make([]*msg.Msg, 0)
 	return data, nil
 }
 
+func (f *FriendMgr) GetVarUserData(m *msg.Msg) (interface{}, error) {
+	Key := GoUtil.GetUserKey(int64(m.To))
+	data := G_GameLogicPtr.VarMgr.GetUserVar(Key)
+	if data == nil {
+		data = &VarUserData{
+			Upvote: 0,
+		}
+	}
+	return data, nil
+}
+
+func (f *FriendMgr) SetVarUserData(m *msg.Msg) (interface{}, error) {
+	VarOp := m.Extra.(VarOpration)
+	Key := GoUtil.GetUserKey(int64(m.To))
+	data := G_GameLogicPtr.VarMgr.GetUserVar(Key)
+	switch VarOp.Type {
+	case VAR_OP_UPVOTE:
+		data.Upvote++
+	case VAR_OP_CHIP:
+		data.Chip += VarOp.Data.(int)
+	case VAR_OP_CHIP_SET:
+		data.Chip = VarOp.Data.(int)
+	case VAR_OP_KISS:
+		data.Kiss = VarOp.Data.(int)
+	}
+	return &VarOpration{
+		Data: data,
+		Code: MergeConst.SUCCESS,
+	}, nil
+}
+
+func (f *FriendMgr) SetExpireVarData(m *msg.Msg) (interface{}, error) {
+	VarOp := m.Extra.(VarOpration)
+	switch VarOp.Type {
+	case VAR_OP_CATNIP_LOCK:
+		data := VarOp.Data.(CatnipLock)
+		MyKey := GoUtil.GetCatnipLockKey(data.Uid, data.GameId)
+		OtherKey := GoUtil.GetCatnipLockKey(data.Partner, data.GameId)
+		ExpireData := G_GameLogicPtr.VarMgr.GetExpireVar(OtherKey)
+		if _, ok := ExpireData.D.(*CatnipLock); ok {
+			return nil, fmt.Errorf("catnip lock already exists for %d in game %d", data.Uid, data.GameId)
+		}
+		G_GameLogicPtr.VarMgr.SetExpireVar(MyKey, &VarExpireData{
+			T: int64(data.End + 24*3600), // 设置过期时间
+			D: &data,
+		})
+		G_GameLogicPtr.VarMgr.SetExpireVar(OtherKey, &VarExpireData{
+			T: int64(data.End + 24*3600), // 设置过期时间
+			D: &CatnipLock{
+				Uid:     data.Partner,
+				Partner: data.Uid,
+				GameId:  data.GameId,
+				End:     data.End,
+			},
+		})
+	}
+	return nil, nil
+}
+
 // 发送消息给玩家
 func sendToPlayer(m *msg.Msg) error {
-	p := G_GameLogicPtr.GetPlayerByUid(m.To)
+	p := G_GameLogicPtr.GetPlayer(int64(m.To))
 	if p == nil || p.stop {
 		return fmt.Errorf("player %d not online", m.To)
 	}
-	p.SendMsg(m)
+	p.Send(m.Clone())
 	return nil
 }
 
-func FriendMgrSend(m *msg.Msg) error {
+func sendToPlayerOnline(m *msg.Msg) error {
+	p := G_GameLogicPtr.GetPlayer(int64(m.To))
+	if p == nil || p.stop {
+		return fmt.Errorf("player %d not online", m.To)
+	}
+	p.Send(m.Clone())
+	return nil
+}
+
+func FriendMgrSend(m1 *msg.Msg) error {
+	if m1.SendT == 0 {
+		m1.SendT = GoUtil.Now()
+	}
+	m := m1.Clone()
 	ToServer := GoUtil.GetServerIdByUid(m.To)
 	if ToServer != conf.Server.ServerID {
 		err := mergeCluster.SendServerMsg(m, ToServer)
@@ -101,15 +237,29 @@ func FriendMgrSend(m *msg.Msg) error {
 
 // 集群好友消息同步
 func ClusterFriendSync(m *msg.Msg) error {
-	log.Debug("ClusterFriendSync")
 	if v, ok := G_GameLogicPtr.FriendMgr.getData().ClusterMsg[m.To]; ok {
 		for _, msg := range v {
-			mergeCluster.SendServerMsg(msg, m.To)
+			if msg.H == 1 {
+				continue
+			}
+			err := mergeCluster.SendServerMsg(msg.Clone(), m.To)
+			if err == nil {
+				msg.H = 1
+			}
 		}
 	}
 	return nil
 }
 
 func FriendMgrCall(m *msg.Msg) interface{} {
-	return G_GameLogicPtr.FriendMgrCall(m)
+	ToServer := GoUtil.GetServerIdByUid(m.To)
+	if ToServer != conf.Server.ServerID {
+		r, err := mergeCluster.CallServerMsg(m, ToServer)
+		if err != nil { // 区服不在线
+			log.Debug("FriendMgrCall err %v", err)
+			return nil
+		}
+		return r
+	}
+	return G_GameLogicPtr.FriendMgrCall(m.Clone())
 }

src/server/game/Gm.go

@@ -1,29 +1,69 @@
 package game
 
 import (
+	"encoding/gob"
+	"fmt"
+	"os"
+	"server/GoUtil"
+	"server/conf"
+	avatarCfg "server/conf/avatar"
+	cardCfg "server/conf/card"
+	chargeCfg "server/conf/charge"
+	emojiCfg "server/conf/emoji"
+	faceCfg "server/conf/face"
+	mergeDataCfg "server/conf/mergeData"
+	playroomCfg "server/conf/playroom"
+	"server/db"
+	"server/game/mod/activity"
+	"server/game/mod/avatar"
 	"server/game/mod/card"
+	"server/game/mod/decorate"
+	"server/game/mod/emoji"
+	"server/game/mod/face"
+	"server/game/mod/friend"
+	"server/game/mod/handbook"
 	"server/game/mod/item"
+	MsgMod "server/game/mod/msg"
+	"server/game/mod/order"
+	"server/game/mod/playroom"
 	"server/msg"
+	"server/pkg/github.com/name5566/leaf/log"
 	"strconv"
 	"strings"
 
 	"google.golang.org/protobuf/proto"
 )
 
-func ReqGmCommand(args []interface{}) error {
-	_, player, buf := ParseArgs(args)
+func ReqGmCommand(player *Player, buf []byte) error {
+	// if conf.Server.GameName != "pet_home" && conf.Server.GameName != "merge_pet_sdk" {
+	// 	return fmt.Errorf("Player %d ReqGmCommand not support in game %s", player.M_DwUin, conf.Server.GameName)
+	// }
 	detail := &msg.ReqGmCommand{}
 	proto.Unmarshal(buf, detail)
-	arg := strings.Split(detail.Command, " ")
+	return ReqGmCommand_(player, detail.Command)
+}
+func ReqGmCommand_(player *Player, Command string) error {
+	// defer func() {
+	// 	if err := recover(); err != nil {
+	// 		log.Error("ReqGmCommand panic: %v", err)
+	// 	}
+	// }()
+	if conf.Server.GameName != "pet_home" && conf.Server.GameName != "merge_pet_sdk" && conf.Server.GameName != "Merge_Pet_Local" && conf.Server.GameName != "merge_pet_audit" {
+		return fmt.Errorf("Player %d ReqGmCommand not support in game %s, command %s", player.M_DwUin, conf.Server.GameName, Command)
+	}
+	player.TeLog("gm", map[string]interface{}{
+		"command": Command,
+	})
+	arg := strings.Split(Command, " ")
 	switch arg[0] {
 	case "additem":
 		id, _ := strconv.Atoi(arg[1])
 		num, _ := strconv.Atoi(arg[2])
-		player.HandleItem([]*item.Item{item.NewItem(id, num)}, "GM")
+		player.HandleItem([]*item.Item{item.NewItem(id, num)}, msg.ITEM_POP_LABEL_GM.String())
 	case "subitem":
 		id, _ := strconv.Atoi(arg[1])
 		num, _ := strconv.Atoi(arg[2])
-		player.HandleItem([]*item.Item{item.NewItem(id, -num)}, "GM")
+		player.HandleItem([]*item.Item{item.NewItem(id, -num)}, msg.ITEM_POP_LABEL_GM.String())
 	case "reset_order":
 		player.PlayMod.mod_list.Order.Step = 0
 		player.PlayMod.mod_list.Order.InitData()
@@ -32,35 +72,461 @@ func ReqGmCommand(args []interface{}) error {
 		num, _ := strconv.Atoi(arg[1])
 		player.PlayMod.mod_list.Card.ExchangeStar += num
 		player.PushClientRes(player.PlayMod.mod_list.Card.BackData())
+	case "add_card":
+		Id, _ := strconv.Atoi(arg[1])
+		player.PlayMod.mod_list.Card.AddCard(Id)
+		player.PushClientRes(player.PlayMod.mod_list.Card.NotifyCard())
+	case "reset_card_reward":
+		player.PlayMod.mod_list.Card.CollectReward = make(map[int]struct{})
+		player.PlayMod.mod_list.Card.AllCollect = 0
+		player.PushClientRes(player.PlayMod.mod_list.Card.BackData())
 	case "addexp":
 		num, _ := strconv.Atoi(arg[1])
-		player.GetPlayerBaseMod().AddExp(num)
+		player.GetPlayerBaseMod().AddExp(player, num, 0)
 		player.PushClientRes(&player.GetPlayerBaseMod().Data)
+	case "addDailyActive":
+		num, _ := strconv.Atoi(arg[1])
+		DailyMod := player.PlayMod.getDailyTaskMod()
+		DailyMod.Active = num
+		player.PushClientRes(DailyMod.BackData())
+	case "triggerOrder":
+		OrderMod := player.PlayMod.getOrderMod()
+		ChessMod := player.PlayMod.getChessMod()
+		OrderMod.TriggerOrder(player.GetPlayerBaseMod().GetLevel(), order.TRIGGER_TYPE_ORDER, ChessMod.GetEmitList(), 1)
+		player.PushClientRes(OrderMod.BackData())
 	case "setlv":
 		num, _ := strconv.Atoi(arg[1])
-		player.GetPlayerBaseMod().Data.Level = int32(num)
-		player.GetPlayerBaseMod().Data.Exp = 0
-		player.PushClientRes(&player.GetPlayerBaseMod().Data)
+		player.PlayMod.getBaseMod().Level = num
+		player.PlayMod.getBaseMod().Exp = 0
+		player.PushClientRes(player.PlayerBaseMod.BackAsset())
+		player.initAcitivity()
+		player.PlayMod.getGuideTaskMod().Unlock(num)
+		player.PlayMod.getOrderMod().TriggerOrder(num, order.TRIGGER_TYPE_LV, nil, 1)
+		player.PushClientRes(player.PlayMod.getOrderMod().BackData())
+		player.BackDataActivity()
 	case "zeroUpdate":
-		player.PlayMod.getVarMod().DailyResetTime = 0
-		player.ZeroUpdate([]interface{}{})
+		VarMod := player.PlayMod.getVarMod()
+		VarMod.DailyResetTime = 0
+		player.ZeroUpdate(nil)
+		player.LoginBackData()
+	case "addChampshipLog":
+		num, _ := strconv.Atoi(arg[1])
+		player.AddLog(num, friend.LOG_TYPE_PLAYROOM_CHAMPSHIP, fmt.Sprintf("%d_%d", 1, 1), GoUtil.Now())
+	case "serverZeroUpdate":
+		VarMod := player.PlayMod.getVarMod()
+		VarMod.DailyResetTime = 0
+		player.ZeroUpdate(nil)
+		G_GameLogicPtr.ZeroFlush()
+	case "resetActivity":
+		ActivityMod := player.PlayMod.getActivityMod()
+		ActivityMod.Var = nil
+		ActivityMod.InitData()
+		player.PlayMod.save()
+		player.initAcitivity()
+		player.BackDataActivity()
+	case "weekUpdate":
+		VarMod := player.PlayMod.getVarMod()
+		VarMod.WeeklyResetTime = 0
+		player.ZeroUpdate(nil)
+		G_GameLogicPtr.ZeroFlush()
 	case "setSevenLoginActive":
 		num, _ := strconv.Atoi(arg[1])
 		player.PlayMod.getSevenLoginMod().Active = num
 	case "pay":
 		ChargeId, _ := strconv.Atoi(arg[1])
+		player.Kafka("pay", map[string]interface{}{
+			"ProductId":         ChargeId,
+			"AppId":             conf.Server.AppID,
+			"Uid":               player.M_DwUin,
+			"ServerId":          conf.Server.ServerID,
+			"Price":             chargeCfg.GetMoneyCharge(ChargeId),
+			"PayType":           3,
+			"OrderId":           "gm",
+			"PayChannelOrderId": "gm",
+			"CreateTime":        GoUtil.Now(),
+			"PayTime":           GoUtil.Now(),
+		})
 		Charge(player, ChargeId)
+	case "AllFace":
+		Now := GoUtil.Now()
+		FaceMod := player.PlayMod.getFaceMod()
+		FaceList := faceCfg.GetAllId()
+		FaceMod.List = make(map[int]*face.Face)
+		for _, v := range FaceList {
+			FaceMod.List[v] = &face.Face{
+				AddTime: Now,
+			}
+		}
+
+		AvatarMod := player.PlayMod.getAvatarMod()
+		AvatarMod.List = make(map[int]*avatar.Avatar)
+		AvatarList := avatarCfg.GetAllId()
+
+		for _, v := range AvatarList {
+			AvatarMod.List[v] = &avatar.Avatar{
+				AddTime: Now,
+			}
+		}
+		BackUserInfo(player)
+	case "resetFace":
+		FaceMod := player.PlayMod.getFaceMod()
+		FaceMod.List = nil
+		FaceMod.InitData()
+
+		AvatarMod := player.PlayMod.getAvatarMod()
+		AvatarMod.List = nil
+		AvatarMod.InitData()
+	case "initEmoji":
+		EmojiMod := player.PlayMod.getEmojiMod()
+		InitId := emojiCfg.GetInitList()
+		now := GoUtil.Now()
+		for _, v := range InitId {
+			EmojiMod.List[v] = &emoji.Emoji{
+				AddTime: now,
+			}
+		}
+	case "addEmoji":
+		EmojiMod := player.PlayMod.getEmojiMod()
+		InitId := emojiCfg.GetAllList()
+		now := GoUtil.Now()
+		for _, v := range InitId {
+			EmojiMod.List[v] = &emoji.Emoji{
+				AddTime: now,
+			}
+		}
+	case "createOrder":
+		Lv := player.GetPlayerBaseMod().GetLevel()
+		EmitList := player.PlayMod.getChessMod().GetEmitList()
+		EnergyMul := player.PlayMod.getBaseMod().GetEnergyMul()
+		OrderMod := player.PlayMod.getOrderMod()
+		OrderMod.LastOrder.Type = 1
+		OrderMod.CreateOrder(Lv, EmitList, EnergyMul, order.Common_type)
+		player.PushClientRes(player.PlayMod.getOrderMod().BackData())
 	case "resetCardReq":
 		CardMod := player.PlayMod.getCardMod()
 		CardMod.ReqFriend = make(map[int]*card.CardInfo)
 		CardMod.ExCard = make(map[int]*card.CardInfo)
 		CardMod.ExTimes = 10
 		CardMod.ReqTimes = 10
-
+		player.AddCard(1)
+		player.AddCard(2)
+		player.AddCard(3)
 		FriendMod := player.PlayMod.getFriendMod()
-		FriendMod.ApplyCard = make(map[int]*card.CardInfo)
-		FriendMod.ExchangeCard = make(map[int]*card.CardInfo)
-		FriendMod.SelectCard = make(map[int]*card.CardInfo)
+		FriendMod.Card = make(map[string]*card.CardInfo)
+		player.PushClientRes(CardMod.NotifyCard())
+	case "subCard":
+		ChargeId, _ := strconv.Atoi(arg[1])
+		CardMod := player.PlayMod.getCardMod()
+		player.SubCard(ChargeId)
+		player.PushClientRes(CardMod.NotifyCard())
+	case "setProgress":
+		num, _ := strconv.Atoi(arg[1])
+		player.PlayMod.getLimitedTimeEventMod().Progress = num
+	case "setProgressReward":
+		BaseMod := player.PlayMod.getBaseMod()
+		LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
+		LimitedTimeEventMod.Progress = 5
+		for i := 1; i < 5; i++ {
+			LimitedTimeEventMod.AddProgress(BaseMod.GetLevel())
 		}
+		player.PushClientRes(LimitedTimeEventMod.ProgressBackData())
+	case "champshipGroup":
+		G_GameLogicPtr.ChampshipMgrSend(&MsgMod.Msg{
+			Type: MsgMod.HANDLE_TYPE_CHAMPSHIP_GROUP,
+		})
+	case "clearRank":
+		num, _ := strconv.Atoi(arg[1])
+		G_GameLogicPtr.RankMgr.ClearRank(num)
+	case "resetUserInfo":
+		Rank := G_GameLogicPtr.RankMgr.getRank(RANK_TYPE_USER)
+		for _, v := range Rank {
+			Idstr := strconv.Itoa(v.Uid)
+			db.RedisDelKey(Idstr)
+			G_GameLogicPtr.GetResSimplePlayerByUid(v.Uid)
+		}
+
+	case "champshipZero":
+		G_GameLogicPtr.ChampshipMgrSend(&MsgMod.Msg{
+			Type: MsgMod.SERVER_ZERO_UPDATE,
+		})
+	case "resetEmitOrder":
+		OrderMod := player.PlayMod.getOrderMod()
+		OrderMod.EimtOrder = make(map[string]struct{})
+		HandbookMod := player.PlayMod.getHandbookMod()
+		delete(HandbookMod.BookList, 125)
+	case "handbook":
+		HandbookMod := player.PlayMod.getHandbookMod()
+		for _, v := range mergeDataCfg.GetAllId() {
+			HandbookMod.SetHandbook(v)
+			HandbookMod.BookList[v] = handbook.STATUS_REWARD
+		}
+	case "handbookReward":
+		HandbookMod := player.PlayMod.getHandbookMod()
+		for _, v := range mergeDataCfg.GetAllId() {
+			HandbookMod.BookList[v] = handbook.STATUS_REWARD
+		}
+		player.PushClientRes(HandbookMod.BackData())
+	case "deleteOrder":
+		Id, _ := strconv.Atoi(arg[1])
+		OrderMod := player.PlayMod.getOrderMod()
+		delete(OrderMod.OrderList, Id)
+		player.PushClientRes(OrderMod.BackData())
+	case "miningReload":
+		MiningMod := player.PlayMod.getMiningMod()
+		MiningMod.ZeroUpdate(-1)
+		ActivityInfo := GetActivityInfo(player, activity.ACT_TYPE_MINING)
+		MiningMod.ZeroUpdate(ActivityInfo.Id)
+		MiningBackData(player)
+	case "guessColorReload":
+		GuessColorMod := player.PlayMod.getGuessColorMod()
+		GuessColorMod.ZeroUpdate(-1)
+		ActivityInfo := GetActivityInfo(player, activity.ACT_TYPE_GUESS_COLOR)
+		GuessColorMod.ZeroUpdate(ActivityInfo.Id)
+		GuessColorBackData(player)
+	case "raceReload":
+		RaceMod := player.PlayMod.getRaceMod()
+		RaceMod.ZeroUpdate(-1)
+		ActivityInfo := GetActivityInfo(player, activity.ACT_TYPE_RACE)
+		RaceMod.ZeroUpdate(ActivityInfo.Id)
+		RaceBackData(player)
+	case "raceAdd":
+		RaceMod := player.PlayMod.getRaceMod()
+		RaceMod.AddCoin(100)
+		RaceBackData(player)
+	case "playroomReset":
+		PlayroomMod := playroom.PlayroomMod{}
+		PlayroomMod.InitData()
+		player.PlayMod.mod_list.Playroom = PlayroomMod
+	case "resetCollect":
+		CollectMod := player.PlayMod.getCollectMod()
+		CollectMod.Reward = make([]int, 0)
+		CollectMod.Jackpot = make([]int, 0)
+		CollectMod.InitData()
+	case "playroomCollect":
+		CollectList := playroomCfg.GetDecorateList()
+		PlayroomMod := player.PlayMod.getPlayroomMod()
+		PlayroomMod.NewCollect = make(map[int]*playroom.CollectInfo, 0)
+		for _, v := range CollectList {
+			PlayroomMod.AddCollect(v, "Gm")
+		}
+	case "playroomDress":
+		PlayroomMod := player.PlayMod.getPlayroomMod()
+		PlayroomMod.NewDress = make(map[int]*playroom.DressInfo, 0)
+		DressList := playroomCfg.GetDressList()
+		for _, v := range DressList {
+			Part := playroomCfg.GetDressPart(v)
+			PlayroomMod.UnlockDress(Part, v)
+		}
+		PlayroomBackData(player)
+	case "playroomAir":
+		PlayroomMod := player.PlayMod.getPlayroomMod()
+		PlayroomMod.NewPetAir = make(map[int]*playroom.PetAirInfo, 0)
+		AirList := playroomCfg.GetAirList()
+		for _, v := range AirList {
+			PlayroomMod.UnlockPetAir(v)
+		}
+		PlayroomBackData(player)
+	case "resetRetire":
+		ChessMod := player.PlayMod.getChessMod()
+		ChessMod.Retire = make(map[string]int)
+		ChessMod.RetireChessMap = make(map[string][]int)
+	case "cleanBuff":
+		ChessMod := player.PlayMod.getChessMod()
+		ChessMod.ChessBuff = []int{}
+		player.PushClientRes(ChessMod.BackData())
+	case "addPlayroomPoint":
+		PlayroomMod := player.PlayMod.getPlayroomMod()
+		Num, _ := strconv.Atoi(arg[1])
+		PlayroomMod.RoomPoint += Num
+		PlayroomBackData(player)
+	case "resetPlayroomUnlock":
+		PlayroomMod := player.PlayMod.getPlayroomMod()
+		PlayroomMod.UnlockList = make(map[int]int64)
+		PlayroomBackData(player)
+	case "addChip":
+		PlayroomMod := player.PlayMod.getPlayroomMod()
+		PlayroomMod.AddChip(100100001, 1, 0)
+		player.PushClientRes(PlayroomMod.NotifyLose())
+	case "save":
+		player.PlayMod.ClearData(player)
+	case "outline":
+		a := player.GetAgent()
+		a.Close()
+		player.ClearData()
+	case "resetFriend":
+		FriendMod := player.PlayMod.getFriendMod()
+		FriendMod.FriendList = make(map[int]struct{})
+		FriendMod.ApplyList = make(map[int]int64)
+		FriendMod.Card = make(map[string]*card.CardInfo)
+		FriendMod.SendApply = make(map[int]int64)
+		FriendMod.NewFriendList = make(map[int]*friend.FriendInfo)
+		FriendMod.Npc = []int{}
+		FriendMod.Id = 0
+		FriendMod.Log = make([]*friend.LogInfo, 0)
+		FriendMod.InitData()
+		FriendListBackData(player)
+		FriendLogBackData(player)
+	case "addFriend":
+		FriendMod := player.PlayMod.getFriendMod()
+		Uid, _ := strconv.Atoi(arg[1])
+		FriendMod.AddFriend(Uid)
+	case "addAddCard":
+		CardMod := player.PlayMod.getCardMod()
+		CardList := cardCfg.GetAllCardId(CardMod.Round)
+		for _, v := range CardList {
+			player.AddCard(v)
+			CardMod.Handbook[v] = card.HANDBOOK_STATUS_GET
+		}
+		player.PushClientRes(CardMod.NotifyCard())
+	case "resetRankUser":
+		O := G_GameLogicPtr.RankMgr.getAllRank(RANK_TYPE_USER)
+		for _, v := range O {
+			Uid := strconv.Itoa(v.Uid)
+			TimeSort := fmt.Sprintf("0.%d", RANK_TIME_SORT-GoUtil.Now())
+			TimeSortF, _ := strconv.ParseFloat(TimeSort, 64)
+			db.RedisZAdd(RANK_USER, Uid, v.Score+TimeSortF)
+		}
+	case "addFriendStar":
+		FriendTreasureMod := player.PlayMod.getFriendTreasureMod()
+		FriendTreasureMod.AddStar(200)
+	case "comfortOrder":
+		BaseMod := player.PlayMod.getBaseMod()
+		BaseMod.LogoutTime = GoUtil.Now() - 7*86400
+		TriggerComfortOrder(player)
+		player.PushClientRes(player.PlayMod.getOrderMod().BackData())
+	case "resetGuide":
+		GuildMod := player.PlayMod.getGuideMod()
+		GuildMod.Reward = make(map[int]int)
+		player.PushClientRes(GuildMod.BackData())
+	case "resetDecoratePart":
+		DecorateMod := player.PlayMod.getDecorateMod()
+		DecorateMod.PartCost = make(map[int]*decorate.PartCostInfo)
+		DecorateMod.PartClassPool = []int{}
+		DecorateMod.PartPool = make(map[int]int)
+		DecorateMod.InitData()
+		player.PushClientRes(DecorateMod.BackData())
+	case "setDecorateArea":
+		S, _ := strconv.Atoi(arg[1])
+		DecorateMod := player.PlayMod.getDecorateMod()
+		DecorateMod.AreaId = S
+		DecorateMod.FinishList = make(map[int]struct{})
+		DecorateMod.Progress = 0
+		DecorateMod.PartCost = make(map[int]*decorate.PartCostInfo)
+		DecorateMod.PartClassPool = []int{}
+		DecorateMod.PartPool = make(map[int]int)
+		DecorateMod.InitData()
+		player.PushClientRes(DecorateMod.BackData())
+	case "setDecorateProgress":
+		S, _ := strconv.Atoi(arg[1])
+		DecorateMod := player.PlayMod.getDecorateMod()
+		DecorateMod.FinishList = make(map[int]struct{})
+		for i := 1; i <= S; i++ {
+			DecorateMod.FinishList[i] = struct{}{}
+		}
+		DecorateMod.Progress = S
+	case "resetCardSeasonFirst":
+		CardMod := player.PlayMod.getCardMod()
+		CardMod.SeasonFirst = false
+	case "addPhysiology":
+		PlayroomMod := player.PlayMod.getPlayroomMod()
+		Type, _ := strconv.Atoi(arg[1])
+		Num, _ := strconv.Atoi(arg[2])
+		PlayroomMod.AddPhysiology(Type, Num)
+	case "resetTriggerTime":
+		PlayroomMod := player.PlayMod.getPlayroomMod()
+		PlayroomMod.TriggerTime = 0
+	case "resetTimeline":
+		FriendMod := player.PlayMod.getFriendMod()
+		FriendMod.Log = make([]*friend.LogInfo, 0)
+	case "resetFastCD":
+		LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
+		LimitedTimeEventMod.ResetFastProduceCD()
+		EndTime, Times := LimitedTimeEventMod.GetFastProduceInfo()
+		player.PushClientRes(&msg.ResFastProduceInfo{
+			EndTime: EndTime,
+			Num:     int32(Times),
+		})
+	case "sendMail":
+		MailMod := player.PlayMod.getMailMod()
+		title := `MMM圣诞节奖励`
+		content := `测试`
+		MailMod.Send(title, "副标题", content, title, "副标题", content, []*item.Item{
+			{
+				Id:  item.ITEM_DIAMOND_ID,
+				Num: 10,
+			},
+			{
+				Id:  item.ITEM_ENERGY_ID,
+				Num: 10,
+			},
+			{
+				Id:  item.ITEM_STAR_ID,
+				Num: 10,
+			},
+		}, 2)
+		player.PushClientRes(MailMod.BackData())
+	case "resetNpc":
+		FriendMod := player.PlayMod.getFriendMod()
+		FriendMod.Npc = []int{}
+		FriendListBackData(player)
+	case "recoverUser":
+		file, err := os.OpenFile(conf.Server.GameConfPath+"user.info", os.O_RDWR|os.O_CREATE, 0666)
+		if err != nil {
+			log.Error("Failed to open user.info file: %v", err)
+			return err
+		}
+		// file.Write(buf.Bytes())
+		defer file.Close()
+		Uid := player.M_DwUin
+		file.Seek(0, 0)
+		decoder := gob.NewDecoder(file)
+		modList := PlayerModList{}
+		err = decoder.Decode(&modList)
+		player.PlayMod.mod_list = modList
+		if err != nil {
+			log.Error("Failed to decode user.info file: %v", err)
+			return err
+		}
+		BaseMod := player.PlayMod.getBaseMod()
+		BaseMod.Uid = Uid
+	case "copyUser":
+		p1 := new(Player)
+		err := p1.InitPlayer(arg[1])
+		if err != nil {
+			return err
+		}
+		BaseMod := p1.PlayMod.getBaseMod()
+		BaseMod.Uid = player.M_DwUin
+		BaseMod.NickName = player.PlayMod.getBaseMod().NickName
+		BaseMod.IdCardName = player.PlayMod.getBaseMod().IdCardName
+		BaseMod.IdCardNum = player.PlayMod.getBaseMod().IdCardNum
+		BaseMod.LoginTime = GoUtil.Now()
+		player.PlayMod.mod_list = p1.PlayMod.mod_list
+		player.PlayMod.mod_list.Base = *BaseMod
+	case "orderMerge": // 获取order订单的mergeId
+		OrderMod := player.PlayMod.getOrderMod()
+		items := make([]*item.Item, 0)
+		for _, v := range OrderMod.OrderList {
+			for _, j := range v.MergeId {
+				items = append(items, &item.Item{
+					Id:  j,
+					Num: 1,
+				})
+			}
+		}
+		player.HandleItem(items, msg.ITEM_POP_LABEL_GM.String())
+	case "resetCompensation":
+		compensationMod := player.PlayMod.getCompensationMod()
+		compensationMod.C20250910 = false
+	case "resetCode":
+		BaseMod := player.PlayMod.getBaseMod()
+		BaseMod.AddCode = fmt.Sprintf("MMM-%s-%s", "156", GoUtil.UniqueStringFromInt(int(BaseMod.Uid)))
+		BackUserInfo(player)
+	default:
+		return fmt.Errorf("Player %d ReqGmCommand:%v not found", player.M_DwUin, arg)
+	}
+	log.Debug("Player %d ReqGmCommand:%v", player.M_DwUin, arg)
+
+	player.PlayMod.save()
 	return nil
 }

src/server/game/HttpSvr.go

@@ -4,11 +4,8 @@ import (
 	"fmt"
 	"net/http"
 	"server/conf"
-	"server/msg"
 
 	// "server/msg"
-	"encoding/json"
-	"strconv"
 
 	"github.com/gorilla/mux"
 )
@@ -36,23 +33,7 @@ func (p *HttpManager) InitPlayerProfileInfo() {
 }
 
 func (p *HttpManager) GetPlayerProfileInfo(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
 
-	Id, ok := vars["Id"]
-
-	if ok {
-		Uin, _ := strconv.Atoi(Id)
-		data := G_GameLogicPtr.MPlayerProfileManager.HttpReqPlayerBriefProfileData(int32(Uin))
-		test := []*msg.ResPlayerBriefProfileData{data, data}
-		bytes, _ := json.Marshal(test)
-
-		v := []*msg.ResPlayerBriefProfileData{}
-		json.Unmarshal(bytes, &v)
-
-		fmt.Println("bytes Length:" + strconv.Itoa(len(v)))
-		fmt.Println("bytes Length:" + strconv.Itoa(len(v)))
-		w.Write(bytes)
-	}
 }
 
 func (p *HttpManager) AddFriend(w http.ResponseWriter, r *http.Request) {

src/server/game/LimiteEventManager.go

@@ -1,242 +0,0 @@
-package game
-
-import (
-	"fmt"
-	"github.com/robfig/cron/v3"
-	"server/GoUtil"
-	"server/MergeConst"
-	"server/db"
-	"server/gamedata"
-	"strconv"
-	"strings"
-	"time"
-
-	"server/pkg/github.com/name5566/leaf/timer"
-)
-
-type LimitEventPeriod struct {
-	StartCronID cron.EntryID
-	EndTimer    *timer.Timer
-	StartTime   int32
-	EndTime     int32
-	Duration    int32
-	CronStr     string
-	AddTimes    int32
-}
-
-func NewLimitEventData(dataName string, dbName string, player *Player) *PlayerLimitData {
-	act := &PlayerLimitData{
-		PlayerData: NewPlayerData(dataName, player),
-		MDbName:    dbName,
-	}
-
-	return act
-}
-
-func CreateLimiteEventData(ID int32, dataName string, player *Player) PlayerDataModule {
-	var data PlayerDataModule
-	if ID == 1 {
-		data = &PlayerChestRainData{PlayerLimitData: NewLimitEventData(dataName, "t_Limit_Chest_Rain", player)}
-	}
-	if ID == 2 {
-		data = &PlayerSuperEmiterData{PlayerLimitData: NewLimitEventData(dataName, "t_Limit_Super_Emiter", player)}
-	}
-	if ID == 3 {
-		data = &PlayerStarRainData{PlayerLimitData: NewLimitEventData(dataName, "t_Limit_Star_Rain", player)}
-	}
-	if ID == 4 {
-		data = &PlayerHighRollerData{PlayerLimitData: NewLimitEventData(dataName, "t_Limit_High_Roller", player)}
-	}
-	if ID == 5 {
-		data = &PlayerSuperOrderData{PlayerLimitData: NewLimitEventData(dataName, "t_Limit_Super_Order", player)}
-	}
-	if ID == 6 {
-		data = &PlayerSceneSprintData{PlayerLimitData: NewLimitEventData(dataName, "t_Limit_Scene_Sprint", player)}
-	}
-	if ID == 7 {
-		data = &PlayerCardFestivalData{PlayerLimitData: NewLimitEventData(dataName, "t_Limit_Card_Festival", player)}
-	}
-	if ID == 8 {
-		data = &PlayerDoubleHitData{PlayerLimitData: NewLimitEventData(dataName, "t_Limit_Double_Hit", player)}
-	}
-	if ID == 9 {
-		data = &PlayerCardSwapData{PlayerLimitData: NewLimitEventData(dataName, "t_Limit_Card_Swap", player)}
-	}
-	if ID == 10 {
-		data = &PlayerPetRobberData{PlayerLimitData: NewLimitEventData(dataName, "t_Limit_Pet_Robber", player)}
-	}
-
-	return data
-}
-
-type LimiteEventManager struct {
-	MStatus           int32
-	CronList          map[int][]string
-	IsSettle          int32
-	IsLoadDB          bool
-	MUpdateNotifyList []int32
-	McronSave         *cron.Cron
-	McronSaveID       cron.EntryID
-	RobotCronID       cron.EntryID
-	RobotCronID10s    cron.EntryID
-	m_MapCronEntryIDs map[int][]*LimitEventPeriod
-	Mdispatr          *timer.Dispatcher
-	IsHighRoll        bool
-}
-
-func (p *LimiteEventManager) GetLimitDataNameById(id int32) string {
-	LimitDataMap := make(map[int32]string)
-	LimitDataMap[1] = "PlayerChestRainData"
-	LimitDataMap[2] = "PlayerSuperEmiterData"
-	LimitDataMap[3] = "PlayerStarRainData"
-	LimitDataMap[4] = "PlayerHighRollerData"
-	LimitDataMap[5] = "PlayerSuperOrderData"
-	LimitDataMap[6] = "PlayerSceneSprintData"
-	LimitDataMap[7] = "PlayerCardFestivalData"
-	LimitDataMap[8] = "PlayerDoubleHitData"
-	LimitDataMap[9] = "PlayerCardSwapData"
-	LimitDataMap[10] = "PlayerPetRobberData"
-
-	return LimitDataMap[id]
-}
-
-func (p *LimiteEventManager) SaveDataFromDB(Key interface{}) bool {
-
-	return true
-}
-
-func (p *LimiteEventManager) GetSunDayZero() int64 {
-	timeStamp := time.Now().Unix()
-	t := time.Unix(timeStamp, 0).Local()
-	delta := int(t.Weekday()*3600*24) + t.Hour()*3600 + t.Minute()*60 + t.Second()
-	return int64(timeStamp) - int64(delta)
-}
-
-func (p *LimiteEventManager) GetLimitDataStatus(id int) *LimitEventPeriod {
-	timeStamp := time.Now().Unix()
-	keys := p.m_MapCronEntryIDs[id]
-	for i := 0; i < len(keys); i++ {
-		if timeStamp >= int64(keys[i].StartTime) && timeStamp < int64(keys[i].EndTime) {
-			return keys[i]
-		}
-	}
-	return nil
-}
-
-func (p *LimiteEventManager) GetIsHighRollerPersion() bool {
-	return p.IsHighRoll
-}
-
-// 1.宝箱雨
-func (p *LimiteEventManager) InitManager() {
-	// 0 11 20 12 *
-	p.IsHighRoll = false
-	p.m_MapCronEntryIDs = map[int][]*LimitEventPeriod{}
-	c := cron.New()
-	LimiteCfg := gamedata.GetConfigByName("LimiteEvent")
-	WeekZero := p.GetSunDayZero()
-	timeStamp := time.Now().Unix()
-
-	p.Mdispatr = timer.NewDispatcher(10)
-	for i := 0; i < LimiteCfg.NumRecord(); i++ {
-		record := LimiteCfg.Record(i).(*gamedata.LimiteEvent)
-		startStrr := record.StartTime
-		starts := strings.Split(startStrr, "|")
-
-		DurStrr := record.Duration
-		Durs := strings.Split(DurStrr, "|")
-
-		AddTimesStrr := record.AddTimes
-		ats := strings.Split(AddTimesStrr, "|")
-
-		p.m_MapCronEntryIDs[record.Id] = []*LimitEventPeriod{}
-		for n := 0; n < len(starts); n++ {
-			LEP := &LimitEventPeriod{}
-			start := starts[n]
-			dur, _ := strconv.Atoi(Durs[n])
-			addt, _ := strconv.Atoi(ats[n])
-			LEP.StartCronID, _ = c.AddFunc(start, func() {
-				fmt.Println("Next: UTC", c.Entry(LEP.StartCronID).Next.Unix())
-				fmt.Println("CronStr:" + LEP.CronStr)
-				cur := int32(time.Now().Unix())
-				LEP.StartTime = int32(cur)
-				LEP.EndTime = int32(cur) + int32(dur)
-				if record.Id == 9 {
-					if G_GameLogicPtr.M_SvrGlobal.LimitCardSwapTime < LEP.StartTime {
-						card4Cfg, str4 := gamedata.GetRandomDifferenceSet(4, G_GameLogicPtr.M_SvrGlobal.Limit4CardExclude)
-						card5Cfg, str5 := gamedata.GetRandomDifferenceSet(5, G_GameLogicPtr.M_SvrGlobal.Limit5CardExclude)
-						G_GameLogicPtr.M_SvrGlobal.Limit4Card = int32(card4Cfg.Id)
-						G_GameLogicPtr.M_SvrGlobal.Limit5Card = int32(card5Cfg.Id)
-						G_GameLogicPtr.M_SvrGlobal.Limit4CardExclude = str4
-						G_GameLogicPtr.M_SvrGlobal.Limit5CardExclude = str5
-						G_GameLogicPtr.M_SvrGlobal.LimitCardSwapTime = LEP.StartTime
-						db.FormatAllMemUpdateDb(&G_GameLogicPtr.M_SvrGlobal, "t_server_global_data", "Id")
-					}
-				}
-				GoUtil.CallEvent(MergeConst.OpenNewLimitEvent, []interface{}{record.Id, cur, cur + int32(dur), record.Type})
-				if record.Id == 4 {
-					p.IsHighRoll = true
-				}
-				go func() {
-					LeafTimer := p.Mdispatr.AfterFunc(time.Duration(dur)*time.Second, func() {
-						if record.Id == 4 {
-							p.IsHighRoll = false
-						}
-					})
-					LEP.EndTimer = LeafTimer
-
-					(<-p.Mdispatr.ChanTimer).Cb()
-				}()
-			})
-			LEP.Duration = int32(dur)
-			LEP.CronStr = start
-			LEP.AddTimes = int32(addt)
-			p.m_MapCronEntryIDs[record.Id] = append(p.m_MapCronEntryIDs[record.Id], LEP)
-		}
-	}
-	c.Start()
-	for k, v := range p.m_MapCronEntryIDs {
-		// record := LimiteCfg.Index(k).(*gamedata.LimiteEvent)
-		key := k
-		for i := 0; i < len(v); i++ {
-			Schedule := c.Entry(v[i].StartCronID).Schedule
-			Next := Schedule.Next(time.Unix(WeekZero, 0))
-			// fmt.Println("Next.Unix():" + strconv.Itoa(int(Next.Unix())))
-			value := v[i]
-			if timeStamp >= Next.Unix() && timeStamp < Next.Unix()+int64(value.Duration) {
-				fmt.Println("CronStr:" + value.CronStr)
-				if key == 4 {
-					p.IsHighRoll = true
-				}
-				if key == 9 {
-					if G_GameLogicPtr.M_SvrGlobal.LimitCardSwapTime < int32(Next.Unix()) {
-						card4Cfg, str4 := gamedata.GetRandomDifferenceSet(4, G_GameLogicPtr.M_SvrGlobal.Limit4CardExclude)
-						card5Cfg, str5 := gamedata.GetRandomDifferenceSet(5, G_GameLogicPtr.M_SvrGlobal.Limit5CardExclude)
-						G_GameLogicPtr.M_SvrGlobal.Limit4Card = int32(card4Cfg.Id)
-						G_GameLogicPtr.M_SvrGlobal.Limit5Card = int32(card5Cfg.Id)
-						G_GameLogicPtr.M_SvrGlobal.Limit4CardExclude = str4
-						G_GameLogicPtr.M_SvrGlobal.Limit5CardExclude = str5
-						G_GameLogicPtr.M_SvrGlobal.LimitCardSwapTime = int32(Next.Unix())
-						db.FormatAllMemUpdateDb(&G_GameLogicPtr.M_SvrGlobal, "t_server_global_data", "Id")
-					}
-				}
-				go func() {
-					delta := Next.Unix() + int64(value.Duration) - timeStamp
-					LeafTimer := p.Mdispatr.AfterFunc(time.Duration(delta)*time.Second, func() {
-						if key == 4 {
-							p.IsHighRoll = false
-						}
-					})
-					value.EndTimer = LeafTimer
-					value.StartTime = int32(Next.Unix())
-					value.EndTime = int32(Next.Unix()) + int32(value.Duration)
-					(<-p.Mdispatr.ChanTimer).Cb()
-				}()
-			} else {
-
-			}
-		}
-
-	}
-
-}

src/server/game/LimitedTimeTrigger.go

@@ -1,15 +1,24 @@
 package game
 
 import (
+	"fmt"
+	"math"
 	"server/GoUtil"
+	playroomCfg "server/conf/playroom"
+	userCfg "server/conf/user"
+	"server/game/mod/card"
+	"server/game/mod/item"
 	"server/game/mod/limitedTimeEvent"
+	MsgMod "server/game/mod/msg" // Ensure this package exists and is correctly referenced
+	"server/game/mod/playroom"
 	"server/msg"
 	"time"
 )
 
 // 限时事件触发器
 func LimitedTimeEventTrigger(p *Player, AddEventId int) {
-	EndTime, TimeoutEvent, AddEvent := p.PlayMod.getLimitedTimeEventMod().Trigger()
+	Lv := p.GetPlayerBaseMod().GetLevel()
+	EndTime, TimeoutEvent, AddEvent := p.PlayMod.getLimitedTimeEventMod().Trigger(Lv)
 	remainingTime := GoUtil.NextHourRemain()
 	EndTime = GoUtil.IfTrue(EndTime > 0, min(EndTime, int(remainingTime)), int(remainingTime)).(int)
 	if AddEventId != 0 {
@@ -31,23 +40,39 @@ func LimitedTimeEventTrigger(p *Player, AddEventId int) {
 		})
 		switch v {
 		case limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER:
-			MaxEnergyMul := p.GetPlayerBaseMod().GetMaxEnergyMul()
-			p.PlayMod.getBaseMod().ResetEnergyMul(MaxEnergyMul)
+			BaseMod := p.PlayMod.getBaseMod()
+			EnergyMul := BaseMod.GetEnergyMul()
+			NewEnergyMul := p.PlayMod.getBaseMod().GetEnergyMul()
+			OrderMod := p.PlayMod.getOrderMod()
+			Lv := p.GetPlayerBaseMod().GetLevel()
+			Emit := p.PlayMod.getChessMod().GetOrderEmit()
+			ChessList := p.PlayMod.getChessMod().GetUnlockChessList()
+			OrderMod.ChangeEnergyMul(Lv, Emit, NewEnergyMul, ChessList)
+			p.PushClientRes(OrderMod.BackData())
+			p.TeLog("mutil_merge_change", map[string]interface{}{
+				"change_from": math.Pow(2, float64(EnergyMul)),
+				"change_to":   math.Pow(2, float64(NewEnergyMul)),
+				"is_auto":     true,
+			})
 			p.PushClientRes(p.PlayMod.getBaseMod().BackData())
 		case limitedTimeEvent.EVENT_TYPE_SUPER_ORDER:
 			p.PlayMod.getOrderMod().RemoveSuperOrder()
 			p.PushClientRes(p.PlayMod.getOrderMod().BackData())
 		case limitedTimeEvent.EVENT_TYPE_CARD_FESTIVAL:
 			p.PlayMod.getCardMod().ResetCardFestival()
+		case limitedTimeEvent.EVENT_TYPE_GOLDCARD_EX:
+			p.PlayMod.getFriendMod().ResetGoldCardEx()
+			LimitedTimeCardTrigger(p)
 		}
 	}
 
 	for _, v := range AddEvent { // 增加事件处理
 		switch v {
 		case limitedTimeEvent.EVENT_TYPE_SUPER_ORDER:
-			Emit := p.PlayMod.getChessMod().GetEmitList()
+			Emit := p.PlayMod.getChessMod().GetOrderEmit()
 			Lv := p.GetPlayerBaseMod().GetLevel()
-			p.PlayMod.getOrderMod().CreateSuperOrder(Lv, Emit)
+			EnergyMul := p.PlayMod.getBaseMod().GetEnergyMul()
+			p.PlayMod.getOrderMod().CreateSuperOrder(Lv, Emit, EnergyMul)
 			p.PushClientRes(p.PlayMod.getOrderMod().BackData())
 		case limitedTimeEvent.EVENT_TYPE_CARD_FESTIVAL:
 			p.PlayMod.getCardMod().CreateCardFestival()
@@ -64,9 +89,200 @@ func LimitedTimePiggyBankTrigger(p *Player) {
 		p.CallEvent(time.Duration(Remain)*time.Second, func() {
 			p.lock.Lock()
 			defer p.lock.Unlock()
-			p.PlayMod.getPiggyBankMod().TimeOut()
+			LimitedTimePiggyBankTrigger(p)
 			p.SendClientRes()
 		}, "PiggyBank")
 	}
 	p.PushClientRes(p.PlayMod.getPiggyBankMod().BackData())
 }
+
+// 限时卡牌触发器
+func LimitedTimeCardTrigger(p *Player) {
+	FriendMod := p.PlayMod.getFriendMod()
+	CardMod := p.PlayMod.getCardMod()
+	Now := GoUtil.Now()
+	EndTime := int64(0)
+	for k, v := range FriendMod.Card {
+		if v.EndTime > 0 && v.EndTime <= Now {
+			if v.Status == card.STATUS_CARD_EX_1 {
+				delete(FriendMod.Card, k)
+				FriendMgrSend(&MsgMod.Msg{
+					From: v.BUid,
+					To:   v.AUid,
+					Type: MsgMod.HANDLE_TYPE_EX_CARD_SELECT_TIMEOUT,
+				})
+			}
+			if v.Status == card.STATUS_CARD_EX_2 {
+				delete(FriendMod.Card, k)
+				FriendMgrSend(&MsgMod.Msg{
+					From: v.AUid,
+					To:   v.BUid,
+					Type: MsgMod.HANDLE_TYPE_EX_CARD_TIMEOUT,
+				})
+				p.AddCard(v.CardId)
+				CardMod.DelExCard(v)
+				p.PushClientRes(CardMod.NotifyTimes())
+				p.PushClientRes(CardMod.NotifyCard())
+			}
+		}
+		EndTime = min(EndTime, v.EndTime)
+	}
+	if EndTime > 0 {
+		p.CallEvent(time.Duration(EndTime-Now)*time.Second, func() {
+			p.lock.Lock()
+			defer p.lock.Unlock()
+			LimitedTimeCardTrigger(p)
+			p.SendClientRes()
+		}, "LimitedTimeCard")
+	}
+}
+func LimitedTimePlayroomTrigger(p *Player) {
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	for k, v := range PlayroomMod.Physiology {
+		if v.Time > 0 {
+			LimitedTimePlayroomTrigger_(p, k)
+		}
+	}
+}
+
+func LimitedTimePlayroomTrigger_(p *Player, Id int) {
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	Physiology := PlayroomMod.GetPhysiology(Id)
+	if Physiology == nil {
+		return
+	}
+	NewTime, NextSecond, Num := PlayroomTrigger(Physiology.Id, Physiology.Time, Physiology.Num)
+	Physiology.Time = NewTime
+	DiffValue := Physiology.Num - Num
+	MType, MEffect := playroomCfg.GetMoodEffect(Physiology.Id)
+	CleanMood := PlayroomMod.GetMoodInfo(playroom.MOOD_TYPE_CLEAN)
+	PlayroomMod.AddMood(MType, -MEffect*DiffValue)
+	// 上厕所数值为0 且清洁度大于50时，清洁度降至50
+	if Id == playroom.PHYSIOLOGY_TYPE_TOLIET && Num == 0 && CleanMood.Num > 50 {
+		CleanMood.Num = 50
+	}
+	// log.Debug("PlayroomTrigger Id:%d, Time:%d, Num:%d, NewTime:%d, NextSecond:%d, MType:%d, MEffect:%d, Num :%d", Id, Physiology.Time, Physiology.Num, NewTime, NextSecond, MType, MEffect, Num)
+	Physiology.Num = Num
+	if PlayroomMod.GetMoodInfo(MType).Num == 0 { // 心情值为0时，重置生理状态
+		PlayroomMod.ResetPhysiology(MType)
+		NewTime = 0
+	}
+	p.PlayMod.save()
+	ResNotifyMood := PlayroomMod.NotifyMood()
+	p.PushClientRes(ResNotifyMood)
+	if NextSecond > 0 {
+		p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
+			p.lock.Lock()
+			defer p.lock.Unlock()
+			LimitedTimePlayroomTrigger_(p, Id)
+			p.SendClientRes()
+		}, fmt.Sprintf("Playroom_%d", Id))
+	}
+}
+
+func PlayroomTrigger(Id int, Time int64, Num int) (int64, int64, int) {
+	if Num == 0 {
+		return 0, 0, 0
+	}
+	Now := GoUtil.Now()
+	NeedDuration := playroomCfg.GetPhysiologyDuration(Id, Num)
+	if Time+int64(NeedDuration) > Now {
+		return Time, int64(NeedDuration), Num
+	}
+	n := 0
+	for {
+		if n > 100 {
+			return 0, 0, 0
+		}
+		Num--
+		NeedDuration := playroomCfg.GetPhysiologyDuration(Id, Num)
+		Time += int64(NeedDuration)
+		if Time >= Now {
+			return Now, int64(NeedDuration), Num
+		}
+		if Num == 0 {
+			return 0, 0, 0
+		}
+		n++
+	}
+}
+
+func LimitedTimePlayroomWorkTrigger(p *Player) {
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	EndTime := PlayroomMod.Endtime
+	Now := GoUtil.Now()
+	if EndTime > 0 && EndTime <= Now {
+		PlayroomMod.ResetWork()
+		p.PlayMod.save()
+		PlayroomBackData(p)
+		p.SendClientRes()
+		return
+	}
+	NextSecond := EndTime - GoUtil.Now()
+	if NextSecond > 0 {
+		p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
+			p.lock.Lock()
+			defer p.lock.Unlock()
+			LimitedTimePlayroomWorkTrigger(p)
+			p.SendClientRes()
+		}, "PlayroomWork")
+	}
+}
+
+func LimitedTimeEnergyAdd(p *Player) {
+	curtime := time.Now().Unix()
+	PlayerBaseMod := p.GetPlayerBaseMod()
+	BaseMod := p.PlayMod.getBaseMod()
+	delta := curtime - BaseMod.GetRecoverTime()
+	Recover := userCfg.GetRecover(BaseMod.GetLevel())
+	if Recover <= 0 {
+		return
+	}
+	Addsta := int(delta) / Recover
+	if Addsta <= 0 {
+		return
+	}
+	Energy := BaseMod.GetEnergy()
+	MaxEnergy := PlayerBaseMod.GetMaxEnergy()
+	if MaxEnergy > Energy {
+		E := MaxEnergy - Energy
+		Energy += Addsta
+		if Energy > MaxEnergy {
+			Energy = MaxEnergy
+		}
+		p.TeLog("asset_change", map[string]interface{}{
+			"item_id":       item.ITEM_ENERGY_ID,
+			"change_type":   "gain",
+			"change_num":    min(Addsta, E),
+			"change_after":  Energy,
+			"change_reason": "recover_server",
+		})
+		p.CallEvent(time.Duration(Recover)*time.Second, func() {
+			p.lock.Lock()
+			defer p.lock.Unlock()
+			LimitedTimeEnergyAdd(p)
+		}, "AddEnergy")
+	}
+	BaseMod.SetEnergy(Energy)
+	BaseMod.SetRecoverTime(curtime)
+	p.SendErrClienRes(PlayerBaseMod.BackAsset())
+}
+
+func GuideTaskTrigger(p *Player) {
+	GuideTaskMod := p.PlayMod.getGuideTaskMod()
+	UnlockTime := GuideTaskMod.UnlockTime
+	if UnlockTime == 0 {
+		return
+	}
+	Now := GoUtil.Now()
+	NextSecond := 86400 - (Now-UnlockTime)%86400
+	if NextSecond > 0 {
+		p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
+			p.lock.Lock()
+			defer p.lock.Unlock()
+			GuideTaskMod.Login()
+			p.PushClientRes(GuideTaskMod.BackData())
+			p.SendClientRes()
+		}, "PlayroomWork")
+	}
+}

src/server/game/LogMgr.go

@@ -1,9 +1,8 @@
 package game
 
 import (
-	"server/db"
-	"server/game/mod/item"
-	"server/pkg/github.com/name5566/leaf/log"
+	"encoding/json"
+	kafkaMiddleware "server/middleware/kafka"
 	"sync"
 
 	"github.com/robfig/cron/v3"
@@ -14,6 +13,10 @@ const (
 	LoginOut_log = 2
 	Event_log    = 3
 )
+const (
+	PLAYROOM_LOST = "playroom_lost"
+	LOG_LENGTH    = 10000
+)
 
 type LogMgr struct {
 	L         []*Log
@@ -22,56 +25,55 @@ type LogMgr struct {
 }
 
 type Log struct {
-	Uid       int32
-	Type      int32
-	Event     string
-	Items     []*item.Item
+	Uid       int64
+	AppId     int
+	ServerId  int
+	EventName string
+	Param     map[string]interface{}
 	TimeStamp int64
 }
 
 func (L *LogMgr) InitManager() {
 	L.McronSave = cron.New()
-	L.L = make([]*Log, 0, 10)
+	L.L = make([]*Log, 0, LOG_LENGTH)
 	L.McronSave.AddFunc("@every 10s", func() {
 		L.Lock.Lock()
 		defer L.Lock.Unlock()
-		for _, v := range L.L {
-			switch v.Type {
-			case Login_log:
-				v.InsertLoginLog()
-			case LoginOut_log:
-				v.InsertLoginLog()
-			case Event_log:
-				v.InsertEventLog()
-			default:
-				log.Debug("unknown log type %d", v.Type)
-				continue
-			}
-		}
+		if kafkaMiddleware.KafkaMod == nil {
+			if len(L.L) > LOG_LENGTH {
 				L.L = L.L[:0]
+			} else if len(L.L) > LOG_LENGTH {
+				L.L = L.L[len(L.L)-LOG_LENGTH:]
+			}
+			return
+		}
+		Quene := L.L
+		NewQuene := make([]*Log, 0, LOG_LENGTH)
+		for _, v := range Quene {
+			value, _ := json.Marshal(v)
+			err := kafkaMiddleware.SendMsg([]byte(v.EventName), value)
+			if err != nil {
+				NewQuene = append(NewQuene, v)
+			}
+		}
+		L.L = NewQuene
 	})
 	L.McronSave.Start()
 }
 
 func (L *LogMgr) AddLog(logs *Log) {
-	return
 	L.Lock.Lock()
 	defer L.Lock.Unlock()
 	L.L = append(L.L, logs)
 }
 
-func (Log *Log) InsertEventLog() {
-	sqlStr := "INSERT INTO t_log_event (dwUin, type, event, timestamp) VALUES (?, ?, ?, ?)"
-	_, err := db.SqlDb.Exec(sqlStr, Log.Uid, Log.Type, Log.Event, Log.TimeStamp)
-	if err != nil {
-		log.Debug("log insert event log error %s", err.Error())
-	}
-}
-
-func (Log *Log) InsertLoginLog() {
-	sqlStr := "INSERT INTO t_log_login (dwUin, type, event, timestamp) VALUES (?, ?, ?, ?)"
-	_, err := db.SqlDb.Exec(sqlStr, Log.Uid, Log.Type, Log.Event, Log.TimeStamp)
-	if err != nil {
-		log.Debug("log insert event log error %s", err.Error())
+func (L *LogMgr) Close() {
+	L.McronSave.Stop()
+	L.Lock.Lock()
+	defer L.Lock.Unlock()
+	for _, v := range L.L {
+		value, _ := json.Marshal(v)
+		kafkaMiddleware.SendMsg([]byte(v.EventName), value)
 	}
+	L.L = L.L[:0]
 }

src/server/game/MailMgr.go

@@ -6,9 +6,15 @@ import (
 	"server/db"
 	"server/game/mod/item"
 	"server/game/mod/msg"
+	"server/pkg/github.com/name5566/leaf/log"
 	"strings"
 )
 
+const (
+	MAIL_SEND_TYPE_SERVER = 1
+	MAIL_SEND_TYPE_USER   = 2
+)
+
 type MailMgr struct {
 	*ServerMod
 	list map[int]*ServerMail
@@ -22,10 +28,13 @@ type ServerMail struct {
 	Id            int
 	Title         string
 	Content       string
+	TitleEn       string
+	ContentEn     string
 	Items         []*item.Item
 	Start_time    int64
 	Register_time int64
 	End_time      int64
+	Send_type     int
 	Mail_type     int
 	To_uids       []int
 }
@@ -38,13 +47,25 @@ func (m *MailMgr) Init() {
 	m.list = make(map[int]*ServerMail)
 	// 注册处理函数
 	m.init()
-	m.LoadMail()
+	m.LoadMail(nil)
+	m.RegisterHandler(msg.HANDLE_TYPE_MAIL_ADD, m.AddMail)
+	m.RegisterHandler(msg.HANDLE_TYPE_MAIL_RELOAD, m.LoadMail)
 }
 
-func (r *MailMgr) LoadMail() {
+func (m *MailMgr) AddMail(msg *msg.Msg) (interface{}, error) {
+	ServerMail := msg.Extra.(*ServerMail)
+	m.list[ServerMail.Id] = ServerMail
+	return nil, nil
+}
+
+func (r *MailMgr) LoadMail(msg *msg.Msg) (interface{}, error) {
 	// 从数据库加载邮件
 	data := make([]*db.SqlServerMailStruct, 0)
-	db.GetServerMailData(&data)
+	err := db.GetServerMailData(&data)
+	if err != nil {
+		log.Error("LoadMail error: %v", err)
+		return nil, err
+	}
 	for _, v := range data {
 		Uids := make([]int, 0)
 		UidArr := strings.Split(v.To_uids, ",")
@@ -57,16 +78,41 @@ func (r *MailMgr) LoadMail() {
 			Id:            v.Id,
 			Title:         v.Title,
 			Content:       v.Content,
+			TitleEn:       v.TitleEn,
+			ContentEn:     v.ContentEn,
 			Items:         item.ParseItem(items),
 			Start_time:    v.Start_time,
 			Register_time: v.Register_time,
 			End_time:      v.End_time,
 			Mail_type:     v.Mail_type,
+			Send_type:     v.Send_type,
 			To_uids:       Uids,
 		}
 	}
+	return nil, nil
 }
 
-func (r *MailMgr) Sync() {
-	G_GameLogicPtr.NotifyAll(&msg.Msg{Type: msg.HANDLE_TYPE_MAIL, Extra: r.list[1]})
+func (r *MailMgr) Sync(Uid int, Register int64) []ServerMail {
+	// 同步邮件
+	Now := GoUtil.Now()
+	list := make([]ServerMail, 0)
+	for _, v := range r.list {
+		if v.Start_time > 0 && v.Start_time > Now {
+			continue
+		}
+		if v.End_time > 0 && v.End_time < Now {
+			continue
+		}
+		if v.Register_time > 0 && v.Register_time < Register {
+			continue
+		}
+		if v.Send_type == MAIL_SEND_TYPE_SERVER { //全服邮件
+			list = append(list, *v)
+		} else {
+			if GoUtil.InArray(Uid, v.To_uids) {
+				list = append(list, *v)
+			}
+		}
+	}
+	return list
 }

src/server/game/Model.go

@@ -1,9 +0,0 @@
-package game
-
-type PlayerSimpleData struct {
-	Uid    int
-	Name   string
-	Avatar int
-	Level  int
-	Face   int
-}

src/server/game/OldPlayerCompensateMgr.go

@@ -1,113 +0,0 @@
-package game
-
-import (
-	"fmt"
-	"math"
-	"server/db"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type OldPlayerCompensateMgr struct {
-	MSqlCompensateStruct map[string]*db.SqlCompensateStruct
-}
-
-func (p *OldPlayerCompensateMgr) SuccessSendEmail(username string) bool {
-
-	emailst, ok := p.MSqlCompensateStruct[username]
-	if ok {
-		emailst.IsSendEmail = 1
-		db.FormatAllMemUpdateDb(emailst, "t_player_compensate_Data", "auto_id")
-		return true
-	}
-	return false
-}
-
-func (p *OldPlayerCompensateMgr) SendEmailToDb(username string, dwUin int32) bool {
-
-	emailst, ok := p.MSqlCompensateStruct[username]
-	if ok {
-		if emailst.IsSendEmail == 1 {
-			return false
-		} else {
-			sqlSt := &db.SqlEmailStruct{}
-			sqlSt.DwUin = dwUin
-			sqlSt.Content = `Welcome back to our game!
-Here comes your refund for your scene progress and payment in test version!
-Have fun in new version!`
-			sqlSt.CurrencyCount = 0
-			sqlSt.CurrencyInfo = ""
-			sqlSt.RecvTime = 0
-			sqlSt.Title = "Test Players' Refund"
-			sqlSt.Sender = "System"
-			sqlSt.ItemCount = 0
-			sqlSt.ItemInfo = ""
-			sqlSt.SendTime = int32(time.Now().Unix())
-			sqlSt.Status = 0
-			sqlSt.Type = 1
-			sqlSt.RewardId = ""
-			sqlSt.RewardCount = ""
-			sqlSt.LinkUrl = ""
-			strarr := []string{}
-			if emailst.DecorationCnt-5 > 0 {
-				SceneDiamond := (emailst.DecorationCnt-5)*10 + 25
-
-				temp := fmt.Sprintf("Diamond|%d", SceneDiamond)
-				strarr = append(strarr, temp)
-			}
-			f, err := strconv.ParseFloat(emailst.ChargeCnt, 64)
-			var ChargeDiamond float64 = 0
-			if err == nil {
-				ChargeDiamond = f * 1.5 * 75
-			}
-			if ChargeDiamond > 0 {
-				cd := int32(math.Ceil(ChargeDiamond))
-				remain := cd % 10
-				if remain != 0 && remain != 5 {
-					if remain < 5 {
-						cd = cd - remain + 5
-					} else {
-						cd = cd - remain + 10
-					}
-				}
-				temp := fmt.Sprintf("Diamond|%d", cd)
-				strarr = append(strarr, temp)
-
-			}
-			sqlSt.RewardType = strings.Join(strarr, "_")
-
-			insertId, err1 := db.FormatAllMemInsertDb(sqlSt, "system_mail_info")
-
-			if err1 == nil {
-				p.SuccessSendEmail(username)
-				fmt.Sprintln("Success Intert Mail:" + strconv.Itoa(int(insertId)))
-			}
-
-			return true
-		}
-
-	}
-	return false
-}
-
-func (p *OldPlayerCompensateMgr) LoadData() {
-	sqlStr := "SELECT * FROM t_player_compensate_Data"
-	sqlStrucks := []db.SqlCompensateStruct{}
-
-	p.MSqlCompensateStruct = make(map[string]*db.SqlCompensateStruct)
-	if err := db.SqlDb.Select(&sqlStrucks, sqlStr); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
-		return
-	} else {
-
-	}
-	for i := 0; i < len(sqlStrucks); i++ {
-		p.MSqlCompensateStruct[sqlStrucks[i].DeviceId] = &sqlStrucks[i]
-	}
-
-}
-
-func (p *OldPlayerCompensateMgr) InitManager() {
-	p.LoadData()
-}

src/server/game/PlayerActiveManager.go

@@ -1,208 +0,0 @@
-package game
-
-import (
-	"server/db"
-	"server/gamedata"
-	"server/msg"
-
-	"google.golang.org/protobuf/proto"
-)
-
-type PlayerActiveMgr struct {
-	M_Player *Player
-}
-
-func (p *PlayerActiveMgr) OpenNewLimitActivity(args []interface{}) {
-	notify := &msg.NotifyLimitedTimeActiveData{}
-	notify.MActiveList = []*msg.LimitedTimeActiveStruct{}
-
-	id := args[0].(int)
-	activityCfg := gamedata.GetConfigByName("Activity")
-	record := activityCfg.Index(id).(*gamedata.ActivityRecord)
-
-	act := &msg.LimitedTimeActiveStruct{}
-	act.StartSvrTime = args[1].(int32)
-	act.EndSvrTime = args[2].(int32)
-	act.Type = int32(record.Type)
-	ActiveID := args[3].(int32)
-	if act.Type == 1 {
-
-		if ActiveID == int32(0) {
-			act.ActiveID = G_GameLogicPtr.InitPassportInsertDb(p.M_Player, act.StartSvrTime, act.EndSvrTime, id)
-		} else {
-			act.ActiveID = ActiveID
-		}
-		actor := &PlayerPassportData{PlayerActiveData: NewActiveData("PlayerPassportData", p.M_Player)}
-		ok := actor.LoadDataFromDB(p.M_Player.M_DwUin)
-		if ok {
-			p.M_Player.playerdata["PlayerPassportData"] = actor
-			p.M_Player.playerdataIF["PlayerPassportData"] = actor
-		}
-
-	}
-	if act.Type == 2 {
-		if ActiveID == int32(0) {
-			act.ActiveID = G_GameLogicPtr.InitPromotionInsertDb(p.M_Player, act.StartSvrTime, act.EndSvrTime, id)
-		} else {
-			act.ActiveID = ActiveID
-		}
-		actor := &PlayerPromotionData{PlayerActiveData: NewActiveData("PlayerPromotionData", p.M_Player)}
-		ok := actor.LoadDataFromDB(p.M_Player.M_DwUin)
-		if ok {
-			p.M_Player.playerdata["PlayerPromotionData"] = actor
-			p.M_Player.playerdataIF["PlayerPromotionData"] = actor
-		}
-	}
-	if act.Type == 3 {
-		if ActiveID == int32(0) {
-			act.ActiveID = G_GameLogicPtr.InitInfinitePackInsertDb(p.M_Player, act.StartSvrTime, act.EndSvrTime, id)
-		} else {
-			act.ActiveID = ActiveID
-		}
-		actor := &PlayerInfinitePackData{PlayerActiveData: NewActiveData("PlayerInfinitePackData", p.M_Player)}
-		ok := actor.LoadDataFromDB(p.M_Player.M_DwUin)
-		if ok {
-			p.M_Player.playerdata["PlayerInfinitePackData"] = actor
-			p.M_Player.playerdataIF["PlayerInfinitePackData"] = actor
-		}
-	}
-
-	if act.Type == 4 {
-		if ActiveID == int32(0) {
-			act.ActiveID = G_GameLogicPtr.Init7DayLoginInsertDb(p.M_Player, act.StartSvrTime, act.EndSvrTime, id)
-		} else {
-			act.ActiveID = ActiveID
-		}
-		actor := &Player7DayLoginData{PlayerActiveData: NewActiveData("Player7DayLoginData", p.M_Player)}
-		ok := actor.LoadDataFromDB(p.M_Player.M_DwUin)
-		if ok {
-			p.M_Player.playerdata["Player7DayLoginData"] = actor
-			p.M_Player.playerdataIF["Player7DayLoginData"] = actor
-		}
-	}
-
-	if act.Type == 5 {
-		if ActiveID == int32(0) {
-			act.ActiveID = G_GameLogicPtr.InitCardCollectInsertDb(p.M_Player, act.StartSvrTime, act.EndSvrTime, id)
-		} else {
-			act.ActiveID = ActiveID
-		}
-		actor := &PlayerCardCollectData{PlayerActiveData: NewActiveData("PlayerCardCollectData", p.M_Player)}
-		ok := actor.LoadDataFromDB(p.M_Player.M_DwUin)
-		if ok {
-			p.M_Player.playerdata["PlayerCardCollectData"] = actor
-			p.M_Player.playerdataIF["PlayerCardCollectData"] = actor
-		}
-	}
-
-	notify.MActiveList = append(notify.MActiveList, act)
-	data, _ := proto.Marshal(notify)
-	agent := p.M_Player.GetAgentByPlayer()
-	G_GameLogicPtr.PackResInfo(agent, "NotifyLimitedTimeActiveData", data)
-}
-
-func NewActiveData(dataName string, player *Player) *PlayerActiveData {
-	act := &PlayerActiveData{
-		PlayerData: NewPlayerData(dataName, player),
-		MisDirty:   false,
-	}
-
-	return act
-}
-
-func (p *PlayerActiveMgr) InitActiveMgr(player *Player) {
-	p.M_Player = player
-	activityCfg := gamedata.GetConfigByName("Activity")
-	map1 := make(map[int]string)
-	map1[1] = "t_player_LimitPassport"
-	map1[2] = "t_player_LimitPromotion"
-	map1[3] = "t_player_LimitInfinitePack"
-	map1[4] = "t_player_Limit7DayLogin"
-	map1[5] = "t_player_card_data"
-	for i := 0; i < len(G_GameLogicPtr.M_LimitActiveList); i++ {
-		Id := G_GameLogicPtr.M_LimitActiveList[i]
-		record := activityCfg.Index(Id).(*gamedata.ActivityRecord)
-		sqlStr := "Select * From " + map1[record.Type] + " Where ConfigActId = ? And dwUin = ?"
-		if record.Type == 1 {
-			struct1 := []db.SqlLimitPassportStruct{}
-			st := G_GameLogicPtr.GetActiveParamById(Id)
-			Start := st.StartTime
-			EndTime := st.EndTime
-			if err := db.SqlDb.Select(&struct1, sqlStr, Id, player.M_DwUin); err != nil {
-				p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
-			} else {
-				if len(struct1) == 0 {
-					p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
-				} else {
-					p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, struct1[0].ActiveID})
-				}
-			}
-
-		}
-		if record.Type == 2 {
-			struct1 := []db.SqlLimitPromotionStruct{}
-			st := G_GameLogicPtr.GetActiveParamById(Id)
-			Start := st.StartTime
-			EndTime := st.EndTime
-			if err := db.SqlDb.Select(&struct1, sqlStr, Id, player.M_DwUin); err != nil {
-				p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
-			} else {
-				if len(struct1) == 0 {
-					p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
-				} else {
-					p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, struct1[0].ActiveID})
-				}
-			}
-		}
-		if record.Type == 3 {
-			struct1 := []db.SqlLimitInfinitePackStruct{}
-			st := G_GameLogicPtr.GetActiveParamById(Id)
-			Start := st.StartTime
-			EndTime := st.EndTime
-			if err := db.SqlDb.Select(&struct1, sqlStr, Id, player.M_DwUin); err != nil {
-				p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
-			} else {
-				if len(struct1) == 0 {
-					p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
-				} else {
-					p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, struct1[0].ActiveID})
-				}
-			}
-
-		}
-		if record.Type == 4 {
-			struct1 := []db.SqlSevenDayLoginStruct{}
-			st := G_GameLogicPtr.GetActiveParamById(Id)
-			Start := st.StartTime
-			EndTime := st.EndTime
-			if err := db.SqlDb.Select(&struct1, sqlStr, Id, player.M_DwUin); err != nil {
-				p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
-			} else {
-				if len(struct1) == 0 {
-					p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
-				} else {
-					p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, struct1[0].ActiveID})
-				}
-			}
-
-		}
-
-		if record.Type == 5 {
-			struct1 := []db.SqlCardCollectStruct{}
-			st := G_GameLogicPtr.GetActiveParamById(Id)
-			Start := st.StartTime
-			EndTime := st.EndTime
-			if err := db.SqlDb.Select(&struct1, sqlStr, Id, player.M_DwUin); err != nil {
-				p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
-			} else {
-				if len(struct1) == 0 {
-					p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
-				} else {
-					p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, struct1[0].ActiveID})
-				}
-			}
-
-		}
-
-	}
-}

src/server/game/PlayerBack.go

@@ -0,0 +1,216 @@
+package game
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	proto "server/msg"
+)
+
+func (p *Player) NotifyPlayroomTask() {
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	m := &proto.NotifyPlayroomTask{
+		DailyTask:       PlayroomMod.BackDataTask(),
+		DailyTaskReward: GoUtil.IntToInt32(PlayroomMod.DailyTaskReward),
+	}
+	p.PushClientRes(m)
+}
+
+func PlayroomBackData(p *Player) {
+	r := &proto.ResPlayroom{}
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	FriendMod := p.PlayMod.getFriendMod()
+	r.Status = int32(PlayroomMod.Status)
+	r.Items = item.ItemToMsg(PlayroomMod.Reward)
+	Opponent := make([]*proto.RoomOpponent, 0)
+	FriendList := make([]*proto.FriendRoom, 0)
+	if PlayroomMod.Target == 0 {
+		PlayroomMod.Target = GetVisitorPlayer(p)
+	}
+	TargerRoom := &proto.FriendRoom{}
+	if PlayroomMod.Target != 0 {
+		PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(PlayroomMod.Target)
+		if PlayerData != nil {
+			TargerRoom.Uid = int64(PlayerData.Uid)
+			TargerRoom.Name = PlayerData.Name
+			TargerRoom.Face = int32(PlayerData.Face)
+			TargerRoom.Avatar = int32(PlayerData.Avatar)
+		} else {
+			PlayroomMod.Target = 0
+		}
+	}
+	for k, v := range PlayroomMod.Visitor {
+		ps := G_GameLogicPtr.GetSimplePlayerByUid(k)
+		if ps == nil {
+			continue
+		}
+		if !FriendMod.CheckFriend(k) {
+			Opponent = append(Opponent, &proto.RoomOpponent{
+				Uid:      int64(k),
+				Name:     ps.Name,
+				Face:     int32(ps.Face),
+				Avatar:   int32(ps.Avatar),
+				LastTime: int32(v.Time),
+			})
+		}
+	}
+	Friend := FriendMod.GetFriendList()
+	for k := range Friend {
+		ps := G_GameLogicPtr.GetSimplePlayerByUid(k)
+		if ps == nil {
+			continue
+		}
+		Times, _ := PlayroomMod.GetVisitorInfo(k)
+		FriendList = append(FriendList, &proto.FriendRoom{
+			Uid:    int64(k),
+			Name:   ps.Name,
+			Face:   int32(ps.Face),
+			Avatar: int32(ps.Avatar),
+			Times:  int32(Times),
+		})
+	}
+	r.Opponent = Opponent
+	r.Friend = FriendList
+	r.Target = TargerRoom
+	Collect := make([]*proto.PlayroomCollectInfo, 0)
+	for _, v := range PlayroomMod.GetCollect() {
+		Collect = append(Collect, &proto.PlayroomCollectInfo{
+			Id:      int32(v.Id),
+			AddTime: v.AddTime,
+			EndTime: v.EndTime,
+			Label:   v.Label,
+		})
+	}
+	r.Collect = Collect
+	Dress := make(map[int32]*proto.PlayroomDress)
+	for _, v := range PlayroomMod.GetDress() {
+		PlayroomDress, ok := Dress[int32(v.Part)]
+		if !ok {
+			PlayroomDress = &proto.PlayroomDress{}
+		}
+		PlayroomDress.List = append(PlayroomDress.List, &proto.PlayroomDressInfo{
+			Id:      int32(v.Id),
+			AddTime: int64(v.AddTime),
+			EndTime: int64(v.EndTime),
+			Label:   v.Label,
+		})
+		Dress[int32(v.Part)] = PlayroomDress
+	}
+	ChipMessage := make([]*proto.ChipInfo, 0)
+	for _, v := range PlayroomMod.ChipList {
+		ChipMessage = append(ChipMessage, &proto.ChipInfo{
+			Uid:     int64(v.Uid),
+			EmojiId: int32(v.Emoji),
+		})
+	}
+	AdWatch := make([]*proto.AdItem, 0)
+	for k, v := range PlayroomMod.ADItem {
+		AdWatch = append(AdWatch, &proto.AdItem{
+			Watch:     int32(v.Watch),
+			LastWatch: int32(v.LastTime),
+			ItemId:    int32(k),
+		})
+	}
+	data := G_GameLogicPtr.GetUserData(int(p.M_DwUin))
+
+	r.Dress = Dress
+	r.DressSet = GoUtil.MapIntToInt32(PlayroomMod.GetDressSet())
+	PetAir := make([]*proto.PlayroomAirInfo, 0)
+	for _, v := range PlayroomMod.GetPetAir() {
+		PetAir = append(PetAir, &proto.PlayroomAirInfo{
+			Id:      int32(v.Id),
+			AddTime: int64(v.AddTime),
+			Label:   v.Label,
+		})
+	}
+	r.PetAir = PetAir
+	r.PetAirSet = int32(PlayroomMod.GetPetAirSet())
+	r.Chip = ChipMessage
+	r.StartTime = int32(PlayroomMod.Starttime)
+	r.WorkStatus = int32(PlayroomMod.WorkStatus)
+	r.Playroom = GoUtil.MapIntToInt32(PlayroomMod.GetRoom())
+	r.Mood = GoUtil.MapIntToInt32(PlayroomMod.GetMood())
+	r.Physiology = GoUtil.MapIntToInt32(PlayroomMod.GetPhysiologyList())
+	r.AllMood = int32(PlayroomMod.AllMood)
+	r.Jackpot = int32(PlayroomMod.JackpotNum)
+	r.Upvote = int32(PlayroomMod.Upvote)
+	r.RoomPoint = int32(PlayroomMod.RoomPoint)
+	r.Unlock = PlayroomMod.GetUnlockIds()
+	r.DailyTaskReward = GoUtil.IntToInt32(PlayroomMod.DailyTaskReward)
+	r.DailyTask = PlayroomMod.BackDataTask()
+	r.Kiss = int32(data.Kiss)
+	r.Revenge = PlayroomMod.RevengeUid
+	r.InteractNum = int32(PlayroomMod.InteractNum)
+	r.AdItem = AdWatch
+	p.PushClientRes(r)
+}
+
+func PlayroomVisit(p *Player, Uid int) {
+	if Uid == 0 {
+		p.PushClientRes(&proto.ResPlayroomInfo{})
+		return
+	}
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	r := &proto.ResPlayroomInfo{}
+	PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(Uid)
+	Now := GoUtil.Now()
+	Work := false
+	if PlayerData.WorkStart > 0 && PlayerData.WorkStart+86400 > Now {
+		Work = true
+	}
+	r.Uid = int64(Uid)
+	r.Name = PlayerData.Name
+	r.Face = int32(PlayerData.Face)
+	r.Avatar = int32(PlayerData.Avatar)
+	r.Playroom = GoUtil.MapIntToInt32(PlayerData.Playroom)
+	r.GameId = int32(PlayroomMod.GameId)
+	r.Defense = Work
+	r.Emoji = GoUtil.MapIntToInt32(PlayerData.Emoji)
+	r.PetName = PlayerData.PetName
+	Items := make(map[int32]*proto.ItemInfo, 0)
+	for k, v := range PlayroomMod.GameReward {
+		Items[int32(k)] = &proto.ItemInfo{
+			Id:  int32(v.Id),
+			Num: int32(v.Num),
+		}
+	}
+	r.Upvote = GoUtil.InArray(Uid, PlayroomMod.UpvoteList)
+	r.Items = Items
+	r.Status = int32(PlayroomMod.GameStatus)
+	data := G_GameLogicPtr.GetUserData(Uid)
+	r.UpvoteCount = int32(data.Upvote)
+	r.Chip = int32(data.Chip)
+	r.Kiss = int32(data.Kiss)
+	r.DressSet = GoUtil.MapIntToInt32(PlayerData.DressSet)
+
+	p.PushClientRes(r)
+}
+
+func (p *Player) NotifyPlayroomKiss() {
+	data := G_GameLogicPtr.GetUserData(int(p.M_DwUin))
+	m := &proto.NotifyPlayroomKiss{
+		Kiss: int32(data.Kiss),
+	}
+	p.PushClientRes(m)
+}
+
+func BackUserInfo(p *Player) {
+	BaseMod := p.PlayMod.getBaseMod()
+	FaceMod := p.PlayMod.getFaceMod()
+	AvatarMod := p.PlayMod.getAvatarMod()
+	DecorateMod := p.PlayMod.getDecorateMod()
+	p.PushClientRes(&proto.UserInfo{
+		Uid:         p.M_DwUin,
+		Nickname:    BaseMod.NickName,
+		Avatar:      int32(AvatarMod.SetId),
+		Face:        int32(FaceMod.SetId),
+		DecorateCnt: int32(DecorateMod.DecorateNum),
+		AvatarList:  AvatarMod.BackData(),
+		FaceList:    FaceMod.BackData(),
+		EmojiList:   p.PlayMod.getEmojiMod().BackData(),
+		SetEmoji:    p.PlayMod.getEmojiMod().GetEmojiSet(),
+		Login:       int32(BaseMod.GetLoginTime()),
+		PetName:     BaseMod.PetName,
+		IdNum:       BaseMod.IdCardNum,
+		AddCode:     BaseMod.AddCode,
+	})
+}

src/server/game/PlayerBaseMod.go

@@ -1,45 +1,36 @@
 package game
 
 import (
-	"bytes"
-	"encoding/gob"
+	"context"
+	"database/sql"
 	"errors"
-	"server/GoUtil"
 	"server/MergeConst"
+	baseCfg "server/conf/base"
 	userCfg "server/conf/user"
 	"server/db"
+	"server/game/mod/item"
 	"server/game/mod/limitedTimeEvent"
+	Msg "server/game/mod/msg"
+	"server/game/mod/order"
 	"server/game/mod/quest"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
-	"server/pkg/github.com/name5566/leaf/timer"
 	"time"
 
-	"github.com/robfig/cron/v3"
 	"google.golang.org/protobuf/proto"
 )
 
 type PlayerBaseData struct {
-	*PlayerData
+	p    *Player
 	Data msg.ResPlayerBaseInfo
-	KeyValueData   map[int]string
-	MLeafTimer     *timer.Timer
-	MTicker        *time.Ticker
-	McronSave      *cron.Cron
-	McronSaveID    cron.EntryID
-	Mdispatr       *timer.Dispatcher
-	DailyRenewTime int32
-	Update         bool
-	isKeyValueDb   bool
 }
 
 func (p *PlayerBaseData) GetData() interface{} {
 	return &p.Data
 }
 
-func (p *PlayerBaseData) BackUp() *PlayerBaseData {
-	return &PlayerBaseData{
-		Data: msg.ResPlayerBaseInfo{
+func (p *PlayerBaseData) BackUp() msg.ResPlayerBaseInfo {
+	return msg.ResPlayerBaseInfo{
 		Diamond:           p.Data.Diamond,
 		DwUin:             p.Data.DwUin,
 		Energy:            p.Data.Energy,
@@ -62,14 +53,6 @@ func (p *PlayerBaseData) BackUp() *PlayerBaseData {
 		ChampshipsGroupID: p.Data.ChampshipsGroupID,
 		NoAd:              p.Data.NoAd,
 		FaceBookId:        p.Data.FaceBookId,
-		},
-		MLeafTimer:     p.MLeafTimer,
-		MTicker:        p.MTicker,
-		McronSave:      p.McronSave,
-		McronSaveID:    p.McronSaveID,
-		Mdispatr:       p.Mdispatr,
-		DailyRenewTime: p.DailyRenewTime,
-		isKeyValueDb:   p.isKeyValueDb,
 	}
 }
 
@@ -105,12 +88,9 @@ func (p *PlayerBaseData) LoadDataFromDB(UserName interface{}) bool {
 	sqlStr := "SELECT * FROM t_player_baseinfo WHERE user_name = ?"
 	sqlStruck := db.ResPlayerBaseInfo{}
 	if err := db.SqlDb.Get(&sqlStruck, sqlStr, UserName); err != nil {
-		log.Debug("get data failed, err:%v\n", err)
+		log.Debug("PlayerBaseData get data failed, err:%v\n", err)
 		return false
 	}
-	sqlStr1 := "SELECT * FROM t_player_client_data WHERE dwUin = ?"
-	sqlStruck1 := db.SqlModStruct{}
-	db.SqlDb.Get(&sqlStruck1, sqlStr1, sqlStruck.DwUin)
 
 	p.Data.Diamond = sqlStruck.Diamond
 	p.Data.DwUin = sqlStruck.DwUin
@@ -125,214 +105,61 @@ func (p *PlayerBaseData) LoadDataFromDB(UserName interface{}) bool {
 	p.Data.PackUnlockCount = sqlStruck.PackUnlockCount
 	p.Data.LastPlayTime = sqlStruck.LastPlayTime
 	p.Data.EnergyBuyCount = sqlStruck.EnergyBuyCount
-	p.Data.LoginTime = int32(time.Now().Unix())
 	p.Data.UserName = sqlStruck.UserName
 	p.Data.LogoutTime = sqlStruck.LogoutTime
 	p.Data.Todayolinetime = sqlStruck.Todayolinetime
 	p.Data.Rolecreatetime = sqlStruck.Rolecreatetime
 	p.Data.LastChampGroupID = sqlStruck.LastChampGroupID
 	p.Data.ChampshipsGroupID = sqlStruck.ChampshipsGroupID
-	p.DailyRenewTime = sqlStruck.DailyRenewTime
 	p.Data.NoAd = sqlStruck.NoAd
 	p.Data.FaceBookId = sqlStruck.FaceBookId
-	p.McronSave = cron.New()
-	p.Reconnect(false)
-	p.AddCompensateEmail()
-	p.KeyValueData = make(map[int]string)
-	var buf bytes.Buffer
-	buf.Write(sqlStruck1.ModData)
-	decode := gob.NewDecoder(&buf)
-	err := decode.Decode(&p.KeyValueData)
-	if err != nil {
-		p.KeyValueData = make(map[int]string)
-	}
+
 	return true
 }
 
-func (p *PlayerBaseData) ProcessCallback() {
-	deltaTime := p.Data.LoginTime - p.Data.LogoutTime
-
-	if p.M_Player.GetGameData("Player7DayCallBackData") == nil {
-		data := &Player7DayCallBackData{PlayerData: NewPlayerData("Player7DayCallBackData", p.M_Player)}
-		ok := data.LoadDataFromDB(p.Data.DwUin)
-		if ok {
-			p.M_Player.playerdata["Player7DayCallBackData"] = data
-			p.M_Player.playerdataIF["Player7DayCallBackData"] = data
-		}
-	}
-
-	if deltaTime >= 7*3600*24 && p.Data.LogoutTime > 0 {
-		p.M_Player.playerdataIF["Player7DayCallBackData"].(*Player7DayCallBackData).OpenNewCallBack()
-	} else {
-		p.M_Player.playerdataIF["Player7DayCallBackData"].(*Player7DayCallBackData).ProcessIsOutline()
-	}
-}
-
-func (p *PlayerBaseData) IsPlayerLoginCallback() bool {
-	return p.Data.LoginTime-p.Data.LogoutTime >= 7*3600*24 && p.Data.LogoutTime > 0
-}
-
-func (p *PlayerBaseData) GetRoleCreateTime() int32 {
-	return p.Data.Rolecreatetime
-}
-
-func (p *PlayerBaseData) AddSta() error {
-	curtime := time.Now().Unix()
-	delta := curtime - (int64)(p.Data.RecoverTime)
-	Recover := userCfg.GetRecover(int(p.Data.Level))
-	Addsta := int(delta) / Recover
-	if Addsta <= 0 {
-		return nil
-	}
-	if p.GetMaxEnergy() > p.Data.Energy {
-		p.Data.Energy = p.Data.Energy + int32(Addsta)
-		if p.Data.Energy > p.GetMaxEnergy() {
-			p.Data.Energy = p.GetMaxEnergy()
-		}
-		p.M_Player.CallEvent(time.Duration(Recover)*time.Second, func() {
-			p.M_Player.lock.Lock()
-			defer p.M_Player.lock.Unlock()
-			p.AddSta()
-		}, "AddEnergy")
-	}
-	p.Data.RecoverTime = int32(curtime)
-	p.M_Player.SendErrClienRes(p.BackAsset())
-	return nil
-}
-
-func (p *PlayerBaseData) Reconnect(b bool) {
-	p.AddSta()
-	if G_GameLogicPtr.DailyTaskTimestamp > (int64)(p.DailyRenewTime) {
-		p.DailyRenewTime = int32(G_GameLogicPtr.DailyTaskTimestamp)
-		p.Data.EnergyBuyCount = 0
-	}
-	GoUtil.RegisterEvent(MergeConst.Notify_Daily_Renew, p.Notify_Daily_Renew, p)
-}
-
-func (p *PlayerBaseData) AddCompensateEmail() {
-	G_GameLogicPtr.MOldPlayerCompensateMgr.SendEmailToDb(p.Data.UserName, p.Data.DwUin)
-}
-
-func (p *PlayerBaseData) SetChampshipID(ChampshipsGroupID int32, isNotify bool) {
-	p.Data.LastChampGroupID = p.Data.ChampshipsGroupID
-	p.Data.ChampshipsGroupID = ChampshipsGroupID
-
-	if isNotify {
-		notify := &msg.NotifyChampshipOpen{}
-		notify.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
-		notify.LastChampshipsGroupID = p.Data.LastChampGroupID
-		notify.ChampshipsGroupID = p.Data.ChampshipsGroupID
-		agent := p.GetPlayer().GetAgentByPlayer()
-		data, _ := proto.Marshal(notify)
-		G_getGameLogic().PackResInfo(agent, "NotifyChampshipOpen", data)
-
-	}
-
-	p.SaveDataFromDB("")
-}
-
-func (p *PlayerBaseData) Notify_Daily_Renew(param []interface{}) {
-	p.Data.EnergyBuyCount = 0
-	p.DailyRenewTime = int32(G_GameLogicPtr.DailyTaskTimestamp)
-	notify := &msg.NotifyRenewBuyEnergyCnt{}
-	notify.DwUin = p.M_Player.M_DwUin
-	notify.CurCnt = 0
-
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(notify)
-	G_getGameLogic().PackResInfo(agent, "NotifyRenewBuyEnergyCnt", data)
-	p.SaveDataFromDB("")
-}
-
 func (p *PlayerBaseData) SaveDataFromDB(Key interface{}) bool {
-	// G_getGameLogic().Mlogger.Debug("SaveDataFromDB:", p.Data.DwUin)
+	BaseMod := p.p.PlayMod.getBaseMod()
 	sqlStruck := db.ResPlayerBaseInfo{}
-	sqlStruck.Diamond = p.Data.Diamond
+	sqlStruck.Diamond = int32(BaseMod.Diamond)
 	sqlStruck.DwUin = p.Data.DwUin
-	sqlStruck.Energy = p.Data.Energy
-	sqlStruck.Star = p.Data.Star
-	sqlStruck.RecoverTime = p.Data.RecoverTime
-	sqlStruck.Level = p.Data.Level
-	sqlStruck.Exp = p.Data.Exp
+	sqlStruck.Energy = int32(BaseMod.Energy)
+	sqlStruck.Star = int32(BaseMod.Star)
+	sqlStruck.RecoverTime = int32(BaseMod.RecoverTime)
+	sqlStruck.Level = int32(BaseMod.Level)
+	sqlStruck.Exp = int32(BaseMod.Exp)
 	sqlStruck.StartOrderId = p.Data.StartOrderId
 	sqlStruck.MusicCode = p.Data.MusicCode
 	sqlStruck.Guild = p.Data.Guild
 	sqlStruck.PackUnlockCount = p.Data.PackUnlockCount
 	sqlStruck.LastPlayTime = p.Data.LastPlayTime
 	sqlStruck.EnergyBuyCount = p.Data.EnergyBuyCount
-	sqlStruck.LoginTime = p.Data.LoginTime
+	sqlStruck.LoginTime = int32(BaseMod.LoginTime)
 	sqlStruck.UserName = p.Data.UserName
-	sqlStruck.LogoutTime = p.Data.LogoutTime
+	sqlStruck.LogoutTime = int32(BaseMod.LogoutTime)
 	sqlStruck.Todayolinetime = p.Data.Todayolinetime
 	sqlStruck.Rolecreatetime = p.Data.Rolecreatetime
-	sqlStruck.DailyRenewTime = p.DailyRenewTime
 	sqlStruck.NoAd = p.Data.NoAd
 	sqlStruck.ChampshipsGroupID = p.Data.ChampshipsGroupID
 	sqlStruck.LastChampGroupID = p.Data.LastChampGroupID
 	sqlStruck.FaceBookId = p.Data.FaceBookId
+	sqlStruck.NickName = BaseMod.NickName
 	db.FormatAllMemUpdateDb(&sqlStruck, "t_player_baseinfo", "dwUin")
 
-	// 存储KeyValue
-	var buf bytes.Buffer
-	encode := gob.NewEncoder(&buf)
-	encode.Encode(p.KeyValueData)
-	db.SavePlayerClientData(&db.SqlModStruct{
-		DwUin:      p.Data.DwUin,
-		ModData:    buf.Bytes(),
-		UpdataTime: int32(GoUtil.Now()),
-	})
 	return true
 }
 
-func (p *PlayerBaseData) GetMaxEnergyMul() int {
-	MaxEnergyMul := userCfg.GetEnergyMulByLv(int(p.Data.Level))
-	if p.M_Player.PlayMod.getLimitedTimeEventMod().CheckExist(limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER) {
-		MaxEnergyMul = 10
+func (p *PlayerBaseData) GetMaxEnergyMul(player *Player) int {
+	BaseMod := player.PlayMod.getBaseMod()
+	MaxEnergyMul := baseCfg.GetMaxEnergyMul(BaseMod.GetLevel(), BaseMod.GetEnergy())
+	if player.PlayMod.getLimitedTimeEventMod().CheckExist(limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER) {
+		MaxEnergyMul = 11
 	}
 	return MaxEnergyMul
 }
 
-func (p *PlayerBaseData) GetMaxEnergy() int32 {
-	MaxSta := MergeConst.G_Sta_Limit
-
-	if p.Data.Level < 7 {
-		MaxSta = MergeConst.G_Sta_Limit
-	} else if p.Data.Level < 12 {
-		MaxSta = 120
-	} else if p.Data.Level < 19 {
-		MaxSta = 130
-	} else if p.Data.Level < 27 {
-		MaxSta = 135
-	} else if p.Data.Level < 38 {
-		MaxSta = 140
-	} else if p.Data.Level < 44 {
-		MaxSta = 145
-	} else if p.Data.Level < 59 {
-		MaxSta = 150
-	} else {
-		MaxSta = 155
-	}
-	return MaxSta
-}
-
-// 定时增加体力
-func (p *PlayerBaseData) NotifyAddSta(cnt int, timeStamp int64) {
-	p.M_Player.lock.Lock()
-	defer p.M_Player.lock.Unlock()
-	if p.GetMaxEnergy() <= p.Data.Energy {
-		return
-	}
-	G_getGameLogic().Mlogger.Debug("NotifyAddSta:", p.Data.DwUin)
-	p.Data.Energy = p.Data.Energy + int32(cnt)
-	p.Data.RecoverTime = int32(timeStamp)
-
-	notify := &msg.NotifyAddEnergy{}
-	notify.AddCnt = int32(cnt)
-	notify.DwUin = p.M_Player.M_DwUin
-
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(notify)
-	G_getGameLogic().PackResInfo(agent, "NotifyAddEnergy", data)
+func (p *PlayerBaseData) GetMaxEnergy() int {
+	BaseMod := p.p.PlayMod.getBaseMod()
+	return userCfg.GetEnergyMax(BaseMod.Level)
 }
 
 // 更新游戏道具
@@ -351,43 +178,41 @@ func (p *PlayerBaseData) UpdateBaseItemInfo(update *msg.UpdateBaseItemInfo) {
 			p.Data.LastPlayTime = v
 		}
 	}
-	p.SaveDataFromDB("")
 }
 
-func (p *PlayerBaseData) ReqRemoveAd(buf []byte) {
+func (p *PlayerBaseData) ReqRemoveAd(player *Player, buf []byte) {
 	req := &msg.ReqRemoveAd{}
 	res := &msg.ResRemoveAd{}
 	proto.Unmarshal(buf, req)
 
 	p.Data.NoAd = 1
 	res.ResultCode = 0
-	p.SaveDataFromDB("")
 
-	agent := p.GetPlayer().GetAgentByPlayer()
+	agent := player.GetAgentByPlayer()
 	data, _ := proto.Marshal(res)
 	G_getGameLogic().PackResInfo(agent, "ResRemoveAd", data)
 }
 
 func (p *PlayerBaseData) ResPlayerBaseInfo(player *Player) {
-	if player != p.M_Player {
-		return
-	}
-	agent := p.GetPlayer().GetAgentByPlayer()
+	BaseMod := player.PlayMod.getBaseMod()
+	player.PushClientRes(&msg.ResPlayerBaseInfo{
+		DwUin:       p.Data.DwUin,
+		Energy:      int32(BaseMod.Energy),
+		Star:        int32(BaseMod.Star),
+		RecoverTime: int32(BaseMod.RecoverTime),
+		Diamond:     int32(BaseMod.Diamond),
+		Level:       int32(BaseMod.Level),
+		Exp:         int32(BaseMod.Exp),
+		LoginTime:   int32(BaseMod.LoginTime),
+		LogoutTime:  int32(BaseMod.LogoutTime),
+		FaceBookId:  p.Data.FaceBookId,
+	})
+	agent := player.GetAgentByPlayer()
 	data, _ := proto.Marshal(&p.Data)
 	G_getGameLogic().PackResInfo(agent, "ResPlayerBaseInfo", data)
 }
 
-func (p *PlayerBaseData) BackKv() *msg.ResKv {
-	kv := make(map[int32]string)
-	for k, v := range p.KeyValueData {
-		kv[int32(k)] = v
-	}
-	return &msg.ResKv{
-		Kv: kv,
-	}
-}
-
-func (p *PlayerBaseData) ReqBindFacebookAccount(buf []byte) {
+func (p *PlayerBaseData) ReqBindFacebookAccount(player *Player, buf []byte) {
 	req := &msg.ReqBindFacebookAccount{}
 	res := &msg.ResBindFacebookAccount{}
 	proto.Unmarshal(buf, req)
@@ -411,15 +236,21 @@ func (p *PlayerBaseData) ReqBindFacebookAccount(buf []byte) {
 		res.ResultCode = 0
 		p.Data.FaceBookId = req.BindAccountId
 		res.BindAccountId = req.BindAccountId
-		p.SaveDataFromDB("")
+		player.TeLog("platform_connect", map[string]interface{}{
+			"platform_type": "Facebook",
+			"platform_id":   req.BindAccountId,
+			"is_reward":     false,
+		})
 	}
-
-	agent := p.GetPlayer().GetAgentByPlayer()
+	BaseMod := player.PlayMod.getBaseMod()
+	BaseMod.FackBookId = req.BindAccountId
+	agent := player.GetAgentByPlayer()
 	data, _ := proto.Marshal(res)
+	p.SaveDataFromDB("")
 	G_getGameLogic().PackResInfo(agent, "ResBindFacebookAccount", data)
 }
 
-func (p *PlayerBaseData) ReqUnBindFacebook(buf []byte) {
+func (p *PlayerBaseData) ReqUnBindFacebook(player *Player, buf []byte) {
 	req := &msg.ReqUnBindFacebook{}
 	res := &msg.ResUnBindFacebook{}
 	proto.Unmarshal(buf, req)
@@ -427,13 +258,18 @@ func (p *PlayerBaseData) ReqUnBindFacebook(buf []byte) {
 	res.ResultCode = 0
 	res.BindAccountId = req.BindAccountId
 	p.Data.FaceBookId = ""
-	p.SaveDataFromDB("")
-
-	agent := p.GetPlayer().GetAgentByPlayer()
+	BaseMod := player.PlayMod.getBaseMod()
+	BaseMod.FackBookId = ""
+	agent := player.GetAgentByPlayer()
 	data, _ := proto.Marshal(res)
 	G_getGameLogic().PackResInfo(agent, "ResUnBindFacebook", data)
+	p.SaveDataFromDB("")
+	player.TeLog("platform_disconnect", map[string]interface{}{
+		"platform_type": "Facebook",
+		"platform_id":   req.BindAccountId,
+	})
 }
-func (p *PlayerBaseData) ReqOnlyBindFacebook(buf []byte) {
+func (p *PlayerBaseData) ReqOnlyBindFacebook(player *Player, buf []byte) {
 	req := &msg.ReqOnlyBindFacebook{}
 	res := &msg.ResOnlyBindFacebook{}
 	proto.Unmarshal(buf, req)
@@ -441,8 +277,8 @@ func (p *PlayerBaseData) ReqOnlyBindFacebook(buf []byte) {
 	sqlStr := "SELECT * FROM t_player_baseinfo WHERE FaceBookId = ?"
 	sqlStruck := db.ResPlayerBaseInfo{}
 	isHaveOther := false
-
-	if err := db.SqlDb.Get(&sqlStruck, sqlStr, req.BindAccountId); err != nil {
+	err := db.SqlDb.Get(&sqlStruck, sqlStr, req.BindAccountId)
+	if err != nil {
 		isHaveOther = false
 	} else {
 		isHaveOther = true
@@ -452,25 +288,52 @@ func (p *PlayerBaseData) ReqOnlyBindFacebook(buf []byte) {
 			res.ResultCode = MergeConst.Protocol_FaceBook_Binded
 		} else {
 			sqlStruck.FaceBookId = ""
-			db.FormatAllMemUpdateDb(&sqlStruck, "t_player_baseinfo", "dwUin")
+
+			// 修改双方的faceBookId
+			ctx := context.Background()
+			txOptions := &sql.TxOptions{}
+			tx, _ := db.SqlDb.BeginTx(ctx, txOptions)
+			sqlStr := "update t_player_baseinfo set FaceBookId = ? where dwUin = ?"
+			_, err := tx.Exec(sqlStr, "", sqlStruck.DwUin)
+			if err != nil {
+				tx.Rollback()
+				return
+			}
+			sqlStr = "update t_player_baseinfo set FaceBookId = ? where dwUin = ?"
+			_, err = tx.Exec(sqlStr, req.BindAccountId, p.Data.DwUin)
+			if err != nil {
+				tx.Rollback()
+				return
+			}
+			tx.Commit()
+			FriendMgrSend(&Msg.Msg{
+				Type: Msg.HANDLE_TYPE_FACEBOOK_UNBIND,
+				To:   int(sqlStruck.DwUin),
+			})
 			res.ResultCode = 0
 			p.Data.FaceBookId = req.BindAccountId
 			res.BindAccountId = req.BindAccountId
-			p.SaveDataFromDB("")
+			player.TeLog("platform_connect", map[string]interface{}{
+				"platform_type": "Facebook",
+				"platform_id":   req.BindAccountId,
+				"is_reward":     false,
+			})
+
 		}
 	} else {
 		res.ResultCode = 0
 		p.Data.FaceBookId = req.BindAccountId
 		res.BindAccountId = req.BindAccountId
-		p.SaveDataFromDB("")
 	}
-
-	agent := p.GetPlayer().GetAgentByPlayer()
+	BaseMod := player.PlayMod.getBaseMod()
+	BaseMod.FackBookId = req.BindAccountId
+	p.SaveDataFromDB("")
+	agent := player.GetAgentByPlayer()
 	data, _ := proto.Marshal(res)
 	G_getGameLogic().PackResInfo(agent, "ResOnlyBindFacebook", data)
 }
 
-func (p *PlayerBaseData) ReqSynGameData(buf []byte) {
+func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
 	req := &msg.ReqSynGameData{}
 	res := &msg.ResSynGameData{}
 	proto.Unmarshal(buf, req)
@@ -484,11 +347,11 @@ func (p *PlayerBaseData) ReqSynGameData(buf []byte) {
 	} else {
 		isHaveOther = true
 	}
-	if sqlStruck.DwUin == p.M_Player.M_DwUin {
+	if sqlStruck.DwUin == player.M_DwUin {
 		return
 	}
-
-	if OldPlayer, ok := G_GameLogicPtr.M_Players[sqlStruck.DwUin]; ok {
+	OldPlayer := G_GameLogicPtr.GetPlayer(sqlStruck.DwUin)
+	if OldPlayer != nil {
 		agent := OldPlayer.GetAgentByPlayer()
 		// notify := &msg.ForceKickOut{}
 		notify := &msg.ResSynGameData{}
@@ -497,16 +360,7 @@ func (p *PlayerBaseData) ReqSynGameData(buf []byte) {
 			G_getGameLogic().PackResInfo(agent, "ResSynGameData", data)
 		}
 		OldPlayer.ClearData()
-		delete(G_GameLogicPtr.M_Players, sqlStruck.DwUin)
-	} else {
-		player := G_GameLogicPtr.FindOfflinePlayer(sqlStruck.DwUin)
-		if player != nil {
-			timer1 := G_GameLogicPtr.MReadyToRemoveList[player]
-			timer1.Disabled()
-			G_GameLogicPtr.Mdispatr.ChanTimer <- timer1
-			timer1.Stop()
-			delete(G_GameLogicPtr.MReadyToRemoveList, player)
-		}
+		G_GameLogicPtr.M_Players.Delete(sqlStruck.DwUin)
 	}
 
 	if isHaveOther {
@@ -516,39 +370,58 @@ func (p *PlayerBaseData) ReqSynGameData(buf []byte) {
 			ReplaceName := sqlStruck.UserName
 			UserName := p.Data.UserName
 			res.ResultCode = 0
-
+			// 修改双方的账号
+			ctx := context.Background()
+			txOptions := &sql.TxOptions{}
+			tx, _ := db.SqlDb.BeginTx(ctx, txOptions)
 			sqlStr1 := "SELECT * FROM t_account WHERE user_name = ?"
 			sqlAccStruck1 := db.Db_Account{}
-			if err2 := db.SqlDb.Get(&sqlAccStruck1, sqlStr1, UserName); err2 != nil {
-
-			} else {
+			err2 := db.SqlDb.Get(&sqlAccStruck1, sqlStr1, UserName)
+			if err2 == nil {
 				sqlAccStruck1.UserName = ""
-				db.FormatAllMemUpdateDb(&sqlAccStruck1, "t_account", "auto_id")
+				_, err := db.SqlDb.Exec("update t_account set user_name = ?  where auto_id = ?", sqlAccStruck1.UserName, sqlAccStruck1.AutoId)
+				if err != nil {
+					tx.Rollback()
+					return
+				}
 			}
 			p.Data.UserName = ""
-			p.SaveDataFromDB("")
+			_, err := db.SqlDb.Exec("update t_player_baseinfo set user_name = ? , FaceBookId = ? where dwUin = ?", "", "", p.Data.DwUin)
+			if err != nil {
+				tx.Rollback()
+				return
+			}
 
 			sqlStruck.FaceBookId = req.NewFBId
 			sqlStruck.UserName = UserName
-			db.FormatAllMemUpdateDb(&sqlStruck, "t_player_baseinfo", "dwUin")
+			_, err = db.SqlDb.Exec("update t_player_baseinfo set user_name = ?, FaceBookId = ? where dwUin = ?", UserName, req.NewFBId, sqlStruck.DwUin)
+			if err != nil {
+				tx.Rollback()
+				return
+			}
 
 			sqlStr := "SELECT * FROM t_account WHERE user_name = ?"
 			sqlAccStruck := db.Db_Account{}
-
-			if err2 := db.SqlDb.Get(&sqlAccStruck, sqlStr, ReplaceName); err2 != nil {
-
-			} else {
+			err2 = db.SqlDb.Get(&sqlAccStruck, sqlStr, ReplaceName)
+			if err2 == nil {
 				sqlAccStruck.UserName = UserName
-				db.FormatAllMemUpdateDb(&sqlAccStruck, "t_account", "auto_id")
+				_, err := db.SqlDb.Exec("update t_account set user_name = ? where auto_id = ?", sqlAccStruck.UserName, sqlAccStruck.AutoId)
+				if err != nil {
+					tx.Rollback()
+					return
 				}
-
+			}
+			tx.Commit()
 		}
 	} else {
 		res.ResultCode = 0
 
 	}
-
-	agent := p.GetPlayer().GetAgentByPlayer()
+	p.p.TeLog("ReqSynGameData", map[string]interface{}{
+		"platform_type": "facebook",
+	})
+	p.SaveDataFromDB("")
+	agent := player.GetAgentByPlayer()
 	data, _ := proto.Marshal(res)
 	G_getGameLogic().PackResInfo(agent, "ResSynGameData", data)
 }
@@ -556,117 +429,190 @@ func (p *PlayerBaseData) ReqSynGameData(buf []byte) {
 func (p *PlayerBaseData) ClearData() bool {
 	p.Data.LogoutTime = int32(time.Now().Unix())
 	p.SaveDataFromDB("")
-	GoUtil.RemoveEvent(MergeConst.Notify_Daily_Renew, p.Notify_Daily_Renew, p)
-	p.McronSave.Remove(p.McronSaveID)
-	p.McronSave.Stop()
-	if p.MLeafTimer != nil {
-		p.MLeafTimer.Stop()
-		p.MLeafTimer = nil
-	}
-	if p.MTicker != nil {
-		p.MTicker.Stop()
-		p.MTicker = nil
-	}
 	return true
 }
 
+func (p *PlayerBaseData) GetRegisterTime() int64 {
+	return int64(p.Data.Rolecreatetime)
+}
+
 // 增加减少体力
-func (p *PlayerBaseData) AddEnergy(cnt int) error {
-	NewEnergy := p.Data.Energy + int32(cnt)
+func (p *PlayerBaseData) AddEnergy(player *Player, cnt int) error {
+	BaseMod := p.p.PlayMod.getBaseMod()
+	NewEnergy := BaseMod.Energy + cnt
 	if NewEnergy < 0 {
 		return errors.New("能量不足")
 	}
 	if cnt < 0 {
-		p.M_Player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_ENERGY, A: []interface{}{-cnt}})
+		player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_ENERGY, A: []interface{}{-cnt}})
+		// BaseMod.FormatEnergyMul(NewEnergy)
+		p.p.PushClientRes(BaseMod.BackData())
 	}
-	if p.Data.Energy >= p.GetMaxEnergy() && NewEnergy < p.GetMaxEnergy() {
-		Recover := userCfg.GetRecover(int(p.Data.Level))
-		p.M_Player.CallEvent(time.Duration(Recover)*time.Second, func() {
-			p.M_Player.lock.Lock()
-			defer p.M_Player.lock.Unlock()
-			p.AddSta()
+	if BaseMod.Energy >= p.GetMaxEnergy() && NewEnergy < p.GetMaxEnergy() {
+		Recover := userCfg.GetRecover(int(BaseMod.Level))
+		player.CallEvent(time.Duration(Recover)*time.Second, func() {
+			player.lock.Lock()
+			defer player.lock.Unlock()
+			LimitedTimeEnergyAdd(player)
 		}, "AddEnergy")
-		p.Data.RecoverTime = int32(time.Now().Unix())
+		BaseMod.RecoverTime = time.Now().Unix()
 	}
-	p.Data.Energy = NewEnergy
+	BaseMod.Energy = NewEnergy
 	return nil
 }
 
 // 增加减少星星
-func (p *PlayerBaseData) AddStar(cnt int) error {
-	NewStar := p.Data.Star + int32(cnt)
+func (p *PlayerBaseData) AddStar(player *Player, cnt int) error {
+	BaseMod := p.p.PlayMod.getBaseMod()
+	NewStar := BaseMod.Star + cnt
 	if NewStar < 0 {
 		return errors.New("星星不足")
 	}
-
-	p.Data.Star = NewStar
+	if cnt > 0 {
+		player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_STAR, A: []interface{}{cnt}})
+	}
+	BaseMod.Star = NewStar
+	player.UpdateUserInfo()
 	return nil
 }
 
 // 增加减少钻石
 func (p *PlayerBaseData) AddDiamond(cnt int) error {
-	NewDiamond := p.Data.Diamond + int32(cnt)
+	BaseMod := p.p.PlayMod.getBaseMod()
+	NewDiamond := BaseMod.Diamond + cnt
 	if NewDiamond < 0 {
 		return errors.New("钻石不足")
 	}
-	p.Data.Diamond = NewDiamond
+	BaseMod.Diamond = NewDiamond
 	return nil
 }
 
 // 增加经验
-func (p *PlayerBaseData) AddExp(exp int) (int, error) {
-	p.Data.Exp += int32(exp)
+func (p *PlayerBaseData) AddExp(player *Player, exp int, pexp int) (int, error) {
+	BaseMod := player.PlayMod.getBaseMod()
+	BaseMod.Exp += exp
+	BaseMod.PExp += pexp
 	upLv := 0
-	upExp := userCfg.GetLevUpExp(int(p.Data.Level))
-	if p.Data.Exp >= int32(upExp) {
-		p.Data.Level++
-		p.Data.Exp -= int32(upExp)
-
+	upExp, upPExp := userCfg.GetLevUpExp(BaseMod.Level)
+	Num := 0
+	UpLevelItem := make([]*item.Item, 0)
+	for BaseMod.Exp >= upExp && BaseMod.PExp >= upPExp {
+		if Num > 100 {
+			break
+		}
+		Num++
+		BaseMod.Level++
+		BaseMod.Exp -= upExp
+		BaseMod.PExp -= upPExp
+		upExp, upPExp = userCfg.GetLevUpExp(BaseMod.Level)
 		// 日常任务解锁
-		DailyTaskMod := p.M_Player.PlayMod.getDailyTaskMod()
-		DecorateMod := p.M_Player.PlayMod.getDecorateMod()
-		if DailyTaskMod.LevUpTrigger(int(p.Data.Level), DecorateMod.GetAreaId()) {
-			p.M_Player.PushClientRes(DailyTaskMod.BackData())
+		DailyTaskMod := player.PlayMod.getDailyTaskMod()
+		DecorateMod := player.PlayMod.getDecorateMod()
+		if DailyTaskMod.LevUpTrigger(BaseMod.Level, DecorateMod.GetAreaId()) {
+			player.PushClientRes(DailyTaskMod.BackData())
 		}
-		upLv = int(p.Data.Level)
-
+		upLv = BaseMod.Level
+		Items := userCfg.GetLevUpReward(upLv)
+		UpLevelItem = item.Merge(UpLevelItem, Items)
 		// 棋盘背包解锁
-		p.M_Player.PushClientRes(p.BackAsset())
-		ChessMod := p.M_Player.PlayMod.getChessMod()
-		if ChessMod.TriggerChessBagUnlock(int(p.Data.Level)) {
-			p.M_Player.PushClientRes(ChessMod.BackData())
+		player.PushClientRes(p.BackAsset())
+		ChessMod := player.PlayMod.getChessMod()
+		if ChessMod.TriggerChessBagUnlock(int(BaseMod.Level)) {
+			player.PushClientRes(ChessMod.BackData())
 		}
-
-		ChargeMod := p.M_Player.PlayMod.getChargeMod()
-		ChargeMod.TriggerChargeUnlock(int(p.Data.Level), ChessMod.GetEmitList())
-		p.M_Player.PushClientRes(ChargeMod.BackData())
+		GuideTaskMod := player.PlayMod.getGuideTaskMod()
+		if GuideTaskMod.Unlock(BaseMod.Level) {
+			player.PushClientRes(GuideTaskMod.BackData())
 		}
-	p.M_Player.PushClientRes(p.BackAsset())
+		ChargeMod := player.PlayMod.getChargeMod()
+		ChargeMod.TriggerChargeUnlock(int(BaseMod.Level), ChessMod.GetEmitList())
+		player.PushClientRes(ChargeMod.BackData())
+		OrderMod := player.PlayMod.getOrderMod()
+		player.TriggerOrder(BaseMod.Level, order.TRIGGER_TYPE_LV, ChessMod.GetOrderEmit(), player.PlayMod.getBaseMod().GetEnergyMul())
+		player.PushClientRes(OrderMod.BackData())
+		// 重载活动
+		player.initAcitivity()
+		player.BackDataActivity()
+		player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_UPLV})
+		player.TeLog("level_up", map[string]interface{}{
+			"after_level": BaseMod.Level,
+		})
+		NewExpLv, NewPetLv := userCfg.GetNewLevUpExp(BaseMod.Level, BaseMod.Exp, BaseMod.PExp)
+		player.TeLog("property_level_up", map[string]interface{}{
+			"property_level":        BaseMod.Level,
+			"property_level_reward": userCfg.GetUnlock(int(BaseMod.Level)),
+			"story_level":           NewExpLv,
+			"pet_level":             NewPetLv,
+		})
+		player.HandleInUserRank()
+	}
+	if len(UpLevelItem) > 0 {
+		err := player.HandleItem(UpLevelItem, msg.ITEM_POP_LABEL_LevUpReward.String())
+		if err != nil {
+			return 0, err
+		}
+	}
+	EmitRetireTrigger2(player)
+	player.InitOrderItem()
+	player.PushClientRes(p.BackAsset())
 	return upLv, nil
 }
 
 func (p *PlayerBaseData) GetLevel() int {
-	return int(p.Data.Level)
+	BaseMod := p.p.PlayMod.getBaseMod()
+	return BaseMod.Level
+}
+
+func (p *PlayerBaseData) GetExp() int {
+	BaseMod := p.p.PlayMod.getBaseMod()
+	return BaseMod.Exp
+}
+
+func (p *PlayerBaseData) GetDiamond() int {
+	BaseMod := p.p.PlayMod.getBaseMod()
+	return BaseMod.Diamond
+}
+
+func (p *PlayerBaseData) GetEnergy() int {
+	BaseMod := p.p.PlayMod.getBaseMod()
+	return BaseMod.Energy
+}
+
+func (p *PlayerBaseData) SetEnergy(Energy int) {
+	BaseMod := p.p.PlayMod.getBaseMod()
+	BaseMod.Energy = Energy
+}
+
+func (p *PlayerBaseData) GetStar() int {
+	BaseMod := p.p.PlayMod.getBaseMod()
+	return BaseMod.Star
 }
 
 func (p *PlayerBaseData) BackAsset() *msg.ResPlayerAsset {
+	BaseMod := p.p.PlayMod.getBaseMod()
 	return &msg.ResPlayerAsset{
-		DwUin:       p.Data.DwUin,
-		Diamond:     p.Data.Diamond,
-		Energy:      p.Data.Energy,
-		Star:        p.Data.Star,
-		RecoverTime: p.Data.RecoverTime,
-		Level:       p.Data.Level,
-		Exp:         p.Data.Exp,
+		DwUin:       BaseMod.Uid,
+		Diamond:     int32(BaseMod.Diamond),
+		Energy:      int32(BaseMod.Energy),
+		Star:        int32(BaseMod.Star),
+		RecoverTime: int32(BaseMod.RecoverTime),
+		Level:       int32(BaseMod.Level),
+		Exp:         int32(BaseMod.Exp),
+		Login:       int32(BaseMod.LoginTime),
+		Logout:      int32(BaseMod.LogoutTime),
+		PExp:        int32(BaseMod.PExp),
+		LoginDay:    int32(BaseMod.LoginDay),
 	}
 }
 
 func (p *PlayerBaseData) GetSevenLoginAdd() int {
-	return userCfg.GetSevenloginAdd(int(p.Data.Level))
+	BaseMod := p.p.PlayMod.getBaseMod()
+	return userCfg.GetSevenloginAdd(BaseMod.GetLevel())
 }
 
 func (p *PlayerBaseData) GetLastLoginTime() int {
-	return int(p.Data.LoginTime)
+	BaseMod := p.p.PlayMod.getBaseMod()
+	return int(BaseMod.LoginTime)
 }
 
 func (p *PlayerBaseData) GetName() string {
@@ -674,14 +620,15 @@ func (p *PlayerBaseData) GetName() string {
 }
 
 func (p *PlayerBaseData) GetLoginTime() int64 {
-	return int64(p.Data.LoginTime)
+	BaseMod := p.p.PlayMod.getBaseMod()
+	return int64(BaseMod.LoginTime)
 }
 
 func (p *PlayerBaseData) GetDataByUid(Uid interface{}) bool {
 	sqlStr := "SELECT * FROM t_player_baseinfo WHERE dwUin = ?"
 	sqlStruck := db.ResPlayerBaseInfo{}
 	if err := db.SqlDb.Get(&sqlStruck, sqlStr, Uid); err != nil {
-		log.Debug("get data failed, err:%v\n", err)
+		// log.Debug("get data failed, err:%v\n", err)
 		return false
 	}
 
@@ -698,26 +645,14 @@ func (p *PlayerBaseData) GetDataByUid(Uid interface{}) bool {
 	p.Data.PackUnlockCount = sqlStruck.PackUnlockCount
 	p.Data.LastPlayTime = sqlStruck.LastPlayTime
 	p.Data.EnergyBuyCount = sqlStruck.EnergyBuyCount
-	p.Data.LoginTime = int32(time.Now().Unix())
+	p.Data.LoginTime = sqlStruck.LoginTime
 	p.Data.UserName = sqlStruck.UserName
 	p.Data.LogoutTime = sqlStruck.LogoutTime
 	p.Data.Todayolinetime = sqlStruck.Todayolinetime
 	p.Data.Rolecreatetime = sqlStruck.Rolecreatetime
 	p.Data.LastChampGroupID = sqlStruck.LastChampGroupID
 	p.Data.ChampshipsGroupID = sqlStruck.ChampshipsGroupID
-	p.DailyRenewTime = sqlStruck.DailyRenewTime
 	p.Data.NoAd = sqlStruck.NoAd
 	p.Data.FaceBookId = sqlStruck.FaceBookId
-	p.McronSave = cron.New()
-	p.Reconnect(false)
-	p.AddCompensateEmail()
 	return true
 }
-
-func (p *PlayerBaseData) SetKv(Key int, Value string) error {
-	if p.KeyValueData == nil {
-		p.KeyValueData = make(map[int]string)
-	}
-	p.KeyValueData[Key] = Value
-	return nil
-}

src/server/game/PlayerChessMod.go

@@ -4,71 +4,27 @@ import (
 	"fmt"
 	"math"
 	"server/GoUtil"
+	"server/conf"
 	mergeDataCfg "server/conf/mergeData"
-	"server/db"
+	orderCfg "server/conf/order"
 	"server/game/mod/item"
+	"server/game/mod/limitedTimeEvent"
+	"server/game/mod/order"
 	"server/game/mod/quest"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 	"sort"
-	"strconv"
-	"strings"
 
 	"google.golang.org/protobuf/proto"
 )
 
 type PlayerChessData struct {
-	*PlayerData
 	Data      msg.ResPlayerChessData
 	ColorData msg.ResChessColorData
 }
 
 func (p *PlayerChessData) LoadDataFromDB(dwUin interface{}) bool {
-	sqlStr := "SELECT * FROM t_player_chess_data WHERE dwUin = ?"
-	sqlStruck := db.SqlChessStruct{}
-	p.Data.MChessData = make(map[string]int32)
-	p.ColorData.MChessColorData = make(map[string]int32)
 
-	if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin.(int32)); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
-		p.IsHaveDataDb = false
-	} else {
-		p.IsHaveDataDb = true
-	}
-
-	if sqlStruck.MChessData != "" {
-		arr := strings.Split(sqlStruck.MChessData, "_")
-
-		for i := 0; i < len(arr); i++ {
-			ss := strings.Split(arr[i], ",")
-			id, err := strconv.ParseInt(ss[1], 10, 32)
-			key := ss[0]
-
-			if err != nil {
-				panic(err)
-			}
-
-			p.Data.MChessData[key] = int32(id)
-		}
-	}
-	if sqlStruck.MChessColorData != "" {
-		arr := strings.Split(sqlStruck.MChessColorData, "_")
-
-		for i := 0; i < len(arr); i++ {
-			ss := strings.Split(arr[i], ",")
-			id, err := strconv.ParseInt(ss[1], 10, 32)
-			key := ss[0]
-
-			if err != nil {
-				panic(err)
-			}
-
-			p.ColorData.MChessColorData[key] = int32(id)
-		}
-	}
-
-	p.Data.DwUin = dwUin.(int32)
-	p.Reconnect(false)
 	return true
 }
 
@@ -76,132 +32,109 @@ func (p *PlayerChessData) Reconnect(b bool) {
 
 }
 
-func (p *PlayerChessData) SetValueByKey(k string) {
-	if k != "" {
-		p.Data.MChessData[k] = p.Data.MChessData[k] + 1
-	}
-}
-
-func (p *PlayerChessData) GetValueByKey(k string) int32 {
-
-	v, ok := p.Data.MChessData[k]
-	if ok {
-		return v
-	}
-	return -1
-}
-func (p *PlayerChessData) GetKeyByEmitID(EmitID int32) string {
-	for k := range p.Data.MChessData {
-		units := strings.Split(k, "@")
-		if len(units) >= 4 {
-			n, _ := strconv.Atoi(units[3])
-			if EmitID == int32(n) {
-				return k
-			}
-		}
-	}
-	return ""
-}
-
 func (p *PlayerChessData) SaveDataFromDB(Key interface{}) bool {
-	var strarr []string
-	var strarr1 []string
-	for k, v := range p.Data.MChessData {
-		str := fmt.Sprintf("%s,%d", k, v)
-		strarr = append(strarr, str)
-	}
-	str_concat := strings.Join(strarr, "_")
 
-	for k, v := range p.ColorData.MChessColorData {
-		str := fmt.Sprintf("%s,%d", k, v)
-		strarr1 = append(strarr1, str)
-	}
-	str_concat1 := strings.Join(strarr1, "_")
-
-	sqlStruck := db.SqlChessStruct{}
-	sqlStruck.DwUin = p.M_Player.M_DwUin
-	sqlStruck.MChessData = str_concat
-	sqlStruck.MChessColorData = str_concat1
-	if p.IsHaveDataDb {
-		db.FormatAllMemUpdateDb(&sqlStruck, "t_player_chess_data", "dwUin")
-	} else {
-		db.FormatAllMemInsertDb(&sqlStruck, "t_player_chess_data")
-	}
-	p.IsHaveDataDb = true
 	return true
 }
 
 func (p *PlayerChessData) ResPlayerChessData(player *Player) {
-	if player != p.M_Player {
-		return
-	}
-	agent := p.GetPlayer().GetAgentByPlayer()
+	agent := player.GetAgentByPlayer()
 	Msg := &p.Data
-	Msg.ChessList = p.M_Player.PlayMod.getChessMod().BackData().ChessList
+	ChessMod := player.PlayMod.getChessMod()
+	Msg.ChessList = ChessMod.BackData().ChessList
+	Msg.MChessData = ChessMod.ChessMap
 	data, _ := proto.Marshal(Msg)
 	G_getGameLogic().PackResInfo(agent, "ResPlayerChessData", data)
 }
 
 func (p *PlayerChessData) ResChessColorData(player *Player) {
-	if player != p.M_Player {
-		return
-	}
-	agent := p.GetPlayer().GetAgentByPlayer()
+	agent := player.GetAgentByPlayer()
 	data, _ := proto.Marshal(&p.ColorData)
 	G_getGameLogic().PackResInfo(agent, "ResChessColorData", data)
 }
 
 // 同步棋盘数据
-func (p *PlayerChessData) UpdatePlayerChessData(buf []byte) error {
+func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) error {
 	update := &msg.UpdatePlayerChessData{}
 	proto.Unmarshal(buf, update)
-	err := p.HandleChess(update.MChessHandle)
+	LastMap := player.PlayMod.getChessMod().ChessMap
+	AddChessList, AddNewEmit, err := p.HandleChess(player, update.MChessHandle)
+
 	if err != nil {
 		res := &msg.ResUpdatePlayerChessData{
 			Code: msg.RES_CODE_FAIL,
 			Msg:  err.Error(),
 		}
-		p.M_Player.SendErrClienRes(res)
+		HandleStr := ""
+		sort.Slice(update.MChessHandle, func(i, j int) bool {
+			return update.MChessHandle[i].Id < update.MChessHandle[j].Id
+		})
+		for _, v := range update.MChessHandle {
+			HandleStr += fmt.Sprintf("%v-%v-%v,", v.Id, v.ChessId, v.Type)
+		}
+		log.Debug("棋子操作队列错误, %v===%v===%v===%v", HandleStr, LastMap, update.MChessData, player.PlayMod.getChessMod().GetChessList())
+		player.SendErrClienRes(res)
 		return err
 	}
-	p.M_Player.PushClientRes(&msg.ResUpdatePlayerChessData{
+	player.PushClientRes(&msg.ResUpdatePlayerChessData{
 		Code: msg.RES_CODE_SUCCESS,
 	})
 	p.Data.MChessData = update.MChessData
-
-	if !p.checkChessEqual() {
+	if !p.checkChessEqual(player) {
 		res := &msg.ResUpdatePlayerChessData{
 			Code: msg.RES_CODE_FAIL,
 			Msg:  "棋子数据不一致",
 		}
-		log.Debug("棋子数据不一致, %v---%v", p.Data.MChessData, p.M_Player.PlayMod.getChessMod().GetChessList())
-		p.M_Player.SendErrClienRes(res)
+		HandleStr := ""
+		sort.Slice(update.MChessHandle, func(i, j int) bool {
+			return update.MChessHandle[i].Id < update.MChessHandle[j].Id
+		})
+		for _, v := range update.MChessHandle {
+			HandleStr += fmt.Sprintf("%v-%v-%v,", v.Id, v.ChessId, v.Type)
+		}
+		log.Debug("棋子数据不一致, %v===%v===%v===%v", HandleStr, LastMap, update.MChessData, player.PlayMod.getChessMod().GetChessList())
+		player.SendErrClienRes(res)
+		player.TeLog("outsync_event", map[string]interface{}{
+			"outsync_event": "UpdatePlayerChessDataFunc",
+		})
 		return fmt.Errorf("棋子数据不一致")
 	}
-	p.SaveDataFromDB("")
+	ChessMod := player.PlayMod.getChessMod()
+	BaseMod := player.PlayMod.getBaseMod()
+	OrderMod := player.PlayMod.getOrderMod()
+	ChessMod.ChessMap = update.MChessData
+	Update := OrderMod.CreateExtraOrder(AddChessList, AddNewEmit, ChessMod.GetUnlockChessList(), BaseMod.GetEnergyMul(), BaseMod.GetLevel())
+	if Update {
+		player.InitOrderItem()
+		player.PushClientRes(OrderMod.BackData())
+	}
 	return nil
 }
 
-func (p *PlayerChessData) UpdateChessData(MChessData map[string]int32) error {
+func (p *PlayerChessData) UpdateChessData(player *Player, MChessData map[string]int32) error {
 	p.Data.MChessData = MChessData
-	if !p.checkChessEqual() {
+	if !p.checkChessEqual(player) {
 		res := &msg.ResUpdatePlayerChessData{
 			Code: msg.RES_CODE_FAIL,
 			Msg:  "棋子数据不一致",
 		}
-		log.Debug("棋子数据不一致, %v---%v", p.Data.MChessData, p.M_Player.PlayMod.getChessMod().GetChessList())
-		p.M_Player.SendErrClienRes(res)
+		log.Debug("棋子数据不一致, %v---%v", p.Data.MChessData, player.PlayMod.getChessMod().GetChessList())
+		player.SendErrClienRes(res)
+		player.TeLog("outsync_event", map[string]interface{}{
+			"outsync_event": "UpdatePlayerChessDataFunc",
+		})
 		return fmt.Errorf("棋子数据不一致")
 	}
+	player.PlayMod.getChessMod().ChessMap = MChessData
 	return nil
 }
 
 // 检查棋子数据是否一致
-func (p *PlayerChessData) checkChessEqual() bool {
-	if len(p.Data.MChessData) == 0 {
+func (p *PlayerChessData) checkChessEqual(player *Player) bool {
+	if len(p.Data.MChessData) == 0 && conf.Server.GameName == "Merge_Pet_Local" {
 		return true
 	}
-	ChessList := p.M_Player.PlayMod.getChessMod().GetChessList()
+	ChessList := player.PlayMod.getChessMod().GetChessList()
 	if len(ChessList) != len(p.Data.MChessData) {
 		return false
 	}
@@ -218,18 +151,21 @@ func (p *PlayerChessData) checkChessEqual() bool {
 }
 
 // 棋子操作
-func (p *PlayerChessData) HandleChess(handle_list []*msg.ChessHandle) error {
+func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHandle) ([]int, []int, error) {
 	sort.Slice(handle_list, func(i, j int) bool {
 		return handle_list[i].Id < handle_list[j].Id
 	})
-	ChessMod := p.M_Player.PlayMod.getChessMod()
-	HandbookMod := p.M_Player.PlayMod.getHandbookMod()
+	ChessMod := player.PlayMod.getChessMod()
+	BaseMod := player.PlayMod.getBaseMod()
+	HandbookMod := player.PlayMod.getHandbookMod()
 	var addChessCostEnergy int
 	var buyChess int
+	LimitPush := false // 限时事件推送
 	TriggerList := make([]*quest.Trigger, 0)
 	itemList := make([]*item.Item, 0)
 	AddChessList := make([]int, 0)
 	AddNewEmit := make([]int, 0)
+	EmitList := ChessMod.GetEmitList()
 	for _, v := range handle_list {
 		ChessId := int(v.ChessId)
 		EmitId := int(v.Emit)
@@ -237,24 +173,29 @@ func (p *PlayerChessData) HandleChess(handle_list []*msg.ChessHandle) error {
 		case msg.HANDLE_TYPE_ADD: //增加棋子
 			err := ChessMod.AddChess(ChessId)
 			if err != nil {
-				return err
+				return nil, nil, err
 			}
+			Type := mergeDataCfg.GetTypeById(ChessId)
 			AddChessList = append(AddChessList, ChessId)
-			if !GoUtil.InArray(EmitId, []int{561, 562, 563, 564, 701, 702, 703, 704, 705, 706}) { // 宝箱生成的棋子不扣体力
+			if !GoUtil.InArray(EmitId, []int{561, 562, 563, 564, 701, 702, 703, 704, 705, 706, 0}) && Type != "Resource" { // 宝箱生成的棋子不扣体力
 				addChessCostEnergy++
 			}
 
 			b := HandbookMod.SetHandbook(ChessId) // 添加图鉴
 			if b {
+				player.TeLog("collection_add", map[string]interface{}{
+					"item_id":   ChessId,
+					"item_name": mergeDataCfg.GetNameById(ChessId),
+				})
 				AddNewEmit = append(AddNewEmit, ChessId)
 			}
-			p.M_Player.PushClientRes(HandbookMod.BackData())
+			player.PushClientRes(HandbookMod.BackData())
 		case msg.HANDLE_TYPE_COMPOSE: //合成棋子
 			NewChessId, err := ChessMod.ComposeChess(ChessId)
 			if err != nil {
-				return err
+				return nil, nil, err
 			}
-			HandbookMod := p.M_Player.PlayMod.getHandbookMod() // 添加图鉴
+			HandbookMod := player.PlayMod.getHandbookMod() // 添加图鉴
 			b := HandbookMod.SetHandbook(NewChessId)
 			if b {
 				AddNewEmit = append(AddNewEmit, NewChessId)
@@ -263,78 +204,163 @@ func (p *PlayerChessData) HandleChess(handle_list []*msg.ChessHandle) error {
 			NewChessIdLv := mergeDataCfg.GetLvById(NewChessId)
 			TriggerList = append(TriggerList, &quest.Trigger{Label: quest.TRIGGER_LABEL_MERGELVTIME, A: []interface{}{NewChessIdLv}})
 			TriggerList = append(TriggerList, &quest.Trigger{Label: quest.TRIGGER_LABEL_MERGETIME})
-			p.M_Player.PushClientRes(HandbookMod.BackData())
+			player.PushClientRes(HandbookMod.BackData())
+			triggerComposeChess(player, NewChessId, player.PlayMod.getBaseMod().EnergyMul, player.PlayMod.getChessMod().GetEmitList())
+			// 获取活动道具
+			ActItem := GetActivityItem(player, GoUtil.Int32ToInt(v.ActType))
+			itemList = item.Merge(itemList, ActItem)
 		case msg.HANDLE_TYPE_BUY: //购买棋子
 			loseGold, err := ChessMod.BuyChess(ChessId)
 			if err != nil {
-				return err
+				return nil, nil, err
 			}
+			AddChessList = append(AddChessList, ChessId)
 			buyChess += loseGold
 			itemList = append(itemList, &item.Item{Id: item.ITEM_STAR_ID, Num: int(-loseGold)})
 		case msg.HANDLE_TYPE_SELL: //出售棋子
 			items, err := ChessMod.SellChess(ChessId)
-			if err != nil {
-				return err
+			if checkChess(ChessId, BaseMod.GetEnergyMul(), ChessMod.GetEmitList()) { // 在订单中无法生成的棋子 出售获得原价宠物币
+				items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: mergeDataCfg.GetStarById(ChessId)}}
 			}
+			LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
+			ChessType := mergeDataCfg.GetTypeById(ChessId)
+			if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_PAYBACK_DAY) && ChessType == "Product" { // 限时活动 返利日
+				err = LimitedTimeEventMod.SubPaybackDay()
+				if err == nil {
+					items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: mergeDataCfg.GetStarById(ChessId)}}
+				}
+				LimitPush = true
+			}
+			if err != nil {
+				return nil, nil, err
+			}
+			player.TeLog("sell_item", map[string]interface{}{
+				"merge_item_id": ChessId,
+				"product_name":  mergeDataCfg.GetNameById(ChessId),
+				"get_star_num":  items[0].Num,
+			})
 			itemList = item.Merge(itemList, items)
 		case msg.HANDLE_TYPE_REMOVE: //移除棋子
 			ChessMod.RemoveChess(ChessId)
 		}
 
 	}
-
 	//扣除体力
+	EnergyPow := BaseMod.GetEnergyMul()
+	ReduceEneny := 0
 	if addChessCostEnergy > 0 {
-		EnergyPow := p.M_Player.PlayMod.getBaseMod().GetEnergyMul()
-		ReduceEneny := int(math.Pow(2, float64(EnergyPow))) * addChessCostEnergy
+		ReduceEneny = int(math.Pow(2, float64(EnergyPow))) * addChessCostEnergy
 		itemList = append(itemList, &item.Item{Id: item.ITEM_ENERGY_ID, Num: -ReduceEneny})
-		G_GameLogicPtr.AddLog(&Log{
-			Type:  Event_log,
-			Uid:   p.M_Player.M_DwUin,
-			Event: "sync map info",
-		})
 	}
-	err := p.M_Player.HandleItem(itemList, "HandleChess")
+	err := player.HandleItem(itemList, msg.ITEM_POP_LABEL_HandleChess.String())
 	if err != nil {
-		return err
+		return nil, nil, err
 	}
-	OrderMod := p.M_Player.PlayMod.getOrderMod()
-	Update := OrderMod.CreateExtraOrder(AddChessList, AddNewEmit, ChessMod.GetChessList())
-	if Update {
-		p.M_Player.PushClientRes(OrderMod.BackData())
+	NewEmitList := ChessMod.GetEmitList()
+	EmitProductList := make([]string, 0)
+	for _, v := range EmitList {
+		ColorList := mergeDataCfg.GetEmitProduceType(v)
+		EmitProductList = append(EmitProductList, ColorList...)
+	}
+	NewEmitProductList := make([]string, 0)
+	for _, v := range NewEmitList {
+		ColorList := mergeDataCfg.GetEmitProduceType(v)
+		NewEmitProductList = append(NewEmitProductList, ColorList...)
+	}
+	OrderMod := player.PlayMod.getOrderMod()
+	if !GoUtil.SlicesEqualString(EmitProductList, NewEmitProductList) {
+		// 发射器系列变化，重新洗牌
+		OrderMod.ResetChessPool()
 	}
-	p.M_Player.QuestTriggerList(TriggerList)
-	p.M_Player.PushClientRes(ChessMod.BackData())
-	p.M_Player.PlayMod.save()
-	return nil
-}
-
-func (p *PlayerChessData) UpdateChessColorData(buf []byte) {
-	update := &msg.UpdateChessColorData{}
-	err := proto.Unmarshal(buf, update)
-	if err != nil {
-		fmt.Println("unmarshal failed, err:", err)
-		return
 
+	// 限时事件 小猫戏法
+	LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
+	if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_TRICK) {
+		LimitedTimeEventMod.AddCatTrickEnergy(ReduceEneny)
+		LimitPush = true
 	}
-	p.ColorData.MChessColorData = update.MChessColorData
-
-	p.SaveDataFromDB("")
-}
-func (p *PlayerChessData) GetChestKeyByValue(id int32) string {
-	for k, v := range p.Data.MChessData {
-		if id == v {
-			return k
+	if LimitPush {
+		player.PushClientRes(LimitedTimeEventMod.BackData())
 	}
-	}
-	return ""
+	player.QuestTriggerList(TriggerList)
+	EmitRetireTrigger1(player)
+	player.InitOrderItem()
+	player.PushClientRes(ChessMod.BackData())
+	player.PlayMod.save()
+	return AddChessList, AddNewEmit, nil
 }
 
 func (p *PlayerChessData) ClearData() bool {
-	p.SaveDataFromDB("")
-
 	return true
 }
 
-//********************************************************************************
-// api
+func checkChess(ChessId, EnergyMul int, Emit []int) bool {
+	if len(Emit) == 0 {
+		return false
+	}
+	ChessIdLv := mergeDataCfg.GetLvById(ChessId)
+	ChessIdType := mergeDataCfg.GetTypeById(ChessId)
+	if ChessIdType != "Product" {
+		return false
+	}
+	ChessIdColor := mergeDataCfg.GetColorById(ChessId)
+	if ChessIdColor == "Star" || ChessIdColor == "Energy" || ChessIdColor == "Diamond" {
+		return false
+	}
+	EmitId := 0
+	for _, v := range Emit {
+		ProduceColor := mergeDataCfg.GetEmitProduceType(v)
+		if GoUtil.InStringArray(ChessIdColor, ProduceColor) {
+			EmitId = v
+			break
+		}
+	}
+	_, Max := getChesslvRange(EmitId, EnergyMul, false)
+	Adjust := mergeDataCfg.GetAdjust(EmitId, ChessIdColor)
+	return ChessIdLv > Max-Adjust
+}
+func getChesslvRange(Emit int, EnergyMul int, IsCharge bool) (int, int) {
+	RandEmitLv := mergeDataCfg.GetLvById(Emit)
+	EmitId := mergeDataCfg.GetEmitId(Emit)
+	RandMaxLv := mergeDataCfg.GetMaxLvById(Emit)
+	RandEmitMinLv := mergeDataCfg.GetEmitMinLvById(EmitId)
+	Ratio := mergeDataCfg.GetEmitRatio(EmitId)
+	m := int(float64(1+RandEmitLv-RandEmitMinLv) / float64(1+RandMaxLv-RandEmitMinLv) / Ratio * 100)
+	if IsCharge {
+		m += 10
+	}
+	m = max(1, m)
+	m = min(100, m)
+	ChessMinLev := orderCfg.GetLvMin(EnergyMul)
+	ChessMaxLev := orderCfg.GetLvMax(EnergyMul, m)
+	return ChessMinLev, ChessMaxLev
+}
+
+func triggerComposeChess(player *Player, ChessId, EnergyMul int, Emit []int) {
+	OrderMod := player.PlayMod.getOrderMod()
+	if OrderMod.Step < 12 {
+		return
+	}
+	if !checkChess(ChessId, EnergyMul, Emit) {
+		return
+	}
+	ChessMod := player.PlayMod.getChessMod()
+	ChessList := ChessMod.GetUnlockChessList()
+	ChessNum := 0
+	for _, v := range ChessList {
+		if v == ChessId {
+			ChessNum++
+		}
+	}
+	OrderNum := 0
+	for _, v := range OrderMod.GetOrderList() {
+		if v.Type == order.Clean_Order_type && v.MergeId[0] == ChessId {
+			OrderNum++
+		}
+	}
+	if OrderNum >= ChessNum {
+		return
+	}
+	OrderMod.CreateCleanOrder2([]int{ChessId})
+	player.PushClientRes(OrderMod.BackData())
+}

src/server/game/PlayerEmailData.go

@@ -1,283 +0,0 @@
-package game
-
-import (
-	"fmt"
-	"github.com/robfig/cron/v3"
-	"server/MergeConst"
-	"server/db"
-	"server/msg"
-	"sort"
-	"time"
-
-	"google.golang.org/protobuf/proto"
-)
-
-type PlayerEmailData struct {
-	*PlayerData
-	Data       msg.ResBriefEmailData
-	SqlStructs []db.SqlEmailStruct
-	ZeroCronID cron.EntryID
-	WeekCronID cron.EntryID
-	Mcron      *cron.Cron
-}
-
-func (p *PlayerEmailData) LoadDataFromDB(dwUin interface{}) bool {
-
-	sqlStr := "SELECT * FROM system_mail_info WHERE dwUin = ?"
-	if err := db.SqlDb.Select(&p.SqlStructs, sqlStr, dwUin.(int32)); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
-		p.IsHaveDataDb = false
-	} else {
-		p.IsHaveDataDb = true
-	}
-
-	CurTime := int32(time.Now().Unix())
-
-	deleteList := []int{}
-	deleteDbList := []int32{}
-	for i := 0; i < len(p.SqlStructs); i++ {
-		item := p.SqlStructs[i]
-		if item.RecvTime > 0 && item.Status == 1 && CurTime-item.RecvTime >= MergeConst.G_Clear_Read_Email_Limit {
-			deleteList = append(deleteList, i)
-			deleteDbList = append(deleteDbList, item.EmailId)
-		}
-	}
-	tempList := []db.SqlEmailStruct{}
-	startIndex := 0
-	for i := 0; i < len(deleteList); i++ {
-		curIndex := deleteList[i]
-		if curIndex == startIndex {
-			startIndex = startIndex + 1
-			continue
-		}
-		tempList = append(tempList, p.SqlStructs[startIndex:curIndex]...)
-		startIndex = curIndex + 1
-	}
-	if startIndex <= len(p.SqlStructs)-1 {
-		tempList = append(tempList, p.SqlStructs[startIndex:]...)
-	}
-	p.SqlStructs = tempList
-	p.DeleteOutlineMail(deleteDbList)
-
-	sort.Slice(p.SqlStructs, func(i, j int) bool {
-		if p.SqlStructs[i].Status == p.SqlStructs[j].Status {
-			if p.SqlStructs[i].Type == p.SqlStructs[j].Type {
-				return p.SqlStructs[i].SendTime > p.SqlStructs[j].SendTime
-			} else {
-				return p.SqlStructs[i].Type > p.SqlStructs[j].Type
-			}
-
-		} else {
-			return p.SqlStructs[i].Status < p.SqlStructs[j].Status
-		}
-	})
-
-	for i := 0; i < len(p.SqlStructs); i++ {
-		item := p.SqlStructs[i]
-		if item.Status == 0 {
-			p.SqlStructs[i].Status = 1
-			db.FormatAllMemUpdateDb(&p.SqlStructs[i], "system_mail_info", "mail_id")
-		}
-	}
-
-	p.Mcron = cron.New()
-	p.Reconnect(false)
-
-	return true
-}
-func (p *PlayerEmailData) Reconnect(b bool) {
-	p.ZeroCronID, _ = p.Mcron.AddFunc("@every 5s", func() {
-		p.IntervalGetUnsendMails()
-	})
-	p.Mcron.Start()
-}
-func (p *PlayerEmailData) DeleteOutlineMail(deleteList []int32) {
-	sqlStr := "DELETE FROM system_mail_info WHERE mail_id = ?"
-	for i := 0; i < len(deleteList); i++ {
-
-		result, err := db.SqlDb.Exec(sqlStr, deleteList[i])
-		if err != nil {
-			fmt.Printf("exec failed, err:%v\n", err)
-			return
-		}
-		affectedRows, err := result.RowsAffected()
-		if err != nil {
-			fmt.Printf("get affected failed, err:%v\n", err)
-			return
-		}
-		fmt.Printf("delete data success, affected rows:%d\n", affectedRows)
-	}
-}
-
-func (p *PlayerEmailData) IntervalGetUnsendMails() {
-	sqlStr := "SELECT * FROM system_mail_info WHERE dwUin = ? AND state = ?"
-	SqlStructs := []db.SqlEmailStruct{}
-	if err := db.SqlDb.Select(&SqlStructs, sqlStr, p.M_Player.M_DwUin, 0); err != nil {
-
-	} else {
-		for i := 0; i < len(SqlStructs); i++ {
-			SqlStructs[i].Status = 1
-			db.FormatAllMemUpdateDb(&SqlStructs[i], "system_mail_info", "mail_id")
-		}
-		if len(SqlStructs) > 0 {
-			p.NotifyNewBriefEmailData(SqlStructs)
-		}
-
-	}
-}
-
-func (p *PlayerEmailData) NotifyNewBriefEmailData(SqlStructs []db.SqlEmailStruct) {
-	notify := &msg.NotifyNewBriefEmailData{}
-	notify.DwUin = p.M_Player.M_DwUin
-	notify.MEmailList = []*msg.BriefEmailStruct{}
-
-	p.SqlStructs = append(p.SqlStructs, SqlStructs...)
-
-	for i := 0; i < len(SqlStructs); i++ {
-		st := &msg.BriefEmailStruct{}
-		st.EmailId = SqlStructs[i].EmailId
-		st.Sender = SqlStructs[i].Sender
-		st.Title = SqlStructs[i].Title
-		st.CurrencyCount = SqlStructs[i].CurrencyCount
-		st.CurrencyInfo = SqlStructs[i].CurrencyInfo
-		st.ItemCount = SqlStructs[i].ItemCount
-		st.ItemInfo = SqlStructs[i].ItemInfo
-		st.SendTime = SqlStructs[i].SendTime
-		st.Status = 1
-		st.Type = SqlStructs[i].Type
-		SqlStructs[i].Status = 1
-		notify.MEmailList = append(notify.MEmailList, st)
-	}
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(notify)
-	G_getGameLogic().PackResInfo(agent, "NotifyNewBriefEmailData", data)
-}
-
-func (p *PlayerEmailData) ResBriefEmailData() {
-	res := &msg.ResBriefEmailData{}
-	res.DwUin = p.M_Player.M_DwUin
-	res.MEmailList = []*msg.BriefEmailStruct{}
-	for i := 0; i < len(p.SqlStructs); i++ {
-		st := &msg.BriefEmailStruct{}
-		st.EmailId = p.SqlStructs[i].EmailId
-		st.Sender = p.SqlStructs[i].Sender
-		st.Title = p.SqlStructs[i].Title
-		st.CurrencyCount = p.SqlStructs[i].CurrencyCount
-		st.CurrencyInfo = p.SqlStructs[i].CurrencyInfo
-		st.ItemCount = p.SqlStructs[i].ItemCount
-		st.ItemInfo = p.SqlStructs[i].ItemInfo
-		st.SendTime = p.SqlStructs[i].SendTime
-		st.Status = p.SqlStructs[i].Status
-		st.Type = p.SqlStructs[i].Type
-		res.MEmailList = append(res.MEmailList, st)
-	}
-
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResBriefEmailData", data)
-}
-
-func (p *PlayerEmailData) FindSqlStructByMailId(mailId int32) *db.SqlEmailStruct {
-	for i := 0; i < len(p.SqlStructs); i++ {
-		if p.SqlStructs[i].EmailId == mailId {
-			return &p.SqlStructs[i]
-		}
-	}
-	return nil
-}
-
-func (p *PlayerEmailData) DeleteSqlStructByMailId(mailId int32) *db.SqlEmailStruct {
-	var temp *db.SqlEmailStruct = nil
-	var list []db.SqlEmailStruct
-	for i := 0; i < len(p.SqlStructs); i++ {
-		if p.SqlStructs[i].EmailId == mailId {
-			temp = &p.SqlStructs[i]
-			if i > 0 {
-				list = append(list, p.SqlStructs[:i]...)
-			}
-			if i < len(p.SqlStructs)-1 {
-				list = append(list, p.SqlStructs[i+1:]...)
-			}
-			break
-		}
-	}
-	p.SqlStructs = list
-
-	return temp
-}
-
-func (p *PlayerEmailData) ResDetailEmailData(buf []byte) {
-	res := &msg.ResDetailEmailData{}
-	req := &msg.ReqDetailEmailData{}
-	proto.Unmarshal(buf, req)
-
-	st := p.FindSqlStructByMailId(req.EmailId)
-	if st != nil {
-		res.ResultCode = 0
-		res.Content = st.Content
-		res.EmailId = req.EmailId
-		res.RewardType = st.RewardType
-		res.RewardId = st.RewardId
-		res.RewardCount = st.RewardCount
-		res.LinkUrl = st.LinkUrl
-		if st.Type == 0 {
-			st.Status = 2
-			st.RecvTime = int32(time.Now().Unix())
-			db.FormatAllMemUpdateDb(st, "system_mail_info", "mail_id")
-		}
-
-	} else {
-		res.ResultCode = MergeConst.Protocol_Email_Find_Fail
-	}
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResDetailEmailData", data)
-}
-func (p *PlayerEmailData) ResDeleteEmail(buf []byte) {
-	res := &msg.ResDeleteEmail{}
-	req := &msg.ReqDeleteEmail{}
-	proto.Unmarshal(buf, req)
-
-	if p.DeleteSqlStructByMailId(req.EmailId) != nil {
-		res.EmailId = req.EmailId
-		res.ResultCode = 0
-		deleteList := []int32{req.EmailId}
-		p.DeleteOutlineMail(deleteList)
-
-	} else {
-		res.ResultCode = MergeConst.Protocol_Email_Find_Fail
-	}
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResDeleteEmail", data)
-}
-
-func (p *PlayerEmailData) ResGetEmailReward(buf []byte) {
-	res := &msg.ResGetEmailReward{}
-	req := &msg.ReqGetEmailReward{}
-	proto.Unmarshal(buf, req)
-
-	st := p.FindSqlStructByMailId(req.EmailId)
-	if st != nil {
-		res.ResultCode = 0
-		res.EmailId = req.EmailId
-		res.RewardType = st.RewardType
-		res.RewardId = st.RewardId
-		res.RewardCount = st.RewardCount
-		st.Status = 2
-		st.RecvTime = int32(time.Now().Unix())
-		db.FormatAllMemUpdateDb(st, "system_mail_info", "mail_id")
-		///发送奖励
-	} else {
-		res.ResultCode = MergeConst.Protocol_Email_Find_Fail
-	}
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResGetEmailReward", data)
-}
-func (p *PlayerEmailData) ClearData() bool {
-	p.SaveDataFromDB("")
-	p.Mcron.Remove(p.ZeroCronID)
-	p.Mcron.Stop()
-	return true
-}

src/server/game/PlayerEmitUnlockMod.go

@@ -1,129 +0,0 @@
-package game
-
-import (
-	"fmt"
-	"server/GoUtil"
-	"server/MergeConst"
-	"server/db"
-	"server/msg"
-	"strconv"
-	"strings"
-
-	"google.golang.org/protobuf/proto"
-)
-
-type PlayerEmitUnlockData struct {
-	*PlayerData
-	Data msg.ResPlayerEmitUnlockData
-}
-
-func (p *PlayerEmitUnlockData) LoadDataFromDB(dwUin interface{}) bool {
-	sqlStr := "SELECT * FROM t_player_emit_unlock WHERE dwUin = ?"
-	sqlStruck := db.SqlEmitUnlockStruct{RenewTime: 0}
-	p.Data.MEmitUnlockData = make(map[int32]int32)
-
-	if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin.(int32)); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
-		p.IsHaveDataDb = false
-	} else {
-		p.IsHaveDataDb = true
-	}
-	if sqlStruck.Value != "" {
-		arr := strings.Split(sqlStruck.Value, "_")
-		for i := 0; i < len(arr); i++ {
-			ss := strings.Split(arr[i], ",")
-			id, err := strconv.ParseInt(ss[0], 10, 32)
-			cnt, _ := strconv.ParseInt(ss[1], 10, 32)
-			if err != nil {
-				panic(err)
-			}
-			p.Data.MEmitUnlockData[int32(id)] = int32(cnt)
-		}
-	}
-	p.Data.DwUin = dwUin.(int32)
-	p.Data.RenewTime = sqlStruck.RenewTime
-
-	p.Reconnect(false)
-	return true
-}
-
-func (p *PlayerEmitUnlockData) Reconnect(b bool) {
-	if G_GameLogicPtr.DailyTaskTimestamp > (int64)(p.Data.RenewTime) {
-		p.Data.RenewTime = int32(G_GameLogicPtr.DailyTaskTimestamp)
-		for k := range p.Data.MEmitUnlockData {
-			p.Data.MEmitUnlockData[k] = 0
-		}
-		if b {
-			agent := p.GetPlayer().GetAgentByPlayer()
-			data, _ := proto.Marshal(&p.Data)
-			G_getGameLogic().PackResInfo(agent, "NotifyDailyRenewEmitUnlock", data)
-		}
-	}
-	GoUtil.RegisterEvent(MergeConst.Notify_Daily_Renew, p.NotifyDailyRenewEmitUnlock, p)
-}
-
-func (p *PlayerEmitUnlockData) GetUnlockCntByID(id int32) int32 {
-	cnt, ok := p.Data.MEmitUnlockData[id]
-	if ok {
-		return cnt
-	}
-	return 0
-}
-
-func (p *PlayerEmitUnlockData) ClearData() bool {
-	p.SaveDataFromDB("")
-	GoUtil.RemoveEvent(MergeConst.Notify_Daily_Renew, p.NotifyDailyRenewEmitUnlock, p)
-	return true
-}
-
-func (p *PlayerEmitUnlockData) SaveDataFromDB(Key interface{}) bool {
-	var strarr []string
-	for k, v := range p.Data.MEmitUnlockData {
-		str := fmt.Sprintf("%d,%d", k, v)
-		strarr = append(strarr, str)
-	}
-	str_concat := strings.Join(strarr, "_")
-	// sqlStr := "UPDATE user SET age = ?, degree = ? WHERE id = ?"
-	// result, err := SqlDb.Exec(sqlStr, 22, 10, 4)
-	sqlStruck := db.SqlEmitUnlockStruct{}
-	sqlStruck.DwUin = p.M_Player.M_DwUin
-	sqlStruck.Value = str_concat
-	if p.IsHaveDataDb {
-		db.FormatAllMemUpdateDb(&sqlStruck, "t_player_emit_unlock", "dwUin")
-	} else {
-		db.FormatAllMemInsertDb(&sqlStruck, "t_player_emit_unlock")
-	}
-	p.IsHaveDataDb = true
-	return true
-}
-
-func (p *PlayerEmitUnlockData) ResPlayerEmitUnlockData(player *Player) {
-	if player != p.M_Player {
-		return
-	}
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(&p.Data)
-	G_getGameLogic().PackResInfo(agent, "ResPlayerEmitUnlockData", data)
-}
-
-func (p *PlayerEmitUnlockData) NotifyDailyRenewEmitUnlock(param []interface{}) {
-	p.Data.RenewTime = int32(param[0].(int64))
-	for k := range p.Data.MEmitUnlockData {
-		p.Data.MEmitUnlockData[k] = 0
-	}
-
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(&p.Data)
-	G_getGameLogic().PackResInfo(agent, "NotifyDailyRenewEmitUnlock", data)
-	// p.SaveDataFromDB("")
-}
-
-func (p *PlayerEmitUnlockData) UpdatePlayerEmitUnlockData(buf []byte) {
-
-	update := &msg.UpdatePlayerEmitUnlockData{}
-	proto.Unmarshal(buf, update)
-
-	p.Data.MEmitUnlockData = update.MEmitUnlockData
-
-	p.SaveDataFromDB("")
-}

src/server/game/PlayerGiftMod.go

@@ -1,97 +0,0 @@
-package game
-
-import (
-	"fmt"
-	"server/db"
-	"server/msg"
-	"strconv"
-	"strings"
-
-	"google.golang.org/protobuf/proto"
-)
-
-type PlayerGiftData struct {
-	*PlayerData
-	Data msg.ResPlayerGiftData
-}
-
-func (p *PlayerGiftData) LoadDataFromDB(dwUin interface{}) bool {
-
-	sqlStr := "SELECT * FROM t_player_gift_data WHERE dwUin = ?"
-	sqlStruck := db.SqlGiftStruct{}
-	p.Data.MGiftData = make(map[int32]int32)
-	if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin.(int32)); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
-		p.IsHaveDataDb = false
-	} else {
-		p.IsHaveDataDb = true
-	}
-	if sqlStruck.MGiftData != "" {
-		arr := strings.Split(sqlStruck.MGiftData, "_")
-
-		for i := 0; i < len(arr); i++ {
-			ss := strings.Split(arr[i], ",")
-			id, err := strconv.ParseInt(ss[1], 10, 32)
-			key, _ := strconv.ParseInt(ss[0], 10, 32)
-
-			if err != nil {
-				panic(err)
-			}
-
-			p.Data.MGiftData[int32(key)] = int32(id)
-		}
-	}
-
-	p.Data.DwUin = dwUin.(int32)
-	p.Reconnect(false)
-	return true
-}
-
-func (p *PlayerGiftData) Reconnect(b bool) {
-
-}
-
-func (p *PlayerGiftData) SaveDataFromDB(Key interface{}) bool {
-	var strarr []string
-	for k, v := range p.Data.MGiftData {
-		str := fmt.Sprintf("%d,%d", k, v)
-		strarr = append(strarr, str)
-	}
-	str_concat := strings.Join(strarr, "_")
-
-	sqlStruck := db.SqlGiftStruct{}
-	sqlStruck.DwUin = p.M_Player.M_DwUin
-	sqlStruck.MGiftData = str_concat
-	if p.IsHaveDataDb {
-		db.FormatAllMemUpdateDb(&sqlStruck, "t_player_gift_data", "dwUin")
-	} else {
-		db.FormatAllMemInsertDb(&sqlStruck, "t_player_gift_data")
-	}
-	p.IsHaveDataDb = true
-	return true
-}
-
-func (p *PlayerGiftData) ResPlayerGiftData(player *Player) {
-	if player != p.M_Player {
-		return
-	}
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(&p.Data)
-	G_getGameLogic().PackResInfo(agent, "ResPlayerGiftData", data)
-}
-
-func (p *PlayerGiftData) UpdatePlayerGiftData(buf []byte) {
-
-	update := &msg.UpdatePlayerGiftData{}
-	proto.Unmarshal(buf, update)
-
-	p.Data.MGiftData = update.MGiftData
-
-	p.SaveDataFromDB("")
-}
-
-func (p *PlayerGiftData) ClearData() bool {
-	p.SaveDataFromDB("")
-
-	return true
-}

src/server/game/PlayerLog.go

@@ -0,0 +1,94 @@
+package game
+
+import (
+	itemCfg "server/conf/item"
+	playroomCfg "server/conf/playroom"
+	"server/game/mod/item"
+)
+
+func (p *Player) PlayerDecoLog(Type string, Id int, Label string) {
+	p.TeLog("playerdeco_income", map[string]interface{}{
+		"playerdeco_type": Type,
+		"playerdeco_id":   Id,
+		"income_from":     Label,
+	})
+}
+
+func (p *Player) PlayerDecoSetLog(Type string, Id int, Set string) {
+	p.TeLog("playerdeco_set", map[string]interface{}{
+		"playerdeco_type": Type,
+		"playerdeco_id":   Id,
+		"set_function":    Set,
+	})
+}
+
+func (p *Player) PetItemGetLog(Item []*item.Item, Cost []*item.Item, Label string) {
+	CostType := ""
+	CostNum := 0
+	if len(Cost) > 0 {
+		switch Cost[0].Id {
+		case item.ITEM_DIAMOND_ID:
+			CostType = "diamond"
+		case item.ITEM_STAR_ID:
+			CostType = "star"
+		case 0:
+			CostType = "ad"
+		default:
+			CostType = "unknown"
+		}
+		CostNum = -Cost[0].Num
+	}
+	for _, v := range Item {
+		Type := itemCfg.GetItemType(v.Id)
+		if Type == item.ITEM_TYPE_PLAYROOM_PET {
+			Name, _ := itemCfg.GetItemName(v.Id)
+			Effect := itemCfg.GetItemEffect(v.Id)
+			p.PetItemGetLog_(Effect, Name, Label, CostType, CostNum)
+		}
+	}
+}
+
+func (p *Player) PetItemGetLog_(Type int, Name string, Label string, CostType string, CostNum int) {
+	p.TeLog("pet_item_get", map[string]interface{}{
+		"pet_item_type":      Type,
+		"pet_item_name":      Name,
+		"pet_item_get_type":  Label,
+		"pet_item_cost_type": CostType,
+		"pet_item_cost":      CostNum,
+	})
+}
+
+func (p *Player) PetItemUseLog(Item []*item.Item) {
+	for _, v := range Item {
+		Type := itemCfg.GetItemType(v.Id)
+		if Type == item.ITEM_TYPE_PLAYROOM_PET && v.Num < 0 {
+			Name, _ := itemCfg.GetItemName(v.Id)
+			Effect := itemCfg.GetItemEffect(v.Id)
+			p.TeLog("pet_item_use", map[string]interface{}{
+				"pet_item_type": Effect,
+				"pet_item_name": Name,
+			})
+		}
+	}
+}
+
+func (p *Player) RoomDecoSetLog(Diff map[int]int) {
+	for _, v := range Diff {
+		Type, Name := playroomCfg.GetDecoInfo(v)
+		p.TeLog("room_deco_set", map[string]interface{}{
+			"room_deco_type": Type,
+			"room_deco_name": Name,
+		})
+	}
+}
+
+func (p *Player) PetDecoSetLog(Diff map[int]int) {
+	for _, v := range Diff {
+		Type := playroomCfg.GetDressPart(v)
+		Name := playroomCfg.GetDressName(v)
+		p.TeLog("pet_deco_set", map[string]interface{}{
+			"pet_deco_type": Type,
+			"pet_deco_name": Name,
+		})
+	}
+}

src/server/game/PlayerMod.go

@@ -3,27 +3,40 @@ package game
 import (
 	"bytes"
 	"encoding/gob"
-	"encoding/json"
 	"fmt"
+	userCfg "server/conf/user"
 	"server/db"
 	"server/game/mod/activity"
 	"server/game/mod/avatar"
 	"server/game/mod/base"
 	"server/game/mod/card"
+	"server/game/mod/catnip"
 	"server/game/mod/champship"
 	"server/game/mod/charge"
 	"server/game/mod/chess"
+	"server/game/mod/collect"
+	"server/game/mod/compensation"
 	"server/game/mod/dailyTask"
 	"server/game/mod/decorate"
+	"server/game/mod/emoji"
 	"server/game/mod/endless"
 	"server/game/mod/face"
 	"server/game/mod/friend"
-	"server/game/mod/guild"
+	"server/game/mod/friendTreasure.go"
+	guesscolor "server/game/mod/guessColor"
+	"server/game/mod/guide"
+	"server/game/mod/guideTask"
 	"server/game/mod/handbook"
+	"server/game/mod/invite"
+	"server/game/mod/item"
+	"server/game/mod/kv"
 	"server/game/mod/limitedTimeEvent"
 	"server/game/mod/mail"
+	"server/game/mod/mining"
 	"server/game/mod/order"
 	"server/game/mod/piggyBank"
+	"server/game/mod/playroom"
+	"server/game/mod/race"
 	"server/game/mod/sevenLogin"
 	Var "server/game/mod/var"
 	"server/pkg/github.com/name5566/leaf/log"
@@ -38,38 +51,51 @@ type PlayerModData struct {
 
 // PlayerModList 玩家模块列表
 type PlayerModList struct {
-	Base             base.Base                            `json:"base"`
-	Chess            chess.ChessBorad                     `json:"chess"`
-	Handbook         handbook.Handbook                    `json:"handbook"`
-	Order            order.OrderMod                       `json:"order"`
-	Decorate         decorate.Decorate                    `json:"decorate"`
-	Card             card.CardMod                         `json:"card"`
-	Var              Var.Var                              `json:"var"`
-	Guild            guild.Guild                          `json:"guild"`
-	DailyTask        dailyTask.DailyTaskMod               `json:"dailyTask"`
-	Face             face.FaceMod                         `json:"face"`
-	Avatar           avatar.AvatarMod                     `json:"avatar"`
-	SevenLogin       sevenLogin.SevenLoginMod             `json:"sevenLogin"`
-	Activity         activity.ActivityMod                 `json:"activity"`
-	LimitedTimeEvent limitedTimeEvent.LimitedTimeEventMod `json:"limitedTimeEvent"`
-	Friend           friend.FriendMod                     `json:"friend"`
-	Mail             mail.MailMod                         `json:"mail"`
-	Charge           charge.ChargeMod                     `json:"charge"`
-	Endless          endless.EndlessMod                   `json:"endless"`
-	PiggyBank        piggyBank.PiggyBankMod               `json:"piggyBank"`
-	Champship        champship.ChampshipMod               `json:"champship"`
+	Base             base.Base                            // 基础信息
+	Chess            chess.ChessBorad                     // 棋盘
+	Handbook         handbook.Handbook                    // 图鉴
+	Order            order.OrderMod                       //订单
+	Decorate         decorate.Decorate                    //装饰
+	Card             card.CardMod                         //卡牌
+	Var              Var.Var                              // 变量
+	Guide            guide.Guide                          // 引导
+	DailyTask        dailyTask.DailyTaskMod               // 每日任务
+	Face             face.FaceMod                         // 头像
+	Avatar           avatar.AvatarMod                     // 头像框
+	SevenLogin       sevenLogin.SevenLoginMod             // 七天签到
+	LimitedTimeEvent limitedTimeEvent.LimitedTimeEventMod // 限时事件
+	Friend           friend.FriendMod                     // 好友
+	Mail             mail.MailMod                         // 邮件
+	Charge           charge.ChargeMod                     // 商店充值
+	Endless          endless.EndlessMod                   // 无尽礼包
+	PiggyBank        piggyBank.PiggyBankMod               // 小猪存钱
+	Champship        champship.ChampshipMod               // 锦标赛
+	Invite           invite.InviteMod                     // 邀请
+	Kv               kv.KvMod                             //  客户端数据
+	Mining           mining.MiningMod                     // 挖矿活动
+	Item             item.ItemMod                         // 道具
+	GuessColor       guesscolor.GuessColorMod             // 猜颜色活动
+	Race             race.RaceMod                         // 竞赛活动
+	Playroom         playroom.PlayroomMod                 // 玩家小屋
+	FriendTreasure   friendTreasure.FriendTreasureMod     // 好友宝藏
+	Emoji            emoji.EmojiMod                       // 表情
+	Collect          collect.Collect                      // 收集
+	Activity         activity.Activity                    // 活动
+	Compensation     compensation.Compensation            // 补偿
+	Catnip           catnip.CatnipMod                     // 猫草大作战
+	GuideTask        guideTask.GuideTaskMod               // 引导任务
 }
 
 func (p *PlayerModData) LoadDataFromDB(dwUin interface{}) bool {
 	sqlStr := "SELECT * FROM t_player_mod WHERE dwUin = ?"
 	p.Data = db.SqlModStruct{}
-	if err := db.SqlDb.Get(&p.Data, sqlStr, dwUin.(int32)); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
+	if err := db.SqlDb.Get(&p.Data, sqlStr, dwUin.(int64)); err != nil {
+
 		p.IsHaveDataDb = false
 	} else {
 		p.IsHaveDataDb = true
 	}
-	p.Data.DwUin = dwUin.(int32)
+	p.Data.DwUin = dwUin.(int64)
 	return true
 }
 
@@ -90,28 +116,22 @@ func (p *PlayerModData) ReqModData(buf []byte) {
 
 // 推送基础数据
 func (p *PlayerModData) Reconnect(b bool) []byte {
-
 	return []byte{}
 }
 
-func (p *PlayerModData) InitMod() bool {
+func (p *PlayerModData) InitMod(player *Player) (bool, error) {
 	playerModList := PlayerModList{}
+	if len(p.Data.ModData) > 0 {
 		buf := bytes.NewBuffer(p.Data.ModData)
 		decoder := gob.NewDecoder(buf)
 		err := decoder.Decode(&playerModList)
-	// err := json.Unmarshal([]byte(p.Data.ModData), &playerModList)
 		if err != nil {
-		fmt.Printf("playmod get data failed, err:%v\n", err)
+			log.Debug("playmod get data failed, err:%v\n", err)
+			return false, fmt.Errorf("playmod get data failed, err:%v", err)
+		}
 	}
 	p.ModList = playerModList
 	is_update := false
-	// 初始化基础模块
-	if p.ModList.Base == (base.Base{}) {
-		var baseMod base.Base
-		baseMod.InitData()
-		p.ModList.Base = baseMod
-		is_update = true
-	}
 
 	// 初始化棋盘模块
 
@@ -121,25 +141,50 @@ func (p *PlayerModData) InitMod() bool {
 		p.ModList.Chess = chessMod
 		is_update = true
 	}
+	BaseMod := &p.ModList.Base
+	if BaseMod.Uid == 0 {
+		PlayerBaseMod := player.GetPlayerBaseMod()
+		BaseMod.Uid = PlayerBaseMod.Data.DwUin
+		BaseMod.SetAccount(PlayerBaseMod.Data.UserName)
+		BaseMod.SetLevel(1)
+		BaseMod.SetExp(0)
+		BaseMod.SetEnergy(userCfg.GetInitEnergy())
+		BaseMod.SetStar(userCfg.GetInitStar())
+		BaseMod.SetDiamond(userCfg.GetInitDiamond())
+		BaseMod.SetRecoverTime(int64(PlayerBaseMod.Data.RecoverTime))
+		BaseMod.FackBookId = PlayerBaseMod.Data.FaceBookId
+		is_update = true
+	}
+	Ip := p.GetPlayer().GetIp()
 	p.ModList.Handbook.InitData()
 	p.ModList.Order.InitData()
 	p.ModList.Decorate.InitData()
 	p.ModList.Card.InitData()
 	p.ModList.Var.InitData()
-	p.ModList.Guild.InitData()
+	p.ModList.Guide.InitData()
 	p.ModList.DailyTask.InitData()
 	p.ModList.Face.InitData()
 	p.ModList.Avatar.InitData()
-	p.ModList.Base.InitData()
+	p.ModList.Base.InitData(int(p.Data.DwUin), Ip)
 	p.ModList.SevenLogin.InitData()
-	p.ModList.Activity.InitData()
-	p.ModList.LimitedTimeEvent.InitData()
+	p.ModList.LimitedTimeEvent.InitData(BaseMod.GetLevel())
 	p.ModList.Friend.InitData()
 	p.ModList.Mail.InitData()
 	p.ModList.Charge.InitData()
 	p.ModList.Endless.InitData()
-
-	return is_update
+	p.ModList.Invite.InitData()
+	p.ModList.Kv.InitData()
+	p.ModList.Mining.InitData()
+	p.ModList.Item.InitData()
+	p.ModList.GuessColor.InitData()
+	p.ModList.Playroom.InitData()
+	p.ModList.Emoji.InitData()
+	p.ModList.Collect.InitData()
+	p.ModList.Activity.InitData()
+	p.ModList.Catnip.InitData()
+	p.ModList.Compensation.InitData()
+	p.ModList.GuideTask.InitData()
+	return is_update, nil
 }
 
 type PlayerMod struct {
@@ -151,37 +196,64 @@ func (p *PlayerMod) save() {
 	p.is_update = true
 }
 
-func (p *PlayerMod) ClearData(player *Player) {
+func (p *PlayerMod) IsBlackList() bool {
+	BaseMod := p.getBaseMod()
+	return BaseMod.Account == "cecf89cd063b93c63da531daf7204afa"
+}
 
-	if p.is_update {
+func (p *PlayerMod) ClearData(player *Player) {
+	ChessMod := p.getChessMod()
+	if len(ChessMod.ChessMap) > 0 && len(ChessMod.ChessList) != len(ChessMod.ChessMap) {
+		log.Debug("uid: %d, SaveData, chess error ", player.M_DwUin)
+		return
+	}
+	if p.is_update && !p.IsBlackList() {
 		//序列化模块
 		var buf bytes.Buffer
 		encode := gob.NewEncoder(&buf)
 		err := encode.Encode(p.mod_list)
 		if err != nil {
-			fmt.Println(err)
+			log.Debug("uid: %d, SaveData, playmod error %v", player.M_DwUin, err)
 			return
 		}
-		log.Debug("uid: %d, ClearData, playmod", player.M_DwUin)
+		// log.Debug("uid: %d, ClearData, playmod", player.M_DwUin)
 		modData := &db.SqlModStruct{
 			DwUin:      player.M_DwUin,
 			ModData:    buf.Bytes(),
 			UpdataTime: int32(time.Now().Unix()),
 		}
 
-		db.SavePlayerModData(modData)
+		err = db.SavePlayerModData(modData)
+		if err != nil {
+			log.Debug("uid: %d, SaveData, playmod error %v", player.M_DwUin, err)
+			return
+		}
 		p.is_update = false
 	}
 }
 
 func (p *PlayerMod) BackUp(B *PlayerBackUp) {
-	modString, _ := json.Marshal(p.mod_list)
-	B.PlayMod = modString
+	var buf bytes.Buffer
+	encode := gob.NewEncoder(&buf)
+	err := encode.Encode(p.mod_list)
+	if err != nil {
+		log.Debug("Backup, playmod error %v", err)
+		return
+	}
+	B.PlayMod = buf.Bytes()
 }
 
 func (p *PlayerMod) Recover(B *PlayerBackUp) {
 	if len(B.PlayMod) > 0 {
-		json.Unmarshal(B.PlayMod, &p.mod_list)
+		PlayMod := PlayerModList{}
+		buf := bytes.NewBuffer(B.PlayMod)
+		decoder := gob.NewDecoder(buf)
+		err := decoder.Decode(&PlayMod)
+		if err != nil {
+			log.Debug("Recover, playmod error %v", err)
+			return
+		}
+		p.mod_list = PlayMod
 	}
 }
 
@@ -213,8 +285,8 @@ func (p *PlayerMod) getVarMod() *Var.Var {
 	return &p.mod_list.Var
 }
 
-func (p *PlayerMod) getGuildMod() *guild.Guild {
-	return &p.mod_list.Guild
+func (p *PlayerMod) getGuideMod() *guide.Guide {
+	return &p.mod_list.Guide
 }
 
 func (p *PlayerMod) getDailyTaskMod() *dailyTask.DailyTaskMod {
@@ -233,10 +305,6 @@ func (p *PlayerMod) getSevenLoginMod() *sevenLogin.SevenLoginMod {
 	return &p.mod_list.SevenLogin
 }
 
-func (p *PlayerMod) getActivityMod() *activity.ActivityMod {
-	return &p.mod_list.Activity
-}
-
 func (p *PlayerMod) getLimitedTimeEventMod() *limitedTimeEvent.LimitedTimeEventMod {
 	return &p.mod_list.LimitedTimeEvent
 }
@@ -264,3 +332,56 @@ func (p *PlayerMod) getPiggyBankMod() *piggyBank.PiggyBankMod {
 func (p *PlayerMod) getChampshipMod() *champship.ChampshipMod {
 	return &p.mod_list.Champship
 }
+
+func (p *PlayerMod) getInviteMod() *invite.InviteMod {
+	return &p.mod_list.Invite
+}
+
+func (p *PlayerMod) getKvMod() *kv.KvMod {
+	return &p.mod_list.Kv
+}
+
+func (p *PlayerMod) getMiningMod() *mining.MiningMod {
+	return &p.mod_list.Mining
+}
+
+func (p *PlayerMod) getItemMod() *item.ItemMod {
+	return &p.mod_list.Item
+}
+
+func (p *PlayerMod) getGuessColorMod() *guesscolor.GuessColorMod {
+	return &p.mod_list.GuessColor
+}
+
+func (p *PlayerMod) getRaceMod() *race.RaceMod {
+	return &p.mod_list.Race
+}
+
+func (p *PlayerMod) getPlayroomMod() *playroom.PlayroomMod {
+	return &p.mod_list.Playroom
+}
+
+func (p *PlayerMod) getFriendTreasureMod() *friendTreasure.FriendTreasureMod {
+	return &p.mod_list.FriendTreasure
+}
+
+func (p *PlayerMod) getEmojiMod() *emoji.EmojiMod {
+	return &p.mod_list.Emoji
+}
+
+func (p *PlayerMod) getCollectMod() *collect.Collect {
+	return &p.mod_list.Collect
+}
+
+func (p *PlayerMod) getActivityMod() *activity.Activity {
+	return &p.mod_list.Activity
+}
+func (p *PlayerMod) getCompensationMod() *compensation.Compensation {
+	return &p.mod_list.Compensation
+}
+func (p *PlayerMod) getCatnipMod() *catnip.CatnipMod {
+	return &p.mod_list.Catnip
+}
+func (p *PlayerMod) getGuideTaskMod() *guideTask.GuideTaskMod {
+	return &p.mod_list.GuideTask
+}

src/server/game/PlayerMsg.go

@@ -0,0 +1,23 @@
+package game
+
+import (
+	"server/GoUtil"
+	"server/game/mod/activity"
+	"server/game/mod/msg"
+)
+
+func (p *Player) CatnipGrowthMsg(To, Id, Growth int) error {
+	ActivityId := GetActivityId(p, activity.ACT_TYPE_CATNIP)
+	FriendMgrSend(&msg.Msg{
+		From:  int(p.M_DwUin),
+		To:    To,
+		Type:  msg.HANDLE_TYPE_CATNIP_GROWTH,
+		SendT: GoUtil.Now(),
+		Extra: CatnipMsg{
+			ActivityId: ActivityId,
+			GameId:     Id,
+			Growth:     Growth,
+		},
+	})
+	return nil
+}

src/server/game/PlayerPigData.go

@@ -1,169 +0,0 @@
-package game
-
-import (
-	"fmt"
-	"server/MergeConst"
-	"server/db"
-	"server/msg"
-	"time"
-
-	"google.golang.org/protobuf/proto"
-)
-
-type PlayerPigData struct {
-	*PlayerData
-	Data msg.ResPigDetailInfo
-}
-
-func (p *PlayerPigData) LoadDataFromDB(dwUin interface{}) bool {
-
-	sqlStr := "SELECT * FROM t_player_piginfo WHERE dwUin = ?"
-	sqlStruck := db.SqlPigDetailInfoStruct{}
-	sqlStruck.PigId = 0
-	if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin.(int32)); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
-		p.IsHaveDataDb = false
-	} else {
-		p.IsHaveDataDb = true
-	}
-	p.Data.CurDiamonds = sqlStruck.CurDiamonds
-	p.Data.DwUin = p.M_Player.M_DwUin
-	p.Data.PigId = sqlStruck.PigId
-	p.Data.PigType = sqlStruck.PigType
-	p.Data.StartSvrTime = sqlStruck.StartSvrTime
-	p.Data.EndSvrTime = sqlStruck.EndSvrTime
-	p.Data.CurGetLv = sqlStruck.CurGetLv
-	p.Reconnect(false)
-
-	return true
-}
-func (p *PlayerPigData) Reconnect(b bool) {
-
-}
-
-func (p *PlayerPigData) DeleteLastPigData(pigid int32) {
-	sqlStr := "DELETE FROM " + "t_player_piginfo" + " WHERE PigId = ?"
-
-	db.SqlDb.Exec(sqlStr, pigid)
-	p.Data.PigId = 0
-}
-
-func (p *PlayerPigData) ClearData() bool {
-	p.SaveDataFromDB("")
-
-	return true
-}
-func (p *PlayerPigData) SaveDataFromDB(Key interface{}) bool {
-
-	sqlStruck := db.SqlPigDetailInfoStruct{}
-	sqlStruck.DwUin = p.M_Player.M_DwUin
-	sqlStruck.CurDiamonds = p.Data.CurDiamonds
-	sqlStruck.CurGetLv = p.Data.CurGetLv
-	sqlStruck.CurSvrTime = 0
-	sqlStruck.EndSvrTime = p.Data.EndSvrTime
-	sqlStruck.StartSvrTime = p.Data.StartSvrTime
-	sqlStruck.PigId = p.Data.PigId
-	sqlStruck.PigType = p.Data.PigType
-
-	if p.IsHaveDataDb {
-		if p.Data.PigId != 0 {
-			db.FormatAllMemUpdateDb(&sqlStruck, "t_player_piginfo", "PigId")
-		}
-	} else {
-		if p.Data.PigId != 0 {
-			db.FormatAllMemInsertDb(&sqlStruck, "t_player_piginfo")
-		}
-	}
-	p.IsHaveDataDb = true
-	return true
-}
-
-func (p *PlayerPigData) ResOpenNewPig(player *Player) {
-	res := &msg.ResOpenNewPig{}
-	st := &db.SqlPigDetailInfoStruct{}
-	st.DwUin = player.M_DwUin
-	st.StartSvrTime = (int32)(time.Now().Unix())
-	st.EndSvrTime = st.StartSvrTime + MergeConst.G_Pig_Limite
-	st.PigType = 1
-	st.CurDiamonds = 0
-	st.CurSvrTime = 0
-	st.CurGetLv = 1
-
-	PigId, _ := db.FormatAllMemInsertDb(st, "t_player_piginfo")
-	res.PigId = (int32)(PigId)
-
-	p.Data.CurDiamonds = st.CurDiamonds
-	p.Data.DwUin = p.M_Player.M_DwUin
-	p.Data.PigId = int32(PigId)
-	p.Data.PigType = st.PigType
-	p.Data.StartSvrTime = st.StartSvrTime
-	p.Data.EndSvrTime = st.EndSvrTime
-
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResOpenNewPig", data)
-}
-
-func (p *PlayerPigData) ResPigDetailInfo(player *Player) {
-	// res := &msg.ReqPigDetailInfo{}
-	p.Data.CurSvrTime = int32(time.Now().Unix())
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(&p.Data)
-	G_getGameLogic().PackResInfo(agent, "ResPigDetailInfo", data)
-}
-
-func (p *PlayerPigData) UpdateFinishOrderDiamond(buf []byte) {
-
-	update := &msg.UpdateFinishOrderDiamond{}
-	proto.Unmarshal(buf, update)
-
-	p.Data.CurDiamonds = update.CurDiamonds
-	p.SaveDataFromDB("")
-}
-
-func (p *PlayerPigData) ResGetPigReward(buf []byte) {
-
-	req := &msg.ReqGetPigReward{}
-	proto.Unmarshal(buf, req)
-
-	res := &msg.ResGetPigReward{}
-	res.PigId = req.PigId
-
-	if req.PigId != p.Data.PigId {
-		res.ResultCode = MergeConst.Protocol_PigID_No_Exsit
-	} else {
-		res.ResultCode = 0
-		p.Data.CurGetLv = p.Data.CurGetLv + 1
-		res.CurGetLv = p.Data.CurGetLv
-	}
-	res.CurDiamonds = p.Data.CurDiamonds
-
-	if MergeConst.G_PigIsOne {
-		p.DeleteLastPigData(req.PigId)
-	}
-
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResGetPigReward", data)
-}
-
-func (p *PlayerPigData) ResDropPigReward(buf []byte) {
-
-	req := &msg.ReqDropPigReward{}
-	proto.Unmarshal(buf, req)
-
-	res := &msg.ResDropPigReward{}
-	res.PigId = req.PigId
-
-	if req.PigId != p.Data.PigId {
-		res.ResultCode = MergeConst.Protocol_PigID_No_Exsit
-	} else {
-		res.ResultCode = 0
-	}
-
-	p.DeleteLastPigData(req.PigId)
-
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResDropPigReward", data)
-}

src/server/game/PlayerProfileDataManager.go

@@ -1,418 +0,0 @@
-package game
-
-import (
-	"math"
-	"math/rand"
-	"server/db"
-	"server/game/internal"
-	"server/msg"
-	"strconv"
-
-	"server/pkg/github.com/name5566/leaf/gate"
-
-	"google.golang.org/protobuf/proto"
-)
-
-type PlayerProfileManager struct {
-	MsqlStrucks []db.SqlPlayerProfileStruct
-	MapSql      map[int32]*db.SqlPlayerProfileStruct
-}
-
-func (p *PlayerProfileManager) LoadDataFromDB(dwUin interface{}) bool {
-
-	sqlStr := "SELECT * FROM t_player_Profile_Data"
-	p.MsqlStrucks = []db.SqlPlayerProfileStruct{}
-	p.MapSql = make(map[int32]*db.SqlPlayerProfileStruct)
-	db.SqlDb.Select(&p.MsqlStrucks, sqlStr)
-
-	for i := 0; i < len(p.MsqlStrucks); i++ {
-		item := p.MsqlStrucks[i]
-		p.MapSql[item.DwUin] = &item
-	}
-
-	return true
-}
-
-func (p *PlayerProfileManager) GetPlayerDecorate(dwUin int32) (int, int, string) {
-	sqlStr := "SELECT * FROM t_player_baseinfo WHERE dwUin = ?"
-	sqlStruck := db.ResPlayerBaseInfo{}
-	decorate := 0
-	ActiveTime := 0
-	FaceBookId := ""
-	if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin); err != nil {
-
-	} else {
-		Score := 0
-		for i := 1; i < int(sqlStruck.Level); i++ {
-			Score = Score + (i-1)*10 + 20
-		}
-		Score = Score + int(sqlStruck.Exp)
-		decorate = Score / 10
-		ActiveTime = int(math.Max(float64(sqlStruck.LoginTime), float64(sqlStruck.LogoutTime)))
-		FaceBookId = sqlStruck.FaceBookId
-	}
-	return decorate, ActiveTime, FaceBookId
-}
-
-func (p *PlayerProfileManager) InitManager() {
-	p.LoadDataFromDB("")
-}
-
-func (p *PlayerProfileManager) AddNewProfile(st *db.SqlPlayerProfileStruct) bool {
-	if p.GetPlayerProfile(st.DwUin) == nil {
-		p.MapSql[st.DwUin] = st
-		db.FormatAllMemInsertDb(st, "t_player_Profile_Data")
-	}
-	return true
-}
-
-func (p *PlayerProfileManager) UpdateNewProfile(st *db.SqlPlayerProfileStruct) bool {
-	if p.GetPlayerProfile(st.DwUin) != nil {
-		p.MapSql[st.DwUin] = st
-		db.FormatAllMemUpdateDb(st, "t_player_Profile_Data", "dwUin")
-	} else {
-		p.AddNewProfile(st)
-	}
-	return true
-}
-
-func (p *PlayerProfileManager) GetPlayerProfileByNick(nick string) []*db.SqlPlayerProfileStruct {
-	ret := []*db.SqlPlayerProfileStruct{}
-	// G_getGameLogic().Mlogger.Debug("p.MapSql" + strconv.Itoa(len(p.MapSql)))
-	// G_getGameLogic().Mlogger.Debug("nick:" + nick)
-	for k, v := range p.MapSql {
-		if strconv.Itoa(int(k)) == nick {
-			ret = append(ret, v)
-		} else {
-			// G_getGameLogic().Mlogger.Debug("v.NickName:" + v.NickName)
-			if nick == v.NickName {
-				ret = append(ret, v)
-			}
-		}
-	}
-	return ret
-}
-
-func (p *PlayerProfileManager) GetPlayerProfile(id int32) *db.SqlPlayerProfileStruct {
-
-	st, ok := p.MapSql[id]
-	if ok {
-		return st
-	}
-	return nil
-}
-func (p *PlayerProfileManager) GetIsHavePlayerById(id int32) bool {
-	sqlStr := "SELECT * FROM t_player_baseinfo WHERE dwUin = ?"
-	sqlStruck := db.ResPlayerBaseInfo{}
-	if err := db.SqlDb.Get(&sqlStruck, sqlStr, id); err != nil {
-
-	} else {
-		return true
-	}
-	return false
-}
-
-func (p *PlayerProfileManager) ReqPlayerProfileData(args []interface{}) {
-	a := args[0].(gate.Agent)
-	play, _ := internal.Agents.Load(a)
-	buf := args[1].([]byte)
-	player := play.(*Player)
-
-	req := &msg.ReqPlayerProfileData{}
-	res := &msg.ResPlayerProfileData{}
-	proto.Unmarshal(buf, req)
-	profile := p.GetPlayerProfile(player.M_DwUin)
-	if profile != nil {
-		res.DwUin = player.M_DwUin
-		res.NickName = profile.NickName
-		res.ImageFrame = profile.ImageFrame
-		res.ImageIcon = profile.ImageIcon
-		res.PicURL = profile.PicURL
-		res.UnlockFrame = profile.UnlockFrame
-		res.UnlockIcon = profile.UnlockIcon
-		DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(player.M_DwUin)
-		res.DecorateCnt = int32(DecorateCnt)
-		res.ActiveTime = int32(ActiveTime)
-	} else {
-		res.DwUin = player.M_DwUin
-		res.NickName = "Player" + strconv.Itoa(int(player.M_DwUin))
-		res.ImageFrame = 1
-		res.ImageIcon = 1
-		res.UnlockFrame = ""
-		res.UnlockIcon = ""
-		res.PicURL = ""
-		DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(player.M_DwUin)
-		res.DecorateCnt = int32(DecorateCnt)
-		res.ActiveTime = int32(ActiveTime)
-
-		st := db.SqlPlayerProfileStruct{}
-		st.DwUin = player.M_DwUin
-		st.ImageFrame = 1
-		st.ImageIcon = 1
-		st.UnlockFrame = ""
-		st.UnlockIcon = ""
-		st.PicURL = ""
-		st.NickName = "Player" + strconv.Itoa(int(player.M_DwUin))
-		p.UpdateNewProfile(&st)
-	}
-	agent := player.GetAgentByPlayer()
-	data1, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResPlayerProfileData", data1)
-
-}
-
-func (p *PlayerProfileManager) ReqUpdatePlayerProfile(args []interface{}) {
-	a := args[0].(gate.Agent)
-	play, _ := internal.Agents.Load(a)
-	buf := args[1].([]byte)
-	player := play.(*Player)
-
-	req := &msg.ReqUpdatePlayerProfile{}
-	res := &msg.ResUpdatePlayerProfile{}
-	proto.Unmarshal(buf, req)
-	profile := p.GetPlayerProfile(player.M_DwUin)
-	if profile != nil {
-		if req.Type == 1 {
-			profile.NickName = req.Param
-		}
-		if req.Type == 2 {
-			value, _ := strconv.Atoi(req.Param)
-			profile.ImageFrame = int32(value)
-		}
-		if req.Type == 3 {
-			value, _ := strconv.Atoi(req.Param)
-			profile.ImageIcon = int32(value)
-		}
-		p.UpdateNewProfile(profile)
-	} else {
-		st := db.SqlPlayerProfileStruct{}
-		st.DwUin = player.M_DwUin
-		st.ImageFrame = 1
-		st.ImageIcon = 1
-		st.NickName = "Player" + strconv.Itoa(int(player.M_DwUin))
-		if req.Type == 1 {
-			st.NickName = req.Param
-		}
-		if req.Type == 2 {
-			value, _ := strconv.Atoi(req.Param)
-			st.ImageFrame = int32(value)
-		}
-		if req.Type == 3 {
-			value, _ := strconv.Atoi(req.Param)
-			st.ImageIcon = int32(value)
-		}
-		st.UnlockFrame = ""
-		st.UnlockIcon = ""
-		st.PicURL = ""
-		p.UpdateNewProfile(&st)
-	}
-	res.DwUin = req.DwUin
-	res.Type = req.Type
-	res.Param = req.Param
-	res.ResultCode = 0
-	agent := player.GetAgentByPlayer()
-	data1, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResUpdatePlayerProfile", data1)
-
-}
-
-func (p *PlayerProfileManager) HttpReqPlayerBriefProfileData(Id int32) *msg.ResPlayerBriefProfileData {
-	profile := p.GetPlayerProfile(Id)
-	res := &msg.ResPlayerBriefProfileData{}
-	if profile != nil {
-		res.DwUin = profile.DwUin
-		res.NickName = profile.NickName
-		res.ImageFrame = profile.ImageFrame
-		res.ImageIcon = profile.ImageIcon
-		DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(Id)
-		res.DecorateCnt = int32(DecorateCnt)
-		res.ActiveTime = int32(ActiveTime)
-		res.PicURL = profile.PicURL
-	} else {
-		res.DwUin = Id
-		res.NickName = "Player" + strconv.Itoa(int(Id))
-		res.ImageFrame = 1
-		res.ImageIcon = 1
-		res.PicURL = ""
-		DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(Id)
-		res.DecorateCnt = int32(DecorateCnt)
-		res.ActiveTime = int32(ActiveTime)
-
-		st := db.SqlPlayerProfileStruct{}
-		st.DwUin = Id
-		st.ImageFrame = 1
-		st.ImageIcon = 1
-		st.UnlockFrame = ""
-		st.UnlockIcon = ""
-		st.PicURL = ""
-		st.NickName = "Player" + strconv.Itoa(int(Id))
-		p.UpdateNewProfile(&st)
-	}
-	return res
-}
-
-func (p *PlayerProfileManager) ReqPlayerBriefProfileData(args []interface{}) {
-	a := args[0].(gate.Agent)
-	play, _ := internal.Agents.Load(a)
-	buf := args[1].([]byte)
-	player := play.(*Player)
-
-	req := &msg.ReqPlayerBriefProfileData{}
-	res := &msg.ResPlayerBriefProfileData{}
-	proto.Unmarshal(buf, req)
-	profile := p.GetPlayerProfile(req.DwUin)
-	if profile != nil {
-		res.DwUin = profile.DwUin
-		res.NickName = profile.NickName
-		res.ImageFrame = profile.ImageFrame
-		res.ImageIcon = profile.ImageIcon
-		DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(req.DwUin)
-		res.DecorateCnt = int32(DecorateCnt)
-		res.ActiveTime = int32(ActiveTime)
-		res.PicURL = profile.PicURL
-	} else {
-		res.DwUin = req.DwUin
-		res.NickName = "Player" + strconv.Itoa(int(req.DwUin))
-		res.ImageFrame = 1
-		res.ImageIcon = 1
-		res.PicURL = ""
-
-		DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(req.DwUin)
-		res.DecorateCnt = int32(DecorateCnt)
-		res.ActiveTime = int32(ActiveTime)
-
-		st := db.SqlPlayerProfileStruct{}
-		st.DwUin = req.DwUin
-		st.ImageFrame = 1
-		st.ImageIcon = 1
-		st.UnlockFrame = ""
-		st.UnlockIcon = ""
-		st.PicURL = ""
-		st.NickName = "Player" + strconv.Itoa(int(req.DwUin))
-		p.UpdateNewProfile(&st)
-	}
-	agent := player.GetAgentByPlayer()
-	data1, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResPlayerBriefProfileData", data1)
-
-}
-
-func (p *PlayerProfileManager) RandomGetAnPlayer(origin int32) *db.SqlPlayerProfileStruct {
-	idx := rand.Intn(len(p.MsqlStrucks))
-
-	for p.MsqlStrucks[idx].DwUin == origin {
-		idx = rand.Intn(len(p.MsqlStrucks))
-	}
-	Profile := p.GetPlayerProfile(p.MsqlStrucks[idx].DwUin)
-
-	if Profile != nil {
-		return Profile
-	} else {
-		sql := &db.SqlPlayerProfileStruct{}
-		sql.DwUin = p.MsqlStrucks[idx].DwUin
-		sql.ImageFrame = 1
-		sql.ImageIcon = 1
-		sql.NickName = "Player" + strconv.Itoa(int(p.MsqlStrucks[idx].DwUin))
-		sql.PicURL = ""
-		p.UpdateNewProfile(sql)
-		return sql
-	}
-}
-func (p *PlayerProfileManager) GetIsHaveAddFriendInfo(sender int32, receive int32) (bool, *db.SqlAddFriendStruct) {
-	sqlStr := "SELECT * FROM t_player_Req_add_Friend WHERE SenderId = ? AND ReceiverId = ?"
-	sqlStruck := db.SqlAddFriendStruct{}
-
-	if err := db.SqlDb.Get(&sqlStruck, sqlStr, sender, receive); err != nil {
-		return false, nil
-	} else {
-		return true, &sqlStruck
-	}
-	// return false
-}
-func (p *PlayerProfileManager) RandomGetPlayers(Cnt int, originId int32, ExcludeList []int32) []*db.SqlPlayerProfileStruct {
-
-	var CurCnt int = 0
-	ret := []*db.SqlPlayerProfileStruct{}
-	var Loops int = 0
-	for {
-		Ids := G_GameLogicPtr.DisorderLuaTable(len(p.MsqlStrucks), int(math.Min(float64(len(p.MsqlStrucks)), float64(Cnt))))
-		for i := 0; i < len(Ids); i++ {
-			IsIll := true
-			for j := 0; j < len(ExcludeList); j++ {
-				if ExcludeList[j] == p.MsqlStrucks[Ids[i]].DwUin {
-					IsIll = false
-					break
-				}
-			}
-			if IsIll {
-				isHave1, _ := p.GetIsHaveAddFriendInfo(originId, p.MsqlStrucks[Ids[i]].DwUin)
-				isHave2, _ := p.GetIsHaveAddFriendInfo(p.MsqlStrucks[Ids[i]].DwUin, originId)
-
-				if !isHave1 && !isHave2 {
-					CurCnt += 1
-					ret = append(ret, &p.MsqlStrucks[Ids[i]])
-					ExcludeList = append(ExcludeList, p.MsqlStrucks[Ids[i]].DwUin)
-					if CurCnt == Cnt {
-						return ret
-					}
-				}
-
-			}
-		}
-		Loops += 1
-		if Loops == 3 {
-			break
-		}
-	}
-
-	return ret
-}
-
-func (p *PlayerProfileManager) ReqUpdateFBPicURL(args []interface{}) {
-	a := args[0].(gate.Agent)
-	play, _ := internal.Agents.Load(a)
-	buf := args[1].([]byte)
-	player := play.(*Player)
-
-	req := &msg.ReqUpdateFBPicURL{}
-	res := &msg.ResUpdateFBPicURL{}
-	proto.Unmarshal(buf, req)
-	profile := p.GetPlayerProfile(player.M_DwUin)
-	res.ResultCode = 0
-	if profile != nil {
-		profile.PicURL = req.URL
-		p.UpdateNewProfile(profile)
-	} else {
-		st := db.SqlPlayerProfileStruct{}
-		st.DwUin = player.M_DwUin
-		st.ImageFrame = 1
-		st.ImageIcon = 1
-		st.UnlockFrame = ""
-		st.UnlockIcon = ""
-		st.PicURL = req.URL
-		st.NickName = "Player" + strconv.Itoa(int(player.M_DwUin))
-		p.UpdateNewProfile(&st)
-	}
-	agent := player.GetAgentByPlayer()
-	data1, _ := proto.Marshal(res)
-	G_getGameLogic().PackResInfo(agent, "ResUpdateFBPicURL", data1)
-
-}
-
-func (p *PlayerProfileManager) NewGetPlayerProfile(DwUin int32) *db.SqlPlayerProfileStruct {
-	profile := p.GetPlayerProfile(DwUin)
-	if profile != nil {
-		return profile
-	} else {
-		st := db.SqlPlayerProfileStruct{}
-		st.DwUin = DwUin
-		st.ImageFrame = 1
-		st.ImageIcon = 1
-		st.UnlockFrame = ""
-		st.UnlockIcon = ""
-		st.PicURL = ""
-		st.NickName = "Player" + strconv.Itoa(int(DwUin))
-		p.UpdateNewProfile(&st)
-		return &st
-	}
-}

src/server/game/PlayerUnlockingChestMod.go

@@ -1,227 +0,0 @@
-package game
-
-import (
-	"fmt"
-	mergeDataCfg "server/conf/mergeData"
-	"server/db"
-	"server/msg"
-	"server/pkg/github.com/name5566/leaf/timer"
-	"time"
-
-	"google.golang.org/protobuf/proto"
-)
-
-type PlayerUnlockingChestData struct {
-	*PlayerData
-	Data       msg.ResUnlockingChestID
-	MLeafTimer *timer.Timer
-	Mdispatr   *timer.Dispatcher
-}
-
-func (p *PlayerUnlockingChestData) LoadDataFromDB(dwUin interface{}) bool {
-
-	sqlStr := "SELECT * FROM t_player_chest_data WHERE dwUin = ?"
-	sqlStruck := db.SqlChestStruct{}
-	p.Mdispatr = timer.NewDispatcher(1)
-	if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin.(int32)); err != nil {
-		fmt.Printf("get data failed, err:%v\n", err)
-		p.IsHaveDataDb = false
-	} else {
-		p.IsHaveDataDb = true
-	}
-	p.Data.DwUin = dwUin.(int32)
-	p.Data.ChestID = sqlStruck.ChestID
-	p.Data.UnlockStartTime = sqlStruck.UnlockStartTime
-	p.Data.CurSvrTime = int32(time.Now().Unix())
-
-	p.Reconnect(false)
-	return true
-}
-func (p *PlayerUnlockingChestData) Reconnect(b bool) {
-	if p.Data.ChestID > 0 {
-		chessKey := p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).GetKeyByEmitID(p.Data.ChestID)
-		if chessKey == "" {
-			p.Data.ChestID = 0
-			p.Data.UnlockStartTime = 0
-			return
-		}
-		MergeId := p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).GetValueByKey(chessKey)
-		item, _ := mergeDataCfg.GetOne(int(MergeId))
-		cool := item.CoolTime
-		deltaTime := time.Now().Unix() - (int64)(p.Data.UnlockStartTime)
-		if deltaTime >= (int64)(cool) { //注意后面读表
-			if p.M_Player.GetGameData("PlayerChessData") == nil {
-				data := &PlayerChessData{PlayerData: NewPlayerData("PlayerChessData", p.M_Player)}
-				ok := data.LoadDataFromDB(p.M_Player.M_DwUin)
-				if ok {
-					p.M_Player.playerdata["PlayerChessData"] = data
-					p.M_Player.playerdataIF["PlayerChessData"] = data
-				}
-			}
-
-			p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).SetValueByKey(chessKey)
-			fmt.Println("chessKey:", chessKey)
-			p.Data.ChestID = 0
-			p.Data.UnlockStartTime = 0
-			if b {
-				p.NotifyUnlockingChestData()
-			}
-		} else {
-			go func() {
-				// 注释内容也可以使用
-				t1 := (int64)(cool) - deltaTime
-
-				p.MLeafTimer = p.Mdispatr.AfterFunc(time.Duration(t1)*time.Second, func() {
-					p.NotifyUnlockingChestData()
-					p.MLeafTimer = nil
-				})
-				(<-p.Mdispatr.ChanTimer).Cb()
-			}()
-		}
-		p.NotifyInitUnlockingChestID()
-	}
-}
-
-func (p *PlayerUnlockingChestData) RenewData() {
-	if p.Data.ChestID > 0 {
-		chessKey := p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).GetKeyByEmitID(p.Data.ChestID)
-		MergeId := p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).GetValueByKey(chessKey)
-		// MergeId := p.M_Player.GetIFGameData("PlayerEmitDetailData").(*PlayerEmitDetailData).GetMergeIDByChestid(p.Data.ChestID)
-		item, _ := mergeDataCfg.GetOne(int(MergeId))
-		cool := item.CoolTime
-		deltaTime := time.Now().Unix() - (int64)(p.Data.UnlockStartTime)
-		if p.MLeafTimer != nil {
-			p.MLeafTimer.Disabled()
-			p.Mdispatr.ChanTimer <- p.MLeafTimer
-			p.MLeafTimer.Stop()
-			p.MLeafTimer = nil
-		}
-		if deltaTime >= (int64)(cool) { //注意后面读表
-
-			p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).SetValueByKey(chessKey)
-
-			p.Data.ChestID = 0
-			p.Data.UnlockStartTime = 0
-		} else {
-			go func() {
-				// 注释内容也可以使用
-				t1 := (int64)(cool) - deltaTime
-
-				p.MLeafTimer = p.Mdispatr.AfterFunc(time.Duration(t1)*time.Second, func() {
-					p.NotifyUnlockingChestData()
-					p.MLeafTimer = nil
-				})
-				(<-p.Mdispatr.ChanTimer).Cb()
-			}()
-		}
-		p.NotifyInitUnlockingChestID()
-	}
-}
-
-func (p *PlayerUnlockingChestData) NotifyInitUnlockingChestID() {
-	notify := &msg.NotifyInitUnlockingChestID{}
-	notify.ChestID = p.Data.ChestID
-	notify.UnlockStartTime = p.Data.UnlockStartTime
-	notify.DwUin = p.M_Player.M_DwUin
-	notify.CurSvrTime = int32(time.Now().Unix())
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(notify)
-	G_GameLogicPtr.PackResInfo(agent, "NotifyInitUnlockingChestID", data)
-}
-
-func (p *PlayerUnlockingChestData) ClearData() bool {
-	p.SaveDataFromDB("")
-	if p.MLeafTimer != nil {
-		p.MLeafTimer.Disabled()
-		p.Mdispatr.ChanTimer <- p.MLeafTimer
-		p.MLeafTimer.Stop()
-		p.MLeafTimer = nil
-	}
-	return true
-}
-func (p *PlayerUnlockingChestData) SaveDataFromDB(Key interface{}) bool {
-
-	sqlStruck := db.SqlChestStruct{}
-	sqlStruck.DwUin = p.M_Player.M_DwUin
-	sqlStruck.ChestID = p.Data.ChestID
-	sqlStruck.UnlockStartTime = p.Data.UnlockStartTime
-
-	if p.IsHaveDataDb {
-		db.FormatAllMemUpdateDb(&sqlStruck, "t_player_chest_data", "dwUin")
-	} else {
-		db.FormatAllMemInsertDb(&sqlStruck, "t_player_chest_data")
-	}
-	p.IsHaveDataDb = true
-	return true
-}
-
-func (p *PlayerUnlockingChestData) ResUnlockingChestID(buf []byte) {
-	update := &msg.ReqUnlockingChestID{}
-	proto.Unmarshal(buf, update)
-	p.Data.ChestID = update.ChestID
-	p.Data.UnlockStartTime = int32(time.Now().Unix())
-	// G_GameLogicPtr.Mlogger.Debug("ResUnlockingChestID1:", p.Data.ChestID, update.MergeID)
-	p.M_Player.GetIFGameData("PlayerEmitDetailData").(*PlayerEmitDetailData).SetMergeIDByChestid(update.ChestID, update.MergeID)
-	// G_GameLogicPtr.Mlogger.Debug("ResUnlockingChestID2:", p.Data.ChestID, update.MergeID)
-	p.RenewData()
-	// G_GameLogicPtr.Mlogger.Debug("ResUnlockingChestID3:", p.Data.ChestID, update.MergeID)
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(&p.Data)
-	G_GameLogicPtr.PackResInfo(agent, "ResUnlockingChestID", data)
-}
-
-func (p *PlayerUnlockingChestData) ResChestUnlockCD(buf []byte) {
-	update := &msg.ReqChestUnlockCD{}
-	proto.Unmarshal(buf, update)
-
-	res := &msg.ResChestUnlockCD{}
-	res.DwUin = p.GetPlayer().M_DwUin
-	res.ChestID = update.ChestID
-	res.Type = update.Type
-	res.CurSvrTime = int32(time.Now().Unix())
-	////ad
-	if res.Type == 3 {
-		p.Data.UnlockStartTime = p.Data.UnlockStartTime - 60*30
-		res.UnlockStartTime = p.Data.UnlockStartTime
-		p.RenewData()
-	}
-	///diamond
-	if res.Type == 2 {
-		p.Data.UnlockStartTime = 0
-		p.RenewData()
-	}
-
-	if res.Type == 1 {
-		p.Data.ChestID = 0
-		p.Data.UnlockStartTime = 0
-		if p.MLeafTimer != nil {
-			p.MLeafTimer.Disabled()
-			p.Mdispatr.ChanTimer <- p.MLeafTimer
-			p.MLeafTimer.Stop()
-			p.MLeafTimer = nil
-		}
-	}
-
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(res)
-	G_GameLogicPtr.PackResInfo(agent, "ResChestUnlockCD", data)
-}
-
-func (p *PlayerUnlockingChestData) NotifyUnlockingChestData() {
-
-	chessKey := p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).GetKeyByEmitID(p.Data.ChestID)
-	p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).SetValueByKey(chessKey)
-
-	notify := &msg.NotifyUnlockingChestData{}
-	notify.DwUin = p.GetPlayer().M_DwUin
-	notify.ChestID = 0
-	notify.UnlockStartTime = 0
-	p.Data.ChestID = 0
-	p.Data.UnlockStartTime = 0
-	notify.CurSvrTime = int32(time.Now().Unix())
-
-	agent := p.GetPlayer().GetAgentByPlayer()
-	data, _ := proto.Marshal(notify)
-	G_GameLogicPtr.PackResInfo(agent, "NotifyUnlockingChestData", data)
-
-}

src/server/game/RankMgr.go

@@ -1,25 +1,37 @@
 package game
 
 import (
+	"fmt"
+	"server/GoUtil"
 	"server/db"
 	"server/game/mod/msg"
 	"sort"
 	"strconv"
 )
 
+const (
+	RANK_TIME_SORT = 3000000000
+)
+
 type RankMgr struct {
 	*ServerMod
 }
 
 type RankData struct {
 	List      map[int][]*Rank // 玩家排行榜
+	Champship map[int][]*Rank // 锦标赛排行榜
 	BackData  map[int][]*Rank // 玩家排行榜 备份
 }
 
+type RankInfo struct {
+	List    []*Rank
+	MyRank  int
+	MyScore float64
+}
+
 const (
 	RANK_TYPE_USER   = 1 // 玩家排行榜
-	RANK_TYPE_CHAMPSHIP = 2 // 锦标赛排行榜
-	RANK_TYPE_GLOBAL    = 3 // 全球排行榜
+	RANK_TYPE_GLOBAL = 2 // 全球排行榜
 
 	RANK_USER = "rank_user" // redis玩家排行榜
 )
@@ -54,20 +66,36 @@ func (r *RankMgr) getData() *RankData {
 
 // 零点更新 重置榜单
 func (r *RankMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {
-	r.getData().BackData[RANK_TYPE_CHAMPSHIP] = r.getData().List[RANK_TYPE_CHAMPSHIP]
-	r.getData().List[RANK_TYPE_CHAMPSHIP] = []*Rank{}
-	r.update = true
 	return nil, nil
 }
 
 // 获取榜单数据
 func (r *RankMgr) getRank(RankType int) []*Rank {
+	if v, ok := r.getData().List[RankType]; ok {
+		len := min(100, len(v))
+		return v[:len]
+	}
+	return []*Rank{}
+}
+
+func (r *RankMgr) getAllRank(RankType int) []*Rank {
 	if v, ok := r.getData().List[RankType]; ok {
 		return v
 	}
 	return []*Rank{}
 }
 
+func (r *RankMgr) getMyRank(Uid, RankType int) (int, float64) {
+	if d, ok := r.getData().List[RankType]; ok {
+		for k, v := range d {
+			if v.Uid == Uid {
+				return k + 1, v.Score
+			}
+		}
+	}
+	return 0, 0.0
+}
+
 // 设置榜单数据
 func (r *RankMgr) setRank(RankType int, data []*Rank) {
 	r.getData().List[RankType] = data
@@ -76,8 +104,40 @@ func (r *RankMgr) setRank(RankType int, data []*Rank) {
 // 获取排行榜信息
 func (r *RankMgr) getRankInfo(m *msg.Msg) (interface{}, error) {
 	data := m.Extra.(RankMsg)
+	if data.RankType == RANK_TYPE_GLOBAL {
+		return r.getRedisRankInfo(m)
+	}
 	rankList := r.getRank(data.RankType)
-	return rankList, nil
+	MyRank, MyScore := r.getMyRank(m.From, data.RankType)
+	return &RankInfo{
+		List:    rankList,
+		MyRank:  MyRank,
+		MyScore: MyScore,
+	}, nil
+}
+
+func (r *RankMgr) getRedisRankInfo(m *msg.Msg) (interface{}, error) {
+	RedisList, err := db.RedisZRevRangeWithScores(RANK_USER, 0, 100)
+	if err != nil {
+		return &RankInfo{}, nil
+	}
+	sort.Slice(RedisList, func(i, j int) bool { // 排序 从大到小
+		return RedisList[i].Score > RedisList[j].Score
+	})
+	rankList := make([]*Rank, 0)
+	for _, v := range RedisList {
+		rankList = append(rankList, &Rank{
+			Uid:   GoUtil.Int(v.Member),
+			Score: v.Score,
+			Time:  GoUtil.Now(),
+		})
+	}
+	MyRank, MyScore, _ := db.RedisZRankWithScores(RANK_USER, strconv.Itoa(m.From))
+	return &RankInfo{
+		List:    rankList,
+		MyRank:  int(MyRank),
+		MyScore: MyScore,
+	}, nil
 }
 
 // 进入排行榜
@@ -91,6 +151,7 @@ func (r *RankMgr) inRank(m *msg.Msg) (interface{}, error) {
 				v.Score = data.Score
 				v.Time = m.SendT
 				inRank = true
+				break
 			}
 			return nil, nil
 		}
@@ -107,14 +168,25 @@ func (r *RankMgr) inRank(m *msg.Msg) (interface{}, error) {
 		}
 		return false
 	})
+
 	// if len(rankList) >= 100 {
 	// 	rankList = rankList[:100]
 	// }
 	r.setRank(data.RankType, rankList)
 	if data.RankType == RANK_TYPE_USER {
 		Uid := strconv.Itoa(data.Uid)
-		db.RedisZAdd(RANK_USER, Uid, data.Score)
+		TimeSort := fmt.Sprintf("0.%d", RANK_TIME_SORT-GoUtil.Now())
+		TimeSortF, _ := strconv.ParseFloat(TimeSort, 64)
+		db.RedisZAdd(RANK_USER, Uid, data.Score+TimeSortF)
 	}
 	r.update = true
 	return nil, nil
 }
+
+func (r *RankMgr) ClearRank(RankType int) {
+	// if RankType == RANK_TYPE_GLOBAL {
+	// 	db.RedisDel(RANK_USER)
+	// 	return
+	// }
+	r.setRank(RankType, []*Rank{})
+}

src/server/game/ServerMod.go

@@ -1,6 +1,8 @@
 package game
 
 import (
+	"context"
+	"database/sql"
 	"fmt"
 	"server/GoUtil"
 	"server/db"
@@ -15,8 +17,10 @@ const (
 	FRIEND_MGR_KEY    = "FRIEND_MGR"
 	RANK_MGR_KEY      = "RANK_MGR"
 	MAIL_MGR_KEY      = "MAIL_MGR"
-
-	PER_SAVE_TIME = 1
+	VAR_MGR_KEY       = "VAR_MGR"
+	CHAMPSHIP_MGR_KEY = "CHAMPSHIP_MGR"
+	BAN_MGR_KEY       = "BAN_MGR"
+	PER_SAVE_TIME     = 60
 )
 
 type ServerMod struct {
@@ -38,16 +42,17 @@ func (s *ServerMod) init() {
 	s.handler = make(map[int]interface{})
 	s.update = false
 	s.LoadData()
-	s.mDispatr.AfterFunc(time.Duration(PER_SAVE_TIME), func() {
-		s.SaveData()
+	s.mDispatr.AfterFunc(time.Duration(PER_SAVE_TIME)*time.Second, func() {
+		go s.SaveData()
 	})
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
-				log.Debug("FriendMgr panic: %s", r)
+				log.Error("%s panic: %s", s.key, r)
 				s.lock.Unlock()
 			}
 		}()
+
 		for {
 			select {
 			case msg := <-s.msgChan:
@@ -61,6 +66,7 @@ func (s *ServerMod) init() {
 			}
 		}
 	}()
+
 }
 
 // 处理消息
@@ -68,7 +74,7 @@ func (s *ServerMod) Handle(m *msg.Msg) (interface{}, error) {
 	if fun, ok := s.handler[m.Type]; ok {
 		return fun.(func(*msg.Msg) (interface{}, error))(m)
 	}
-	log.Debug("server mod key:%s handle not exist handle type:%d", s.key, m.Type)
+	log.Error("server mod key:%s handle not exist handle type:%d", s.key, m.Type)
 	return nil, fmt.Errorf("server mod handler err")
 }
 
@@ -77,7 +83,7 @@ func (s *ServerMod) RegisterHandler(HandlerType int, fun interface{}) {
 	switch fun.(type) {
 	case func(*msg.Msg) (interface{}, error):
 	default:
-		log.Debug("RegisterHandler fun type err, key:%s, handler type :%d", s.key, HandlerType)
+		log.Error("RegisterHandler fun type err, key:%s, handler type :%d", s.key, HandlerType)
 	}
 	s.handler[HandlerType] = fun
 }
@@ -115,32 +121,40 @@ func (s *ServerMod) Call(m *msg.Msg) (interface{}, error) {
 		log.Debug("handle call err. %v", err)
 		return nil, err
 	case <-time.After(s.timeout):
-		log.Debug("handle call timeout")
+		log.Error("handle call timeout")
 		return nil, fmt.Errorf("timeout after %v", s.timeout)
 	}
 }
 
 // mysql 保存消息
 func (s *ServerMod) SaveData() {
-	s.mDispatr.AfterFunc(time.Duration(PER_SAVE_TIME+GoUtil.RandNum(5, 10)), func() {
-		s.SaveData()
+	s.mDispatr.AfterFunc(time.Duration(PER_SAVE_TIME+GoUtil.RandNum(5, 10))*time.Second, func() {
+		go s.SaveData()
 	})
-	if !s.update {
-		return
-	}
 	DbData := db.SqlServerModStruct{}
 	DbData.Key = s.key
 	DbData.UpdataTime = GoUtil.Now()
 	var err error
 	DbData.ModData, err = GoUtil.GobMarshal(s.data)
 	if err != nil {
-		log.Debug("SaveData Marshal failed,Mod Key: %s err:%v", s.key, err)
+		log.Error("SaveData Marshal failed,Mod Key: %s err:%v", s.key, err)
+	}
+	// log.Debug("SaveData Marshal success,Mod Key: %s", s.key)
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	txOptions := &sql.TxOptions{}
+	tx, err := db.SqlDb.BeginTx(ctx, txOptions)
+	if err != nil {
+		log.Error("SaveData sql begin tx failed,Mod Key: %s err:%v", s.key, err)
+		return
 	}
 	err = db.SaveServerData(&DbData)
 	if err != nil {
-		log.Debug("SaveData sql exec ,Mod Key: %s err:%v", s.key, err)
+		tx.Rollback()
+		log.Error("SaveData sql exec ,Mod Key: %s err:%v", s.key, err)
+		return
 	}
-
+	tx.Commit()
 }
 
 func (s *ServerMod) LoadData() {

src/server/game/Trigger.go

@@ -0,0 +1,450 @@
+package game
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"server/GoUtil"
+	"server/MergeConst"
+	"server/conf"
+	champshipCfg "server/conf/champship"
+	languageCfg "server/conf/language"
+	mailCfg "server/conf/mail"
+	mergeDataCfg "server/conf/mergeData"
+	"server/db"
+	"server/game/mod/chess"
+	"server/game/mod/item"
+	"server/game/mod/order"
+	"server/game/mod/quest"
+	"server/msg"
+	"server/pkg/github.com/name5566/leaf/log"
+	"sort"
+	"time"
+)
+
+const (
+	TRIGGER_PARAM_LV  = "lv"  // 等级
+	TRIGGER_PARAM_REQ = "reg" // 注册天数
+)
+
+func (player *Player) MailTrigger(Tr *quest.Trigger) bool {
+	MailMod := player.PlayMod.getMailMod()
+	TriggerMail := mailCfg.GetTriggerMail()
+	t := make([]*mailCfg.TriggerMail, 0)
+	for _, v := range TriggerMail {
+		if GoUtil.InArray(v.Id, MailMod.TriggerMail) {
+			continue
+		}
+		if Tr.Label != v.Trigger[0] {
+			continue
+		}
+		t = append(t, v)
+	}
+	if len(t) == 0 {
+		return false
+	}
+	tr := false
+	for _, v := range t {
+		if checkTriggerCondition(player, v.Trigger) {
+			Title := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, v.Title)
+			Content := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, v.Content)
+			TitleEn := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, v.Title)
+			ContentEn := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, v.Content)
+			MailMod.Send(Title, "", Content, TitleEn, "", ContentEn, v.Items, v.Type)
+			MailMod.AddTriggerMail(v.Id)
+			tr = true
+		}
+	}
+
+	return tr
+}
+
+func checkTriggerCondition(player *Player, Trigger []string) bool {
+	if len(Trigger) < 4 {
+		return false
+	}
+	switch Trigger[1] {
+	case TRIGGER_PARAM_LV:
+		lv := player.PlayMod.getBaseMod().GetLevel()
+		return GoUtil.Compare(lv, Trigger[2], GoUtil.Int(Trigger[3]))
+	case TRIGGER_PARAM_REQ:
+		reg := player.GetPlayerBaseMod().GetRegisterTime()
+		Day := GoUtil.DaysSince(reg)
+		return GoUtil.Compare(Day, Trigger[2], GoUtil.Int(Trigger[3]))
+	default:
+		return false
+	}
+}
+
+func TriggerShippingOrder(player *Player, req *msg.ReqShippingOrder) {
+	OrderSn := req.OrderSn
+	Status := int(req.Status)
+	if Status == MergeConst.ORDER_STATUS_CANCEL { // 取消支付
+		CancelOrder(player, OrderSn)
+		player.PushClientRes(&msg.ResShippingOrder{
+			Code: msg.RES_CODE_SUCCESS,
+			Msg:  "cancel success",
+		})
+		return
+	}
+	OrderData := &db.SqlChargeOrderStruct{}
+	var err error
+	n := 0
+	for {
+		n++
+		if n > 5 {
+			break
+		}
+		OrderData, err = GoogleVerify(player, OrderSn, req.ProduceId, req.Token)
+		if err != nil {
+			log.Debug("GoogleVerify parmas OrderSn：%s; ProduceId:%s; Token:%s", OrderSn, req.ProduceId, req.Token)
+			log.Debug("GoogleVerify err:%v", err)
+			time.Sleep(1 * time.Second)
+			continue
+		}
+		if OrderData.PayStatus != MergeConst.ORDER_STATUS_PAY {
+			time.Sleep(1 * time.Second)
+			continue
+		}
+		if OrderData.PayStatus == MergeConst.ORDER_STATUS_PAY {
+			break
+		}
+	}
+	if OrderData == nil {
+		GoUtil.SendFeishuFatal(int(player.M_DwUin), "GoogleVerify支付校验异常", fmt.Sprintf("GoogleVerify parmas OrderSn：%s; ProduceId:%s; Token:%s", OrderSn, req.ProduceId, req.Token))
+		log.Debug("[order data nil] Uid:%d;OrderSn:%s;PayOrder:%s;", player.M_DwUin, OrderSn, req.ProduceId)
+		return
+	} else {
+		if conf.Server.GameName == "Merge_Pet_online" {
+			GoUtil.SendFeishuOrder(int(player.M_DwUin), OrderData.PayChannelOrderId, OrderData.Price, req.ProduceId, OrderData.PayTime, GoUtil.Now())
+		}
+	}
+	log.Debug("[order verify success] Uid:%d;OrderSn:%s;PayOrder:%s;Token:%s", player.M_DwUin, OrderData.OrderId, OrderData.PayChannelOrderId, req.Token)
+	player.lock.Lock()
+	defer player.lock.Unlock()
+	OrderExtraData := &ChargeExtra{}
+	if OrderData.PayChannelExtra != "" {
+		err = json.Unmarshal([]byte(OrderData.PayChannelExtra), OrderExtraData)
+		if err != nil {
+			log.Debug("GoogleVerify err:%v", err)
+			return
+		}
+		OrderExtraData.ChargeId = OrderData.ProductId
+	}
+	if OrderExtraData.Type == 0 {
+		Charge(player, int(OrderData.ProductId))
+	} else {
+		SendCharge(player, OrderExtraData)
+	}
+	OrderData.PayStatus = MergeConst.ORDER_STATUS_SHIP
+	OrderData.ProductName = req.ProduceId
+	db.UpdatePlayerChargeData(OrderData)
+	player.PlayMod.save()
+	orderDataMap := map[string]interface{}{
+		"AppId":             conf.Server.AppID,
+		"ServerId":          conf.Server.ServerID,
+		"OrderId":           OrderData.OrderId,
+		"PayChannelOrderId": OrderData.PayChannelOrderId,
+		"ProductId":         OrderData.ProductId,
+		"CreateTime":        OrderData.CreateTime,
+		"PayTime":           OrderData.PayTime,
+		"Token":             req.Token,
+		"Price":             OrderData.Price,
+		"PayType":           OrderData.PayType,
+	}
+	player.Kafka("pay", orderDataMap)
+	player.SendClientRes()
+}
+
+func TriggerComfortOrder(p *Player) {
+	BaseMod := p.PlayMod.getBaseMod()
+	Now := GoUtil.Now()
+	Lv := BaseMod.GetLevel()
+
+	if Now-BaseMod.GetLogoutTime() < 7*86400 || Lv < 23 {
+		return
+	}
+	OrderMod := p.PlayMod.getOrderMod()
+	ChessMod := p.PlayMod.getChessMod()
+	OrderMod.ComfortEndTime = int(Now + 86400)
+	EmitList := ChessMod.GetEmitList()
+	EnergyMul := BaseMod.GetEnergyMul()
+	OrderMod.CreateNormalOrder(BaseMod.GetLevel(), EmitList, EnergyMul, order.COMFORT_TYPE)
+}
+
+func TriggerSeed(player *Player) {
+	ChampshipMod := player.PlayMod.getChampshipMod()
+	Items, Score := champshipCfg.GetRewardItems(ChampshipMod.Reward + 1)
+	if Score < 50 {
+		return
+	}
+	b := false
+	for _, v := range Items {
+		if v.Id == item.ITEM_ENERGY_ID {
+			b = true
+			break
+		}
+	}
+	BaseMod := player.PlayMod.getBaseMod()
+	if !b {
+		BaseMod.SetSeed(false)
+	} else {
+		BaseMod.SetSeed(true)
+	}
+}
+
+func TriggerSeedSource(player *Player) {
+	BaseMod := player.PlayMod.getBaseMod()
+	if !BaseMod.GetSeed() {
+		return
+	}
+	Total := 0
+	Energy := BaseMod.GetEnergy()
+	Total += Energy
+
+	ChessMod := player.PlayMod.getChessMod()
+	ChessList := ChessMod.GetUnlockChessList()
+	ChessBuff := ChessMod.GetChessBuf()
+	AllChess := append(ChessList, ChessBuff...)
+	for _, v := range AllChess {
+		ChessColor := mergeDataCfg.GetColorById(v)
+		if ChessColor == "Energy" {
+			Total += mergeDataCfg.GetSellNumById(v)
+		}
+		if v == chess.CHESS_ENERGY_CHEST {
+			Total += 50
+		}
+		if v == chess.CHESS_SURPRISE_CHEST_LOCK || v == chess.CHESS_SURPRISE_CHEST {
+			Total += 10
+		}
+		if v == chess.CHESS_SOURCE_CHEST {
+			Total += 100
+		}
+		if v == chess.CHESS_HIGH_SOURCE_CHEST {
+			Total += 250
+		}
+	}
+
+	Total += (5 - BaseMod.EnergyAD) * 25
+	BaseMod.SetSource(Total)
+}
+
+func TriggerSeedOrder(player *Player) *order.Order {
+	OrderMod := player.PlayMod.getOrderMod()
+	ChessMod := player.PlayMod.getChessMod()
+	BaseMod := player.PlayMod.getBaseMod()
+	if !BaseMod.GetSeed() {
+		return nil
+	}
+	OrderMod.CreatOrderPool(BaseMod.Level, ChessMod.GetOrderEmit(), BaseMod.EnergyMul)
+	ChampshipMod := player.PlayMod.getChampshipMod()
+	NeedScore := champshipCfg.GetRewardTotalScore(ChampshipMod.Reward + 1)
+	E := BaseMod.GetSource()
+	ChessList := ChessMod.GetUnlockChessList()
+	ChessBuff := ChessMod.GetChessBuf()
+	AllChess := append(ChessList, ChessBuff...)
+	NewOrder := &order.Order{}
+	MaxQ := 0
+	MinQ := 0
+	// 计算Q值
+	for _, Order := range OrderMod.OrderPool {
+		Q := 0
+		for _, v := range Order.MergeId {
+			Color := mergeDataCfg.GetColorById(v)
+			Lv := mergeDataCfg.GetLvById(v)
+			Q1 := int(math.Pow(2, float64(Lv))) - 1
+			Q2 := 0
+			Q3 := 0
+			for _, Chess := range AllChess {
+				Lv1 := mergeDataCfg.GetLvById(Chess)
+				Color1 := mergeDataCfg.GetColorById(Chess)
+				Type := mergeDataCfg.GetTypeById(Chess)
+				if Type != "Product" {
+					continue
+				}
+				if Color != Color1 {
+					continue
+				}
+				if Lv1 > Lv {
+					continue
+				}
+				Q2 += int(math.Pow(2, float64(Lv1))) - 1
+			}
+			for _, Chess := range AllChess {
+				if Chess == chess.CHESS_ZIXUAN_CHEST {
+					if Lv < 3 {
+						continue
+					}
+					Q3 += int(math.Pow(2, 3)) - 1
+				}
+				if Chess == chess.CHESS_HIGH_ZIXUAN_CHEST {
+					if Lv < 7 {
+						continue
+					}
+					Q3 += int(math.Pow(2, 7)) - 1
+				}
+				if Chess == chess.CHESS_SOURCE_CHEST {
+					if Lv < 3 {
+						continue
+					}
+					Q3 += int(math.Pow(2, 3)) - 1
+					Q3 += int(math.Pow(2, 4)) - 1
+				}
+				if Chess == chess.CHESS_HIGH_SOURCE_CHEST {
+					if Lv < 7 {
+						continue
+					}
+					Q3 += int(math.Pow(2, 7)) - 1
+					Q3 += int(math.Pow(2, 7)) - 1
+				}
+			}
+			Q += max(Q1-Q2-Q3, 0)
+			Order.Q = Q
+			MaxQ = max(MaxQ, Q)
+			MinQ = min(MinQ, Q)
+		}
+	}
+
+	if E > MaxQ {
+		return nil
+	}
+	// 生成订单
+	ProduceChessList := []int{}
+	for _, v := range AllChess {
+		Type := mergeDataCfg.GetTypeById(v)
+		if Type != "Product" {
+			continue
+		}
+		ProduceChessList = append(ProduceChessList, v)
+	}
+	if E == MaxQ {
+		for _, Order := range OrderMod.OrderPool {
+			if Order.Q == MaxQ {
+				NewOrder = Order
+				break
+			}
+		}
+		EmitTypeList := []string{}
+		for _, v := range NewOrder.MergeId {
+			Color := mergeDataCfg.GetColorById(v)
+			EmitType := mergeDataCfg.GetEmitTypeByColor(Color)
+			EmitTypeList = append(EmitTypeList, EmitType)
+		}
+		ChessList := []int{}
+		for _, v := range ProduceChessList {
+			Color := mergeDataCfg.GetColorById(v)
+			EmitType := mergeDataCfg.GetEmitTypeByColor(Color)
+			Lv := mergeDataCfg.GetLvById(v)
+			if Lv < 3 || Lv > 4 {
+				continue
+			}
+			if GoUtil.InStringArray(EmitType, EmitTypeList) {
+				continue
+			}
+			ChessList = append(ChessList, v)
+		}
+		if len(ChessList) != 0 {
+			RandChess := GoUtil.RandSlice(ChessList)
+			Color := mergeDataCfg.GetColorById(RandChess)
+			Lv := mergeDataCfg.GetLvById(RandChess)
+			NewChess := mergeDataCfg.GetChessIdByLvAndColor(Lv, Color)
+			NewOrder.MergeId = append(NewOrder.MergeId, NewChess)
+		}
+		return NewOrder
+	}
+
+	if E == MinQ {
+		for _, Order := range OrderMod.OrderPool {
+			if Order.Q == MinQ {
+				return Order
+			}
+		}
+	}
+
+	if E < MinQ {
+		for _, Order := range OrderMod.OrderPool {
+			if Order.Q == MinQ {
+				ChessList := []int{}
+				for _, v := range ProduceChessList {
+					Lv := mergeDataCfg.GetLvById(v)
+					if Lv < 5 {
+						ChessList = append(ChessList, v)
+					}
+				}
+				if len(ChessList) != 0 {
+					NewChess := GoUtil.RandSlice(ChessList)
+					Order.MergeId = append(Order.MergeId, NewChess)
+				}
+				return Order
+			}
+		}
+	}
+
+	if E > MinQ && E < MaxQ {
+		L1 := []*order.Order{}
+		for _, Order := range OrderMod.OrderPool {
+			if Order.Q > E {
+				L1 = append(L1, Order)
+			}
+		}
+		Smax := 0
+		Smin := 0
+		for _, Order := range L1 {
+			Score := 0
+			for _, v := range Order.MergeId {
+				Lv := mergeDataCfg.GetLvById(v)
+				Score += champshipCfg.GetChessScore(Lv)
+			}
+			Smax = max(Score, Smax)
+			Smin = min(Score, Smin)
+			Order.S = Score
+		}
+
+		if NeedScore > Smax {
+			for _, Order := range OrderMod.OrderPool {
+				if Order.Q == MinQ {
+					ChessList := []int{}
+					for _, v := range ProduceChessList {
+						Lv := mergeDataCfg.GetLvById(v)
+						if Lv < 5 {
+							ChessList = append(ChessList, v)
+						}
+					}
+					if len(ChessList) != 0 {
+						NewChess := GoUtil.RandSlice(ChessList)
+						Order.MergeId = append(Order.MergeId, NewChess)
+					}
+					return Order
+				}
+			}
+		}
+		if NeedScore == Smax {
+			for _, Order := range L1 {
+				if Order.S == Smax {
+					return Order
+				}
+			}
+		}
+
+		if NeedScore == Smin {
+			for _, Order := range L1 {
+				if Order.S == Smin {
+					return Order
+				}
+			}
+		}
+		L2 := []*order.Order{}
+		for _, Order := range L1 {
+			if Order.S > NeedScore {
+				L2 = append(L2, Order)
+			}
+		}
+		if len(L2) != 0 {
+			sort.Slice(L2, func(i, j int) bool {
+				return L2[i].Q < L2[j].Q
+			})
+			return L2[0]
+		}
+	}
+	return NewOrder
+}

src/server/game/Type.go

@@ -0,0 +1,110 @@
+package game
+
+import (
+	"encoding/gob"
+	"server/game/mod/limitedTimeEvent"
+	"server/game/mod/msg"
+)
+
+type PlayerSimpleData struct {
+	Uid         int
+	Name        string
+	Avatar      int
+	Level       int
+	Face        int
+	Decorate    int
+	Star        int
+	Login       int64
+	Loginout    int64
+	FaceBook    string
+	FaceBookPic string
+	Playroom    map[int]int
+	Chess       []int
+	WorkStart   int64
+	Chip        int
+	PetName     string
+	Emoji       map[int]int
+	Friend      []int
+	Upvote      int
+	DressSet    map[int]int
+	CardInfo    []int
+}
+
+type VarGoldCard struct {
+	Four int
+	Five int
+}
+
+type VarOpration struct {
+	Type int
+	Key  string
+	Data interface{}
+	Code int
+}
+
+type VarUserData struct {
+	Upvote int
+	Chip   int
+	Kiss   int
+}
+
+type VarExpireData struct {
+	D interface{}
+	T int64
+}
+
+const (
+	ACT_STATUS_NOT_START = 0
+	ACT_STATUS_START     = 1
+	ACT_STATUS_END       = 2
+)
+
+type ActivityInfo struct {
+	StartT int64
+	EndT   int64
+	Id     int
+	Type   int
+	Title  string
+	Name   string
+	Status int
+	Info   interface{}
+}
+
+type ChargeExtra struct {
+	Type     int   // 充值类型
+	Uid      int64 // 充值用户
+	ChargeId int   // 充值id
+}
+
+type GameResult struct {
+	T     int // 游戏类型
+	R     int // 1:赢 2:输 3:平
+	Emoji int // 表情
+}
+
+type CatnipMsg struct {
+	ActivityId int
+	GameId     int
+	Growth     int // 增长值
+}
+
+type CatnipLock struct {
+	Uid     int // 玩家ID
+	Partner int // 伙伴ID
+	GameId  int // 游戏ID
+	End     int
+}
+
+func init() {
+	gob.Register(&limitedTimeEvent.MoneyCat{})
+	gob.Register(&limitedTimeEvent.LuckyCat{})
+	gob.Register(&msg.HandbookMsg{})
+	gob.Register(&limitedTimeEvent.CatTrick{})
+	gob.Register(&VarOpration{})
+	gob.Register(&VarUserData{})
+	gob.Register(&ActivityInfo{})
+	gob.Register(&ChargeExtra{})
+	gob.Register(&GameResult{})
+	gob.Register(&CatnipMsg{})
+	gob.Register(&CatnipLock{})
+}

src/server/game/UnitTest.go

@@ -1,20 +1,33 @@
 package game
 
-import "fmt"
+import (
+	"fmt"
+	"math"
+	mergeDataCfg "server/conf/mergeData"
+	orderCfg "server/conf/order"
+	"server/game/mod/decorate"
+	"server/game/mod/item"
+	"server/game/mod/order"
+	"server/game/mod/quest"
+	"server/msg"
+	"server/pkg/github.com/name5566/leaf/log"
+	"time"
+)
 
 func UnitEndlessReward(p *Player) error {
 	EndlessMod := p.PlayMod.getEndlessMod()
 	if EndlessMod == nil {
 		return fmt.Errorf("EndlessMod is nil")
 	}
-	Item, err := EndlessMod.GetReward()
+	BaseMod := p.PlayMod.getBaseMod()
+	Item, err := EndlessMod.GetReward(BaseMod.GetLevel())
 	if err != nil {
 		return err
 	}
 	if Item == nil {
 		return fmt.Errorf("item is nil")
 	}
-	err = p.HandleItem(Item, "Endless")
+	err = p.HandleItem(Item, msg.ITEM_POP_LABEL_Endless.String())
 	if err != nil {
 		return err
 	}
@@ -23,20 +36,320 @@ func UnitEndlessReward(p *Player) error {
 
 func UnitChessShop(p *Player) error {
 	ChessMod := p.PlayMod.getChessMod()
-	if ChessMod == nil {
-		return fmt.Errorf("ChessMod is nil")
-	}
-	ChessMod.EmitList = make(map[int]int)
-	ChessMod.EmitList[83] = 1
-	ChessMod.EmitList[125] = 1
+
 	ChargeMod := p.PlayMod.getChargeMod()
-	if ChargeMod == nil {
-		return fmt.Errorf("ChargeMod is nil")
-	}
-	p.PlayMod.save()
-	p.PlayMod.ClearData(p)
-	ChargeMod.TriggerChargeUnlock(4, ChessMod.GetEmitList())
-	b := ChargeMod.BackData()
-	fmt.Println(b)
+	ChargeMod.InitChessShop(ChessMod.GetEmitList())
+	return nil
+}
+
+func UnitOrder(p *Player) error {
+	OrderMod := p.PlayMod.getOrderMod()
+	ChessMod := p.PlayMod.getChessMod()
+	BaseMod := p.PlayMod.getBaseMod()
+	//OrderMod.OrderList = make(map[int]order.Order)
+	for i := 0; i < 1000; i++ {
+		//OrderMod.ChessPool = nil
+		//OrderMod.EmitShuffle = nil
+		err := OrderMod.CreateNormalOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.Common_type)
+		if err != nil {
+			return err
+		}
+		for k, v := range OrderMod.OrderList {
+			if v.Type == order.Super_type {
+				continue
+			}
+			if len(v.Items) > 0 {
+				continue
+			}
+			if v.Diff == 0 {
+				continue
+			}
+			Star := order.GetOrderStar(v.MergeId, ChessMod.GetOrderEmit())
+			v.Items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, Star)}
+			OrderMod.OrderList[k] = v
+			fmt.Printf("OrderId %d, Diff %d, MergeId %v, Star %d\n", k, v.Diff, v.MergeId, Star)
+		}
+	}
+	NumMap := make(map[int]int)
+	for _, v := range OrderMod.OrderList {
+		NumMap[len(v.MergeId)]++
+	}
+	sum0 := 0
+	for _, v := range NumMap {
+		sum0 += v
+	}
+	for k, v := range NumMap {
+		fmt.Printf("棋子数量： %d, 占比： %.2f%% \n", k, float64(v)/float64(sum0)*100)
+	}
+	DiffMap := make(map[int]int)
+	for _, v := range OrderMod.OrderList {
+		DiffMap[v.Diff]++
+	}
+	sum := 0
+	for _, v := range DiffMap {
+		sum += v
+	}
+	for k, v := range DiffMap {
+		fmt.Printf("难度等级： %d, 占比： %.2f%% \n", k, float64(v)/float64(sum)*100)
+	}
+	AP := make(map[string]int, 0)
+	BP := make(map[string]int, 0)
+	for _, v := range OrderMod.OrderList {
+		for _, id := range v.MergeId {
+			Color := mergeDataCfg.GetColorById(id)
+			if Color == "Bath Toys" {
+				AP["Bath Toys"] += 1
+			}
+			if Color == "Cleaning Tools" {
+				AP["Cleaning Tools"] += 1
+			}
+			if Color == "Baby Toy" {
+				BP["Baby Toy"] += 1
+			}
+			if Color == "Books And Picture Books" {
+				BP["Books And Picture Books"] += 1
+			}
+		}
+	}
+	sum1 := 0
+	for _, v := range AP {
+		sum1 += v
+	}
+	sum2 := 0
+	for _, v := range BP {
+		sum2 += v
+	}
+	for k, v := range AP {
+		fmt.Printf("%s %.2f\n", k, float64(v)/float64(sum1)*100)
+	}
+	for k, v := range BP {
+		fmt.Printf("%s %.2f\n", k, float64(v)/float64(sum2)*100)
+	}
+	return nil
+}
+
+func UnitOrderSeed(player *Player) error {
+	start := time.Now()
+
+	BaseMod := player.PlayMod.getBaseMod()
+	BaseMod.Seed = true
+	TriggerSeedSource(player)
+	o := TriggerSeedOrder(player)
+	fmt.Println(o)
+
+	elapsed := time.Since(start)
+	fmt.Printf("UnitOrderSeed took %s\n", elapsed)
+	return nil
+}
+
+func UnitChess(p *Player) error {
+	CardMod := p.PlayMod.getCardMod()
+	for i := 0; i < 1000; i++ {
+		CardId := CardMod.RandCard(3)
+		fmt.Println(CardId)
+	}
+	return nil
+}
+
+func UnitDecorate(p *Player) error {
+	return nil
+}
+
+func UnitSevenMonthReward(p *Player) error {
+	ChargeMod := p.PlayMod.getChargeMod()
+	BaseMod := p.PlayMod.getBaseMod()
+	ChessMod := p.PlayMod.getChessMod()
+	ChargeMod.TriggerChargeUnlock(int(BaseMod.Level), ChessMod.GetEmitList())
+	return nil
+}
+
+func UnitAllCard(p *Player) error {
+	CardMod := p.PlayMod.getCardMod()
+	Item, err := CardMod.OpenCardPack(5)
+	if err != nil {
+		return err
+	}
+	fmt.Print(Item)
+	return nil
+}
+
+func UnitLimitProgress(p *Player) error {
+	LimitedTimeEventMod := p.PlayMod.getLimitedTimeEventMod()
+	LimitedTimeEventMod.Progress = 5
+	LimitedTimeEventMod.ZeroUpdate(7)
+	LimitedTimeEventMod.AddProgress(6)
+	return nil
+}
+
+func UnitLimitedTimeEvent(p *Player) error {
+	LimitedTimeEventMod := p.PlayMod.getLimitedTimeEventMod()
+
+	mergeList := []int{246, 15}
+	AddItem := LimitedTimeEventMod.GetChestReward(mergeList)
+	fmt.Print(AddItem)
+	return nil
+}
+
+func UnitCard(p *Player) error {
+	CardMod := p.PlayMod.getCardMod()
+	for i := 0; i < 10000; i++ {
+		CardMod.OpenCardPack(5)
+	}
+	return nil
+}
+func UnitOrder1(p *Player, Lv, EnergyMul int) ([]string, [][]float64) {
+	// ChessMod := p.PlayMod.getChessMod()
+	// Emit := ChessMod.GetEmitList()
+	// OrderMod := p.PlayMod.getOrderMod()
+	// OrderMod.LastDiff = 1
+	// OrderMod.OrderList = make(map[int]order.Order)
+	// // ChessMod := p.PlayMod.getChessMod()
+	// // EmitList := ChessMod.GetEmitList()
+	// // fmt.Println(EmitList)
+	// OrderMod.Debug = make(map[int]int)
+	// for i := 0; i < 5000; i++ {
+	// 	err := OrderMod.CreateNormalOrder(Lv, Emit, EnergyMul)
+	// 	log.Debug("OrderMod.CreateNormalOrder %d", i)
+	// 	if err != nil {
+	// 		return nil, nil
+	// 	}
+	// }
+	// I := make(map[int]int)
+	// for k, v := range OrderMod.Debug {
+	// 	// fmt.Printf("chessId %d, num %d\n", k, v)
+	// 	ChessLv := mergeDataCfg.GetLvById(k)
+	// 	I[ChessLv] += v
+	// }
+	// keys := make([]int, 0, len(I))
+	// Sum := 0
+	// for k, v := range I {
+	// 	Sum += v
+	// 	keys = append(keys, k)
+	// }
+	// sort.Ints(keys)
+	// xValue := make([]string, 0)
+	// yValue := make([][]float64, 0)
+	// line := make([]float64, 0)
+	// for _, k := range keys {
+	// 	xValue = append(xValue, fmt.Sprintf("Lv %d", k))
+	// 	line = append(line, float64(I[k])/float64(Sum)*100)
+	// 	fmt.Printf("Lv %d, num %.2f %%\n", k, float64(I[k])/float64(Sum)*100)
+	// }
+	// yValue = append(yValue, line)
+	// return xValue, yValue
+	return nil, nil
+}
+
+func UnitOrder2(p *Player, Lv, EnergyMul int) float64 {
+	ChessMod := p.PlayMod.getChessMod()
+	Emit := ChessMod.GetEmitList()
+	OrderMod := p.PlayMod.getOrderMod()
+	OrderMod.LastDiff = 1
+	OrderMod.OrderList = make(map[int]order.Order)
+	// ChessMod := p.PlayMod.getChessMod()
+	// EmitList := ChessMod.GetEmitList()
+	// fmt.Println(EmitList)
+	// OrderMod.Debug = make(map[int]int)
+	for i := 0; i < 5000; i++ {
+		err := OrderMod.CreateNormalOrder(Lv, Emit, EnergyMul, order.Common_type)
+		log.Debug("OrderMod.CreateNormalOrder %d", i)
+		if err != nil {
+			return 0
+		}
+	}
+	Energy := 0.0
+	for _, v := range OrderMod.OrderList {
+		for _, v1 := range v.MergeId {
+			Color := mergeDataCfg.GetColorById(v1)
+			Lv := mergeDataCfg.GetLvById(v1)
+			EmitId := order.GetEmitByColor(Emit, Color)
+			AdjustLv := mergeDataCfg.GetAdjust(EmitId, Color)
+			Energy += math.Pow(2, float64(Lv-1+AdjustLv))
+		}
+	}
+	return Energy / float64(5000)
+}
+
+func UnitChess1(p *Player) error {
+	ChessMod := p.PlayMod.getChessMod()
+	p.PushClientRes(ChessMod.BackData())
+	EmitRetireTrigger1(p)
+	DailyTaskMod := p.PlayMod.getDailyTaskMod()
+	p.PushClientRes(DailyTaskMod.BackData())
+	return nil
+}
+
+func UnitPlayroom(p *Player) error {
+	//PlayroomMod := p.PlayMod.getPlayroomMod()
+	//PlayroomMod.UnLock(15)
+	PlayroomBackData(p)
+	return nil
+}
+
+func UnitDailyTask(p *Player) error {
+	FT := p.PlayMod.getFriendTreasureMod()
+	FT.ZeroUpdate()
+	return nil
+}
+
+func UnitTriggerMail(p *Player) error {
+	p.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_UPLV})
+	p.ProcessTrigger()
+	return nil
+}
+
+func UnitPlayroomOrder(p *Player) error {
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	PlayroomMod.CreateOrderReward(100, p.PlayMod.getItemMod())
+	return nil
+}
+
+func UnitPetOrder(p *Player) error {
+	p.CreateNormalOrder()
+	ChessMod := p.PlayMod.getChessMod()
+	DecorateMod := p.PlayMod.getDecorateMod()
+	OrderFactor := orderCfg.GetOrderFactor(DecorateMod.GetAreaId())
+	Star := order.GetOrderStar([]int{305}, ChessMod.GetStarEmitList())
+	a := int(float64(Star)*float64(OrderFactor)/1000+0.5) * 10
+	fmt.Print(a)
+	return nil
+}
+
+func UnitDecoratePartCost(p *Player) error {
+	p.LoginBackData()
+	DecorateMod := p.PlayMod.getDecorateMod()
+	DecorateMod.AreaId = 3
+	DecorateMod.PartCost = make(map[int]*decorate.PartCostInfo)
+	DecorateMod.PartClassPool = []int{}
+	DecorateMod.PartPool = make(map[int]int)
+	DecorateMod.InitData()
+	Items, _, _ := DecorateMod.GetDecorateCostItem(1, 33)
+	err := p.HandleLoseItem(Items, "")
+	if err != nil {
+		fmt.Print(err)
+	}
+	return nil
+	ChessMod := p.PlayMod.getChessMod()
+	return ChessMod.PutPartInBag(1515)
+}
+
+func UnitOrderTrigger(p *Player) error {
+	OrderMod := p.PlayMod.getOrderMod()
+	BaseMod := p.PlayMod.getBaseMod()
+	Lv := int(BaseMod.Level)
+	ChessMod := p.PlayMod.getChessMod()
+	Emit := ChessMod.GetEmitList()
+	EnergyMul := BaseMod.GetEnergyMul()
+	OrderMod.TriggerOrder(Lv, order.TRIGGER_TYPE_ORDER, Emit, EnergyMul)
+	order.GetOrderStar([]int{1146}, ChessMod.GetOrderEmit())
+	return nil
+}
+
+func UnitOrderExtra(p *Player) error {
+	OrderMod := p.PlayMod.getOrderMod()
+	BaseMod := p.PlayMod.getBaseMod()
+	ChessMod := p.PlayMod.getChessMod()
+	Update := OrderMod.CreateExtraOrder([]int{25}, nil, ChessMod.GetUnlockChessList(), BaseMod.GetEnergyMul(), BaseMod.GetLevel())
+	fmt.Print(Update)
 	return nil
 }

src/server/game/VarMgr.go

@@ -0,0 +1,122 @@
+package game
+
+import (
+	"encoding/gob"
+	"server/GoUtil"
+	"server/game/mod/card"
+	"server/game/mod/msg"
+	"time"
+)
+
+type VarMgr struct {
+	*ServerMod
+}
+
+type VarData struct {
+	Var       map[string]interface{}
+	VarExpire map[string]*VarExpireData
+	UserVar   map[string]*VarUserData
+	ZeroTime  int64
+}
+
+const (
+	VAR_GOLD_CARD       = "gold_card"
+	VAR_PLAYROOM_UPVOTE = "playroom_upvote"
+	VAR_USER_DATA       = "user_data"
+)
+
+const (
+	VAR_OP_UPVOTE      = 1
+	VAR_OP_CHIP        = 2
+	VAR_OP_KISS        = 3
+	VAR_OP_CHIP_SET    = 4
+	VAR_OP_CATNIP_LOCK = 5
+)
+
+func (f *VarMgr) Init() {
+	gob.Register(&VarGoldCard{})
+	f.key = VAR_MGR_KEY
+	f.data = &VarData{
+		Var: map[string]interface{}{},
+	}
+	// 注册处理函数
+	f.init()
+	if f.data.(*VarData).Var == nil {
+		f.data.(*VarData).Var = make(map[string]interface{})
+	}
+	if f.data.(*VarData).UserVar == nil {
+		f.data.(*VarData).UserVar = make(map[string]*VarUserData)
+	}
+	if f.getData().ZeroTime == GoUtil.ZeroTimestamp() {
+		f.ZeroUpdate(&msg.Msg{})
+	}
+	f.RegisterHandler(msg.SERVER_ZERO_UPDATE, f.ZeroUpdate)
+
+	f.mDispatr.AfterFunc(time.Duration(GoUtil.NextZeroTimestampDuration())*time.Second, func() {
+		f.Send(&msg.Msg{
+			Type: msg.SERVER_ZERO_UPDATE,
+		})
+	})
+}
+
+func (f *VarMgr) SetGlobalData(m *msg.Msg) (interface{}, error) {
+	return nil, nil
+}
+
+func (f *VarMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {
+	f.getData().ZeroTime = GoUtil.ZeroTimestamp()
+	// 随机生成两个金卡
+	Card1, Card2 := card.RankGoldCard()
+	f.SetVar(VAR_GOLD_CARD, &VarGoldCard{
+		Four: Card1,
+		Five: Card2,
+	})
+	for k, v := range f.getData().VarExpire {
+		if v.T < GoUtil.ZeroTimestamp() {
+			delete(f.getData().VarExpire, k)
+		}
+	}
+	return nil, nil
+}
+
+func (f *VarMgr) SetVar(key string, value interface{}) {
+	f.getData().Var[key] = value
+}
+
+func (f *VarMgr) GetVar(key string) interface{} {
+	return f.getData().Var[key]
+}
+
+func (f *VarMgr) SetExpireVar(key string, value *VarExpireData) {
+	f.getData().VarExpire[key] = value
+}
+
+func (f *VarMgr) GetExpireVar(key string) *VarExpireData {
+	if v, ok := f.getData().VarExpire[key]; ok {
+		return v
+	}
+	data := &VarExpireData{}
+	f.getData().VarExpire[key] = data
+	return data
+}
+
+func (f *VarMgr) SetUserVar(key string, value *VarUserData) {
+	f.getData().UserVar[key] = value
+}
+
+func (f *VarMgr) GetUserVar(key string) *VarUserData {
+	if v, ok := f.getData().UserVar[key]; ok {
+		return v
+	}
+	data := &VarUserData{}
+	f.getData().UserVar[key] = data
+	return data
+}
+
+func (f *VarMgr) DelVar(key string) {
+	delete(f.getData().Var, key)
+}
+
+func (f *VarMgr) getData() *VarData {
+	return f.data.(*VarData)
+}

src/server/game/admin.go

@@ -0,0 +1,244 @@
+package game
+
+import (
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"server/GoUtil"
+	"server/MergeConst"
+	"server/conf"
+	"server/db"
+	Msg "server/game/mod/msg"
+	"server/gamedata"
+	"server/msg"
+	"server/pkg/github.com/name5566/leaf/gate"
+	"server/pkg/github.com/name5566/leaf/log"
+	"time"
+
+	"github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/mem"
+	"google.golang.org/protobuf/proto"
+)
+
+var AdminFuncMap = map[string]func([]interface{}) error{
+	"ReqAdminInfo":        AdminPlayerInfo,
+	"ReqServerInfo":       ReqServerInfo,
+	"ReqReloadServerMail": ReqReloadServerMail,
+	"ReqReload":           ReqReload,
+	"ReqAdminGm":          ReqAdminGm,
+	"ReqAdminBan":         ReqAdminBan,
+}
+
+func AdminProcess(Func string, args []interface{}) {
+	defer func() {
+		if r := recover(); r != nil {
+			GoUtil.SendFeishuFatal(0, Func, fmt.Sprintf("fatal : %s", r))
+		}
+	}()
+	if f, ok := AdminFuncMap[Func]; ok {
+		err := f(args)
+		if err != nil {
+			log.Debug("AdminProcess error: %v", err)
+		}
+		return
+	}
+	log.Debug("AdminProcess error: %v", "Func not found")
+}
+
+func VerifyUser(accountInfo *db.Db_Account, detail *msg.ReqLogin) (ResLogin *msg.ResLogin) {
+	if detail.Type == msg.LOGIN_TYPE_CODE_LOGIN {
+		err := VerifyCode(detail.UserName, detail.Code)
+		if err != nil {
+			ResLogin = &msg.ResLogin{
+				ResultCode: MergeConst.Protocol_Error_Account_Code_Error,
+				DwUin:      0,
+			}
+			return
+		}
+	}
+	if accountInfo == nil {
+		ResLogin = &msg.ResLogin{
+			ResultCode: MergeConst.Protocol_Error_Account_NoExsit,
+			DwUin:      0,
+		}
+		return
+	}
+	if detail.Type == msg.LOGIN_TYPE_ACCOUNT_LOGIN && accountInfo.UserPassword != detail.UserPwd {
+		ResLogin = &msg.ResLogin{
+			ResultCode: MergeConst.Protocol_Error_Account_OR_PWD_ERROR,
+			DwUin:      0,
+		}
+		return
+	}
+	if detail.Type == msg.LOGIN_TYPE_DEVICE_LOGIN {
+		if detail.Device != accountInfo.DeviceId {
+			ResLogin = &msg.ResLogin{
+				ResultCode: MergeConst.Protocol_Error_Account_Device_Error,
+				DwUin:      0,
+			}
+			return
+		}
+	}
+	playerbaseinfo := db.GetPlayerBaseInfoFromDbByName(detail.UserName)
+	if playerbaseinfo == nil {
+		ResLogin = &msg.ResLogin{
+			ResultCode: MergeConst.Protocol_Error_Account_NoExsit,
+			DwUin:      0,
+		}
+		return
+	}
+
+	if G_GameLogicPtr.BanMgr.IsBanned(playerbaseinfo.DwUin) {
+		ResLogin = &msg.ResLogin{
+			ResultCode: MergeConst.Protocol_Error_Account_Ban,
+			DwUin:      0,
+		}
+		return
+	}
+
+	ResLogin = &msg.ResLogin{
+		ResultCode: 0,
+		DwUin:      playerbaseinfo.DwUin,
+		FaceBookId: playerbaseinfo.FaceBookId,
+		UserName:   playerbaseinfo.UserName,
+	}
+	return
+}
+
+func AdminPlayerInfo(args []interface{}) error {
+	a, buf := ParseAdminArgs(args)
+	req := &msg.ReqAdminInfo{}
+	proto.Unmarshal(buf, req)
+	player := G_GameLogicPtr.GetPlayer(req.Uid)
+	online := true
+	if player == nil {
+		player = new(Player)
+		player.M_DwUin = req.Uid
+		player.InitPlayerOnly()
+		player.ZeroUpdate(nil)
+		online = false
+	}
+	res := make(map[string]interface{})
+	res["Name"] = player.PlayMod.getBaseMod().NickName
+	res["Uid"] = player.M_DwUin
+	res["AreaId"] = player.PlayMod.getDecorateMod().GetAreaId()
+	res["Charge"] = player.PlayMod.getChargeMod().Charge
+	res["Level"] = player.GetPlayerBaseMod().GetLevel()
+	res["Diamond"] = player.GetPlayerBaseMod().GetDiamond()
+	res["Star"] = player.GetPlayerBaseMod().GetStar()
+	res["Energy"] = player.GetPlayerBaseMod().GetEnergy()
+	res["Diamond"] = player.GetPlayerBaseMod().GetDiamond()
+	res["Mac"] = player.GetPlayerBaseMod().GetName()
+	res["Login"] = player.PlayMod.getBaseMod().LoginTime
+	res["Cumulative"] = player.PlayMod.getBaseMod().Cumulative
+	res["RegisterTime"] = player.GetPlayerBaseMod().GetRegisterTime()
+	res["TodayCumulative"] = player.PlayMod.getBaseMod().TodayCumulative
+	res["Ban"] = G_GameLogicPtr.BanMgr.GetBanInfo(player.M_DwUin).EndTime
+	if online {
+		res["Cumulative"] = int64(player.PlayMod.getBaseMod().Cumulative) + GoUtil.Now() - int64(player.PlayMod.getBaseMod().LoginTime)
+		res["TodayCumulative"] = int64(player.PlayMod.getBaseMod().TodayCumulative) + GoUtil.Now() - int64(player.PlayMod.getBaseMod().LoginTime)
+	}
+	res["Bonus"] = player.PlayMod.getLimitedTimeEventMod().Progress
+	res["Code"] = player.PlayMod.getBaseMod().AddCode
+	OrderMap := make(map[int]interface{})
+	Index := 0
+	for k, v := range player.PlayMod.getOrderMod().OrderList {
+		OrderMap[Index] = map[string]interface{}{
+			"Id":      k,
+			"Type":    v.Type,
+			"Time":    v.Timestamp,
+			"ChessId": GoUtil.IntSliceToString(v.MergeId),
+			"Diff":    v.Diff,
+		}
+		Index++
+	}
+	res["Order"] = OrderMap
+	AdminPlayerBack(a, res)
+	return nil
+}
+
+func AdminPlayerBack(a gate.Agent, res map[string]interface{}) {
+	JsonBuff, _ := json.Marshal(res)
+	response := &msg.AdminRes{}
+	response.Func = "admin"
+	response.Info = JsonBuff
+	a.WriteMsg(response)
+}
+
+func ReqServerInfo(args []interface{}) error {
+	a, _ := ParseAdminArgs(args)
+	res := make(map[string]interface{})
+	res["PlayerNum"] = G_GameLogicPtr.GetPlayerNum()
+	res["StartTime"] = G_GameLogicPtr.GetStartTime()
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	res["TotalAlloc"] = fmt.Sprintf("%dM", m.TotalAlloc/(1024*1024))
+	// 2. 获取系统内存使用信息
+	vmStat, err := mem.VirtualMemory()
+	if err == nil {
+		res["Sys"] = fmt.Sprintf("%.2f%%", vmStat.UsedPercent)
+	}
+	// 3. 获取 CPU 使用率（一秒内采样）
+	cpuPercent, err := cpu.Percent(time.Second, false)
+	if err == nil && len(cpuPercent) > 0 {
+		res["CPU"] = fmt.Sprintf("%.2f%%", cpuPercent[0])
+	}
+	res["Version"] = conf.Server.Version
+	AdminPlayerBack(a, res)
+	return nil
+}
+
+func ReqReloadServerMail(args []interface{}) error {
+	G_GameLogicPtr.MailMgrCall(&Msg.Msg{Type: Msg.HANDLE_TYPE_MAIL_RELOAD})
+	G_GameLogicPtr.NotifyAll(&Msg.Msg{Type: Msg.HANDLE_TYPE_MAIL})
+	log.Debug("ReqReloadServerMail success")
+	return nil
+}
+
+func ReqReload(args []interface{}) error {
+	a, _ := ParseAdminArgs(args)
+	gamedata.Reload()
+	res := make(map[string]interface{})
+	res["Code"] = 0
+	AdminPlayerBack(a, res)
+	return nil
+}
+
+func ReqAdminGm(args []interface{}) error {
+	a, buf := ParseAdminArgs(args)
+	req := &msg.ReqAdminGm{}
+	proto.Unmarshal(buf, req)
+	res := make(map[string]interface{})
+	res["Code"] = 0
+	res["Msg"] = "ok"
+	player := G_GameLogicPtr.GetPlayer(req.Uid)
+	if player == nil {
+		res["Code"] = 1
+		res["Msg"] = "player not found"
+		AdminPlayerBack(a, res)
+		return nil
+	}
+	player.lock.Lock()
+	defer player.lock.Unlock()
+	err := ReqGmCommand_(player, req.Command)
+	if err != nil {
+		res["Code"] = 1
+		res["Msg"] = err.Error()
+		AdminPlayerBack(a, res)
+		return err
+	}
+	AdminPlayerBack(a, res)
+	return nil
+}
+
+func ReqAdminBan(args []interface{}) error {
+	a, buf := ParseAdminArgs(args)
+	req := &msg.ReqAdminBan{}
+	proto.Unmarshal(buf, req)
+	res := make(map[string]interface{})
+	res["Code"] = 0
+	res["Msg"] = "ok"
+	G_GameLogicPtr.BanMgr.BanUser(req.Uid, int64(req.Time), req.Reason)
+	AdminPlayerBack(a, res)
+	return nil
+}

src/server/game/common.go

@@ -22,6 +22,13 @@ func ParseArgs(args []interface{}) (gate.Agent, *Player, []byte) {
 	return a, player, buf
 }
 
+// 解析参数
+func ParseAdminArgs(args []interface{}) (gate.Agent, []byte) {
+	a := args[0].(gate.Agent)
+	buf := args[1].([]byte)
+	return a, buf
+}
+
 // 获取结构体名称
 func GetStructName(v interface{}) string {
 	t := reflect.TypeOf(v)