Merge branch 'develop' into machine

# Conflicts:
#	gamerule/clawdoll/constants.go
#	gamesrv/action/action_machine.go
#	gamesrv/clawdoll/player_clawdoll.go
#	gamesrv/clawdoll/scene_clawdoll.go
#	gamesrv/clawdoll/scenepolicy_clawdoll.go
#	protocol/clawdoll/clawdoll.pb.go
#	protocol/clawdoll/clawdoll.proto
#	public

.gitignore

@@ -6,6 +6,8 @@
 # Folders
 _obj
 _test
+/bin/*
+**/backup
 
 # Architecture specific extensions/prefixes
 *.[568vq]
@@ -18,6 +20,7 @@ _cgo_gotypes.go
 _cgo_export.*
 
 _testmain.go
+tools/xlsx2binary/agc.go
 
 *.exe
 *.exe~
@@ -35,11 +38,8 @@ _testmain.go
 /dbproxy/dbproxy
 /mgrsrv/mgrsrv
 /gatesrv/gatesrv
-/gamesrv/gamesrv
 /worldsrv/worldsrv
+/gamesrv/gamesrv
 /robot/robot
-/schedulesrv/schedulesrv
 /ranksrv/ranksrv
-
-/bin/*
-**/backup
+/schedulesrv/schedulesrv

README.md

@@ -29,9 +29,6 @@ update_public.sh
 
 #### gen_go.bat
     proto文件生成go文件
-    
-#### gen_web.bat
-    proto文件生成go文件
 
 #### build.bat
     生成可执行文件

build-sub.bat

@@ -1,13 +0,0 @@
-@echo off
-
-echo Build %1 task!
-
-cd %1
-go fmt
-go vet
-go build -v
-echo errorlevel:%errorlevel%
-if "%errorlevel%"=="0" exit
-if not "%errorlevel%"=="0" echo %1 build failed!
-pause
-exit

build.bat

@@ -1,30 +1,9 @@
 go env -w GO111MODULE=off
-@echo "go fmt common..."
-cd common
-go fmt
 
-@echo "go fmt api3th..."
-cd ../api3th
-go fmt
+@echo off
 
-@echo "go fmt model..."
-cd ../model
-go fmt
+call shell/build.bat
 
-@echo "go fmt webapi..."
-cd ../webapi
-go fmt
-
-@echo "go fmt lib complete!"
-
-cd ..
-start build-sub.bat dbproxy
-start build-sub.bat mgrsrv
-start build-sub.bat gatesrv
-start build-sub.bat worldsrv
-start build-sub.bat gamesrv
-start build-sub.bat robot
-start build-sub.bat ranksrv
-
-@echo "Wait all build task complete!"
+echo "Wait all build task complete!"
 pause
+

build_linux.bat

@@ -1,10 +1,14 @@
 set CGO_ENABLED=0
 set GOOS=linux
 set GOARCH=amd64
-
 go env -w GO111MODULE=off
 
-build.bat
+@echo off
 
-@echo "complete"
-pause
+call shell/build.bat
+
+echo "Wait all build task complete!"
+
+if %errorcode% neq 0 (
+    pause
+)

build_mac.bat

@@ -1,10 +0,0 @@
-set CGO_ENABLED=0
-set GOOS=darwin
-set GOARCH=amd64
-
-go env -w GO111MODULE=off
-
-build.bat
-
-@echo "complete"
-pause

common/action.go

@@ -19,10 +19,6 @@ var ActionMgrSington = &ActionMgr{
 	pool: make(map[int]ActionBase),
 }
 
-func init() {
-
-}
-
 type ActionMgr struct {
 	pool map[int]ActionBase
 }

common/constant.go

@@ -67,13 +67,13 @@ const (
 	GameID_ThirteenFree                   = 213 // 十三张（自由场经典场）
 	GameID_ThirteenFreeLaiZi              = 214 // 十三张（自由场癞子场）
 	__GameId_Slot_Min__                   = 300 //################拉霸类################
-	GameId_CaiShen                        = 301 //财神
-	GameId_Avengers                       = 302 //复仇者联盟
-	GameId_EasterIsland                   = 303 //复活岛
-	GameId_IceAge                         = 304 //冰河世纪
-	GameId_TamQuoc                        = 305 //百战成神
-	GameId_Fruits                         = 306 //水果拉霸
-	GameId_Richblessed                    = 307 //多福多财
+	GameId_CaiShen                        = 301 // 财神
+	GameId_Avengers                       = 302 // 复仇者联盟
+	GameId_EasterIsland                   = 303 // 复活岛
+	GameId_IceAge                         = 304 // 冰河世纪
+	GameId_TamQuoc                        = 305 // 百战成神
+	GameId_Fruits                         = 306 // 水果拉霸
+	GameId_Richblessed                    = 307 // 多福多财
 	__GameId_Fishing_Min__                = 400 //################捕鱼类################
 	GameId_HFishing                       = 401 //欢乐捕鱼
 	GameId_TFishing                       = 402 //天天捕鱼
@@ -86,28 +86,27 @@ const (
 	GameId_CaoThap                        = 605 //CaoThap
 	GameId_AngerUncle                     = 606 // 愤怒大叔
 	GameId_SmallRoket                     = 607 // 小火箭
+	GameId_Clawdoll                       = 608 // 娃娃机
 	__GameId_ThrGame_Min__                = 700 //################三方类################
 	GameId_Thr_Dg                         = 701 //DG Game
 	GameId_Thr_XHJ                        = 901 //DG Game
 )
 
-// IsTienLen TienLen游戏
-func IsTienLen(gameId int) bool {
-	return InSliceInt32(GetTienlenGameID(), int32(gameId))
-}
-
-func GetTienlenGameID() []int32 {
-	//todo 还要维护游戏id,好麻烦，还容易忘
-	return []int32{
-		GameId_TienLen, GameId_TienLen_yl,
-		GameId_TienLen_toend, GameId_TienLen_yl_toend,
-		GameId_TienLen_m, GameId_TienLen_m_toend,
-		GameId_TienLenSelect, GameId_TienLenSelect_toend,
-		GameId_TienLenSelect_yl, GameId_TienLenSelect_yl_toend,
-		GameId_TienLenRank, GameId_TienLenRank_toend,
-		GameId_TienLenRank_yl, GameId_TienLenRank_yl_toend,
-	}
-}
+const (
+	GameDifTienlen     = "207" // tienlen
+	GameDifThirteen    = "211" // 十三张
+	GameDifChess       = "521" // 象棋
+	GameDifFish        = "401" // 捕鱼
+	GameDifRocket      = "607" // 小火箭
+	GameDifCaiShen     = "301" // 财神
+	GameDifAvengers    = "302" // 复仇者联盟
+	GameDifEaster      = "303" // 复活节岛
+	GameDifIceAge      = "304" // 冰河世纪
+	GameDifTamQuoc     = "305" // 百战成神
+	GameDifFruits      = "306" // 水果机
+	GameDifRichblessed = "307" // 多彩多福
+	GameDifClawdoll    = "608" // 娃娃机
+)
 
 // IsTienLenYuLe TienLen娱乐
 func IsTienLenYuLe(gameId int) bool {
@@ -138,39 +137,6 @@ func IsTienLenToEnd(gameId int) bool {
 	return false
 }
 
-// IsChess 象棋游戏
-func IsChess(gameId int) bool {
-	switch gameId {
-	case GameId_Chesstitians,
-		GameId_ChesstitiansMakruk,
-		GameId_ChesstitiansCambodian,
-		GameId_ChesstitiansCambodianRobot:
-		return true
-	}
-	return false
-}
-
-// IsThirteen 十三张游戏
-func IsThirteen(gameId int) bool {
-	switch gameId {
-	case GameID_Thirteen4,
-		GameID_Thirteen8,
-		GameID_ThirteenFree,
-		GameID_ThirteenFreeLaiZi:
-		return true
-	}
-	return false
-}
-
-// IsThirteen 十三张游戏
-func IsSmallRocket(gameId int) bool {
-	switch gameId {
-	case GameId_SmallRoket:
-		return true
-	}
-	return false
-}
-
 // IsLocalGame 自动分场模式的游戏
 // 根据 DB_Createroom.xlsx 给玩家分场或创建房间
 func IsLocalGame(gameId int) bool {
@@ -185,9 +151,11 @@ func IsLocalGame(gameId int) bool {
 	return false
 }
 
-// IsPlayerPool 需要统计在个人水池的游戏
-func IsPlayerPool(gameId int) bool {
-	if IsTienLen(gameId) || IsThirteen(gameId) {
+func IsDaZhong(gameId int) bool {
+	switch gameId {
+	case GameId_TienLenSelect,
+		GameId_TienLenSelect_yl, GameId_TienLenSelect_toend,
+		GameId_TienLenSelect_yl_toend:
 		return true
 	}
 	return false
@@ -212,30 +180,12 @@ const (
 
 // 房间模式
 const (
-	SceneMode_Public  = iota //公共房间
-	SceneMode_Club           //俱乐部房间
-	SceneMode_Private        //私人房间
-	SceneMode_Match          //赛事房间
-	SceneMode_Thr            //三方房间
+	SceneMode_Public  = 0 //公共房间
+	SceneMode_Private = 2 //私人房间
+	SceneMode_Match   = 3 //赛事房间
+	SceneMode_Thr     = 4 //三方房间
 )
 
-// 场景级别
-//const (
-//	SceneLvl_Test       = -1 // 试玩场(不要钱)
-//	SceneLvl_Experience = 0  // 体验场(花小钱)
-//	SceneLvl_Primary    = 1  // 初级场
-//	SceneLvl_Middle     = 2  // 中级场
-//	SceneLvl_Senior     = 3  // 高级场
-//	SceneLvl_Professor  = 4  // 专家场
-//)
-
-// 房费选项
-//const (
-//	RoomFee_Owner int32 = iota //房主
-//	RoomFee_AA                 //AA
-//	RoomFee_Max
-//)
-
 const (
 	Platform_Rob     = "__$G_P$__"
 	Platform_Sys     = "0"
@@ -248,71 +198,109 @@ const (
 )
 
 const (
-	GainWay_NewPlayer             int32 = 0  //0.新建角色
-	GainWay_Pay                         = 1  //1.后台增加(主要是充值)
-	GainWay_ByPMCmd                     = 2  //2.pm命令
-	GainWay_MatchBreakBack              = 3  //3.退赛退还
-	GainWay_MatchSystemSupply           = 4  //4.比赛奖励
-	GainWay_Exchange                    = 5  //5.兑换
-	GainWay_ServiceFee                  = 6  //6.桌费
-	GainWay_CoinSceneWin                = 7  //7.金豆场赢取
-	GainWay_CoinSceneLost               = 8  //8.金豆场输
-	GainWay_CoinSceneEnter              = 9  //9.进入金币场预扣
-	GainWay_ShopBuy                     = 10 //10.商城购买或者兑换
-	GainWay_CoinSceneLeave              = 11 //11.金豆场回兑
-	GainWay_HundredSceneWin             = 12 //12.万人场赢取
-	GainWay_HundredSceneLost            = 13 //13.万人场输
-	GainWay_MessageAttach               = 14 //14.邮件
-	GainWay_SafeBoxSave                 = 15 //15.保险箱存入
-	GainWay_SafeBoxTakeOut              = 16 //16.保险箱取出
-	GainWay_Fishing                     = 17 //17.捕鱼
-	GainWay_CoinSceneExchange           = 18 //18.金豆场兑换
-	GainWay_UpgradeAccount              = 19 //19.升级账号
-	GainWay_API_AddCoin                 = 20 //20.API操作钱包
-	GainWay_GoldCome                    = 21 //21.财神降临
-	GainWay_Transfer_System2Thrid       = 22 //22.系统平台转入到第三方平台的金币
-	GainWay_Transfer_Thrid2System       = 23 //23.第三方平台转入到系统平台的金币
-	GainWay_RebateTask                  = 24 //24.返利获取
-	GainWay_IOSINSTALLSTABLE            = 25 //25.ios安装奖励
-	GainWay_VirtualChange               = 26 //26.德州虚拟账变
-	GainWay_CreatePrivateScene          = 27 //27.创建私有房间
-	GainWay_PrivateSceneReturn          = 28 //28.解散私有房间返还
-	GainWay_OnlineRandCoin              = 29 //29.红包雨
-	GainWay_Expire                      = 30 //30.到期清理
-	GainWay_PromoterBind                = 31 //31.手动绑定推广员
-	GainWay_GradeShopReturn             = 32 //32.积分商城撤单退还积分
-	GainWay_Api_In                      = 33 //33.转移金币
-	GainWay_Api_Out                     = 34 //34.转移金币
-	GainWay_Shop_Buy                    = 35 //35.购买记录
-	GainWay_MAIL_MTEM                   = 36 //36.邮件领取道具
-	GainWay_Item_Sale                   = 37 //37.道具出售
-	GainWay_ReliefFund                  = 38 //38.领取救济金
-	GainWay_Shop_Revoke                 = 39 //39.撤单
-	GainWay_ActSign                     = 40 //40.签到
-	GainWay_MatchSignup                 = 41 //比赛报名费用
-	GainWay_MatchSeason                 = 42 //比赛赛季奖励
-	GainWay_ActSignNew                  = 43 //43.新签到
-	GainWay_ActTurnplate                = 44 //44.轮盘
-	GainWay_ActBlindBox                 = 45 //45.盲盒
-	GainWay_ActFirstPay                 = 46 //46.首充
-	GainWay_VIPGift                     = 47 //47.vip礼包
-	GainWay_ActContinuousPay            = 48 //48.连续充值
-	GainWay_ActJybAward                 = 49 //49.礼包码兑换
-	GainWay_LeaveDeduct                 = 50 //50.离开扣分
-	GainWay_LeaveCombat                 = 51 //51.离开补偿
-	GainWay_RankMatch                   = 52 //52.排位赛段位奖励
-	GainWay_AddBag                      = 53 //53 增加背包接口调用
-	GainWay_SmallRocket                 = 54 //54.小火箭收入
-	GainWay_BindTel                     = 55 //55.绑定手机号
-	GainWay_ReliefFund2                 = 56 //56.救济金看视频双倍领取
-	GainWay_ActTurnplate2               = 57 //57.轮盘看视频双倍领取
-	GainWay_ActSignNew2                 = 58 //58.签到看视频双倍领取
-	GainWay_ItemUse                     = 59 //59.道具使用
-	GainWay_PhoneScore                  = 60 //60.积分抽奖活动
-	GainWay_RankReward                  = 61 //61.段位奖励
-	GainWay_TaskReward                  = 62 //62.任务奖励
-	GainWay_Interact                    = 63 //63.房间内互动效果
-	GainWay_Collect                     = 64 //64.集卡活动
+	GainWay_NewPlayer             int32 = 0   //新建角色
+	GainWay_Pay                         = 1   //后台增加(主要是充值)
+	GainWay_ByPMCmd                     = 2   //pm命令
+	GainWay_MatchBreakBack              = 3   //退赛退还
+	GainWay_MatchSystemSupply           = 4   //比赛奖励
+	GainWay_Exchange                    = 5   //兑换
+	GainWay_ServiceFee                  = 6   //桌费
+	GainWay_CoinSceneWin                = 7   //金豆场赢取
+	GainWay_CoinSceneLost               = 8   //金豆场输
+	GainWay_CoinSceneEnter              = 9   //进入金币场预扣
+	GainWay_ShopBuy                     = 10  //商城购买或者兑换
+	GainWay_CoinSceneLeave              = 11  //金豆场回兑
+	GainWay_HundredSceneWin             = 12  //万人场赢取
+	GainWay_HundredSceneLost            = 13  //万人场输
+	GainWay_MessageAttach               = 14  //邮件
+	GainWay_SafeBoxSave                 = 15  //保险箱存入
+	GainWay_SafeBoxTakeOut              = 16  //保险箱取出
+	GainWay_Fishing                     = 17  //捕鱼
+	GainWay_CoinSceneExchange           = 18  //金豆场兑换
+	GainWay_UpgradeAccount              = 19  //升级账号
+	GainWay_API_AddCoin                 = 20  //API操作钱包
+	GainWay_GoldCome                    = 21  //财神降临
+	GainWay_Transfer_System2Thrid       = 22  //系统平台转入到第三方平台的金币
+	GainWay_Transfer_Thrid2System       = 23  //第三方平台转入到系统平台的金币
+	GainWay_RebateTask                  = 24  //返利获取
+	GainWay_IOSINSTALLSTABLE            = 25  //ios安装奖励
+	GainWay_VirtualChange               = 26  //德州虚拟账变
+	GainWay_CreatePrivateScene          = 27  //创建私有房间
+	GainWay_PrivateSceneReturn          = 28  //解散私有房间返还
+	GainWay_OnlineRandCoin              = 29  //红包雨
+	GainWay_Expire                      = 30  //到期清理
+	GainWay_PromoterBind                = 31  //手动绑定推广员
+	GainWay_GradeShopReturn             = 32  //积分商城撤单退还积分
+	GainWay_Api_In                      = 33  //转移金币
+	GainWay_Api_Out                     = 34  //转移金币
+	GainWay_Shop_Buy                    = 35  //购买记录
+	GainWay_MAIL_MTEM                   = 36  //邮件领取道具
+	GainWay_Item_Sale                   = 37  //道具出售
+	GainWay_ReliefFund                  = 38  //领取救济金
+	GainWay_Shop_Revoke                 = 39  //撤单
+	GainWay_ActSign                     = 40  //
+	GainWay_MatchSignup                 = 41  //比赛报名费用
+	GainWay_MatchSeason                 = 42  //比赛赛季奖励
+	GainWay_ActSignNew                  = 43  //新签到
+	GainWay_ActTurnplate                = 44  //轮盘
+	GainWay_ActBlindBox                 = 45  //盲盒
+	GainWay_ActFirstPay                 = 46  //首充
+	GainWay_VIPGift                     = 47  //vip礼包
+	GainWay_ActContinuousPay            = 48  //连续充值
+	GainWay_ActJybAward                 = 49  //礼包码兑换
+	GainWay_LeaveDeduct                 = 50  //离开扣分
+	GainWay_LeaveCombat                 = 51  //离开补偿
+	GainWay_RankMatch                   = 52  //排位赛段位奖励
+	GainWay_AddBag                      = 53  //增加背包接口调用
+	GainWay_SmallRocket                 = 54  //小火箭收入
+	GainWay_BindTel                     = 55  //绑定手机号
+	GainWay_ReliefFund2                 = 56  //救济金看视频双倍领取
+	GainWay_ActTurnplate2               = 57  //轮盘看视频双倍领取
+	GainWay_ActSignNew2                 = 58  //签到看视频双倍领取
+	GainWay_ItemUse                     = 59  //道具使用
+	GainWay_PhoneScore                  = 60  //手机积分活动
+	GainWay_RankReward                  = 61  //排位奖励
+	GainWay_TaskReward                  = 62  //任务奖励
+	GainWay_Interact                    = 63  //房间内互动效果
+	GainWayItemCollectExchange          = 64  //集卡活动兑换
+	GainWay_WeekCardAward               = 65  //周卡奖励
+	GainWay_PigrankTakeCoin             = 66  //存钱罐领取耗费钻石
+	GainWay_PigrankGainCoin             = 67  //存钱罐打开获取金币
+	GainWay_ItemMove                    = 68  //道具赠送
+	GainWay_RoleUpgrade                 = 69  //角色升级
+	GainWay_PetUpgrade                  = 70  //宠物升级
+	GainWay_Game                        = 71  //游戏掉落
+	GainWayItemCollectLogin             = 73  //集卡活动登录
+	GainWay_Collect                     = 74  //集卡活动
+	GainWayItemPhoneScoreExchange       = 75  //抽手机活动兑换
+	GainWayItemTaskInvite               = 78  //邀请任务
+	GainWayItemTaskNewPlayer            = 79  //新手任务
+	GainWayItemTaskAchievement          = 80  //成就任务
+	GainWayItemTaskEveryDay             = 81  //每日任务
+	GainWayItemWeekActive               = 82  //周活跃奖励
+	GainWayContinueSign                 = 83  //累计签到
+	GainWayBackend                      = 84  // 后台操作
+	GainWayBuyCoin                      = 85  // 商城购买金币
+	GainWayBuyItem                      = 86  // 商城购买道具
+	GainWayBuyWeekCard                  = 87  // 商城购买周卡
+	GainWayVipBuyCoin                   = 88  // vip商城购买金币
+	GainWaySign7Con                     = 89  // 累计签到进阶奖励消耗
+	GainWay_PigrankGainDiamond          = 90  //存钱罐打开获取钻石
+	GainWaySign7Add                     = 91  // 累计签到进阶奖励获得
+	GainWayItemChange                   = 92  //背包内使用道具兑换话费
+	GainWayPetSkillLevelUp              = 93  //宠物技能升级
+	GainWayPermitAward                  = 94  // 赛季通行证等级奖励
+	GainWayItemPermitRank               = 95  // 赛季通行证排行奖励
+	GainWayPermitExchangeCost           = 96  // 赛季通行证兑换消耗
+	GainWayPermitExchangeGain           = 97  // 赛季通行证兑换获得
+	GainWayItemTaskPermit               = 98  // 赛季通行证任务
+	GainWayDiamondLottery               = 99  //钻石抽奖
+	GainWaySkinUnLock                   = 100 // 皮肤解锁消耗
+	GainWaySkinUpGrade                  = 101 // 皮肤升级消耗
+	GainWayItemFen                      = 102 // 道具分解消耗
+	GainWayItemFenGain                  = 103 // 道具分解获得
+	GainWayGuide                        = 104 //新手引导奖励
+	GainWayVipGift9                     = 105 //vip等级礼包
 )
 
 // 后台选择 金币变化类型 的充值 类型id号起始
@@ -612,6 +600,16 @@ const (
 	ItemIDWeekScore  = 100004 // 周活跃积分
 	ItemIDGiftBox    = 50001  // 碎片礼盒
 	ItemIDCollectBox = 50002  // 集卡礼盒
+	ItemIDLike       = 100007 // 点赞
+	ItemIDCoffee     = 100008 // 咖啡
+	ItemIDBucket     = 100009 // 水桶
+	ItemIDSlippers   = 100010 // 拖鞋
+	ItemIDPermit     = 100011 // 赛季通行证积分
+	ItemIDLong       = 50013  // 龙币
+	ItemIDPetSkill   = 11001  //宠物技能升级道具
+	ItemIDVCard      = 30001  // v卡
+	ItemIDJCard      = 30002  // 金券
+	ItemDiamondScore = 100012 //钻石积分
 )
 
 func ToItemId(id int32) int32 {
@@ -638,6 +636,10 @@ const (
 	ItemTypeVipExp             = 10 //VIP经验
 	ItemTypeShopScore          = 11 //积分
 	ItemTypeInteract           = 12 // 互动表情
+	ItemTypeExpireTime         = 15 // 时效类道具
+	ItemTypeObjective          = 16 // 目标类道具
+	ItemTypeChange             = 17 // 兑换话费
+	ItemTypeSkinChip           = 22 // 皮肤碎片
 )
 
 func GetKeyNoviceGameId(gameId int) string {
@@ -687,23 +689,37 @@ const (
 
 // 活动，任务类型
 const (
-	TaskTypeAdv             = 1  // 看广告次数
-	TaskTypeBuyCoin         = 2  // 买金币次数
-	TaskTypeLogin           = 3  // 登录次数
-	TaskTypeWinTimes        = 4  // 赢游戏次数
-	TaskTypePlayTimes       = 5  // 玩游戏次数
-	TaskTypeRankMatchTimes  = 6  // 排位赛次数
-	TaskTypePay             = 7  // 充值金额
-	TaskTypeWinOrLose       = 8  // 游戏输赢金币数量
-	TaskTypeTienlenCount    = 9  // tienlen游戏场次
-	TaskTypeBindInviter     = 10 // 绑定邀请人数量
-	TaskTypeWinCoin         = 11 // 赢取金币数量
-	TaskTypeTienlenWinTimes = 12 // tienlen游戏赢取次数
-	TaskTypeInviteScore     = 13 // 邀请积分
-	TaskTypeActivityScore   = 14 // 周活跃积分数量
-	TaskTypeFirstLogin      = 15 // 每日首次登录
-	TaskTypeInviteNum       = 16 // 邀请绑定数量
-	TaskTypeTurnplate       = 17 // 转盘抽奖次数
+	TaskTypeAdv               = 1  // 看广告次数
+	TaskTypeBuyCoin           = 2  // 买金币次数
+	TaskTypeLogin             = 3  // 登录次数
+	TaskTypeWinTimes          = 4  // 赢游戏次数
+	TaskTypePlayTimes         = 5  // 玩游戏次数
+	TaskTypeRankMatchTimes    = 6  // 排位赛次数
+	TaskTypePay               = 7  // 充值金额
+	TaskTypeWinOrLose         = 8  // 游戏输赢金币数量
+	TaskTypeTienlenCount      = 9  // tienlen游戏场次
+	TaskTypeBindInviter       = 10 // 绑定邀请人数量*
+	TaskTypeWinCoin           = 11 // 赢取金币数量
+	TaskTypeTienlenWinTimes   = 12 // tienlen游戏赢取次数
+	TaskTypeInviteScore       = 13 // 邀请积分*
+	TaskTypeActivityScore     = 14 // 周活跃积分数量
+	TaskTypeFirstLogin        = 15 // 每日首次登录
+	TaskTypeInviteNum         = 16 // 邀请绑定数量*
+	TaskTypeTurnplate         = 17 // 转盘抽奖次数
+	TaskTypeInviteRecharge    = 18 // 被邀请人充值金额*
+	TaskTypeLoseCoin          = 19 // 输的金币数量
+	TaskType20                = 20 // 未使用
+	TaskTypeOnlineTs          = 21 // 在线时长，秒
+	TaskTypeBuyPig            = 22 // 购买任意存钱罐
+	TaskTypeDaZhong           = 23 // 大众场胜利
+	TaskTypeInvitePlay        = 24 // 邀请好友私人桌对局
+	TaskTypeJoinMatch         = 25 // 参与比赛场
+	TaskTypeMatchRank10       = 26 // 比赛场前10名
+	TaskTypeCostDiamond       = 27 // 消耗钻石数量
+	TaskTypeTienlenLoseCoin   = 28 // Tienlen输的金币数量
+	TaskTypeTienlenWinCoin    = 29 // Tienlen赢取金币数量
+	TaskTypeRankMatchWinTimes = 30 // 排位胜利次数
+	TaskTypeBuyPermit         = 31 // 购买典藏通行证
 )
 
 const (
@@ -714,26 +730,25 @@ const (
 )
 
 const (
-	TaskActivityTypeEveryDay = 1 // 每日任务
-	TaskActivityTypeWeek     = 2 // 每周任务
-	TaskActivityTypeNovice   = 3 // 新手任务
-	TaskActivityTypeInvite   = 4 // 邀请任务
+	TaskActivityTypeEveryDay       = 1 // 每日任务
+	TaskActivityTypeWeek           = 2 // 每周任务
+	TaskActivityTypeNovice         = 3 // 新手任务
+	TaskActivityTypeInvite         = 4 // 邀请任务
+	TaskActivityTypeAchieve        = 5 // 成就任务
+	TaskActivityTypePermitEveryDay = 6 // 赛季通行证每日任务
+	TaskActivityTypePermit         = 7 // 赛季通行证任务
 )
 
 const HeadRange = 3 // 机器人头像id范围
 
 const (
-	InviteScoreTypeBind      = 1 // 绑定邀请码
-	InviteScoreTypeLogin     = 2 // 每日登录
-	InviteScoreTypePlayTimes = 3 // 每日参与任意游戏
-	InviteScoreTypeRecharge  = 4 // 充值
-	InviteScoreTypeGameTimes = 5 // 每局游戏
+	InviteScoreCheckWeek    = -1 // 跨周
+	InviteScoreTypeBind     = 1  // 绑定邀请码
+	InviteScoreTypePay      = 2  // 充值
+	InviteScoreTypeRecharge = 3  // 充值完成
+	InviteScoreTypePayMe    = 4  // 充值（给自己）
 )
 
-const TaskIDInvitePlayGame = 1000001
-const TaskIDInviteRecharge = 1000002
-const TaskIDInviteFirstLogin = 1000003
-
 func InMatchChannel(ls []string, n string) bool {
 	if n == "" || len(ls) == 0 {
 		return false
@@ -782,3 +797,59 @@ const (
 )
 
 var PetIDs = []int32{PetIDChicken}
+
+const (
+	ChannelSwitchExchange       = 1 // 兑换商城开关
+	ChannelSwitchDropItem       = 2 // v卡掉落开关
+	ChannelSwitchInvite         = 3 // 邀请开关
+	ChannelSwitchPermit         = 4 // 典藏通行证开关
+	ChannelSwitchDiamondLottery = 5 // 钻石抽奖开关
+)
+
+// 特殊商品id
+const (
+	ShopIdWeekCard = 970001 // 周卡
+	ShopIdPermit   = 990001 // 典藏通行证
+)
+
+const PermitStartTsKey = "permit_start_ts"
+
+const PermitAdd = 0.2 // 典藏通行证赛季积分多加，百分比
+
+const (
+	SkinGetAuto = 1
+	SkinGetItem = 2
+	SkinGetVip  = 3
+)
+
+const (
+	SkillIdRankScore      = 30002 // 排位积分加成百分比
+	SkillIdVipTimes       = 30003 // VIP赛每日免费报名次数
+	SkillIdVipGift        = 30004 // VIP每日礼包金币奖励提升百分比
+	SkillIdTask           = 30005 // 每日任务金币奖励提升百分比
+	SkillIdDiamondLottery = 30007 // 每次钻石抽奖幸运值提升百分比
+)
+
+var (
+	SkinRandom    = []int32{300001, 300002, 300007, 300006, 300005, 300004, 300003}
+	SkinWeightMap = map[int32]int{
+		300001: 20,
+		300002: 40,
+		300007: 40,
+		300006: 50,
+		300005: 40,
+		300004: 60,
+		300003: 70,
+	}
+)
+
+const (
+	AttributeGuideStep = 1 // 引导步骤
+	AttributeGuideSkip = 2 // 跳过引导
+	AttributeGuideTest = 3 // 测试引导
+)
+
+const (
+	On  = 1 // 开启
+	Off = 2 // 关闭
+)

common/esayfunc.go

@@ -95,17 +95,9 @@ func GetIntegerBit(num int32, index int32) bool {
 }
 
 // 校验身份证是否合法
-var IDReg, _ = regexp.Compile(`(^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$)|(^[1-9]\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{2}$)`)
-var REGEXP_IPRule, _ = regexp.Compile(`^(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|[1-9])\.(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)$`)
+var REGEXP_IPRule, _ = regexp.Compile(`^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$|^([\da-fA-F]{1,4}:){6}((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$|^::([\da-fA-F]{1,4}:){0,4}((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$|^([\da-fA-F]{1,4}:):([\da-fA-F]{1,4}:){0,3}((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$|^([\da-fA-F]{1,4}:){2}:([\da-fA-F]{1,4}:){0,2}((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$|^([\da-fA-F]{1,4}:){3}:([\da-fA-F]{1,4}:){0,1}((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$|^([\da-fA-F]{1,4}:){4}:((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$|^([\da-fA-F]{1,4}:){7}[\da-fA-F]{1,4}$|^:((:[\da-fA-F]{1,4}){1,6}|:)$|^[\da-fA-F]{1,4}:((:[\da-fA-F]{1,4}){1,5}|:)$|^([\da-fA-F]{1,4}:){2}((:[\da-fA-F]{1,4}){1,4}|:)$|^([\da-fA-F]{1,4}:){3}((:[\da-fA-F]{1,4}){1,3}|:)$|^([\da-fA-F]{1,4}:){4}((:[\da-fA-F]{1,4}){1,2}|:)$|^([\da-fA-F]{1,4}:){5}:([\da-fA-F]{1,4})?$|^([\da-fA-F]{1,4}:){6}:$`)
 var ClubNameRule, _ = regexp.Compile("^[\u4e00-\u9fa5a-zA-Z-z0-9]+$")
 
-func IsValidID(id string) bool {
-	if IDReg != nil {
-		return IDReg.Match([]byte(id))
-	}
-	return false
-}
-
 func IsValidIP(Ip string) bool {
 	const UNKNOWIP = "0.0.0.0"
 	if Ip == "" || Ip == UNKNOWIP {

common/handler.go

@@ -19,6 +19,8 @@ func (hw HandlerWrapper) Process(s *netlib.Session, packetid int, data interface
 	return hw(s, packetid, data, sid)
 }
 
+// RegisterHandler 消息注册
+// Deprecated: use [common.Register] instead
 func RegisterHandler(packetId int, h Handler) {
 	if _, ok := handlers[packetId]; ok {
 		panic(fmt.Sprintf("repeate register handler: %v Handler type=%v", packetId, reflect.TypeOf(h)))
@@ -36,7 +38,11 @@ func GetHandler(packetId int) Handler {
 }
 
 func Register(mainId int, msgType interface{}, h func(s *netlib.Session, packetId int, data interface{}, sid int64) error) {
-	RegisterHandler(mainId, HandlerWrapper(h))
+	if _, ok := handlers[mainId]; ok {
+		panic(fmt.Sprintf("repeate register handler: %v Handler type=%v", mainId, reflect.TypeOf(h)))
+	}
+	handlers[mainId] = HandlerWrapper(h)
+
 	f := func() interface{} {
 		tp := reflect.TypeOf(msgType)
 		if tp.Kind() == reflect.Ptr {

common/log.go

@@ -5,13 +5,12 @@ import (
 	"path/filepath"
 
 	"github.com/howeyc/fsnotify"
+
 	"mongo.games.com/goserver/core"
 	"mongo.games.com/goserver/core/basic"
 	"mongo.games.com/goserver/core/logger"
 )
 
-var LastModifyConfig int64
-
 func init() {
 	core.RegisteHook(core.HOOK_BEFORE_START, func() error {
 		var err error
@@ -62,7 +61,7 @@ type loggerParamModifiedCommand struct {
 }
 
 func (lmc *loggerParamModifiedCommand) Done(o *basic.Object) error {
-	logger.Logger.Info("===reload ", lmc.fileName)
+	logger.Logger.Info("reload logger.xml:", lmc.fileName)
 	data, err := os.ReadFile(lmc.fileName)
 	if err != nil {
 		return err
@@ -70,7 +69,7 @@ func (lmc *loggerParamModifiedCommand) Done(o *basic.Object) error {
 	if len(data) != 0 {
 		err = logger.Reload(lmc.fileName)
 		if err != nil {
-			logger.Logger.Warn("===reload ", lmc.fileName, err)
+			logger.Logger.Warnf("reload logger.xml %v err: %v", lmc.fileName, err)
 		}
 	}
 	return err

common/slice.go

@@ -40,6 +40,18 @@ func CopySliceIntToInt32(s []int) []int32 {
 	return nil
 }
 
+func CopySliceInt64ToInt32(s []int64) []int32 {
+	n := len(s)
+	if n != 0 {
+		temp := make([]int32, n)
+		for i := 0; i < n; i++ {
+			temp[i] = int32(s[i])
+		}
+		return temp
+	}
+	return nil
+}
+
 func CopySliceInt32ToInt(s []int32) []int {
 	n := len(s)
 	if n != 0 {

common/time.go

@@ -76,17 +76,15 @@ func InSameWeek(tNow, tPre time.Time) bool {
 		return true
 	}
 
-	preYear, preWeek := tPre.ISOWeek()
-	nowYear, nowWeek := tNow.ISOWeek()
-	if preYear == nowYear && preWeek == nowWeek {
+	if GetWeekStartTs(tNow.Unix()) == GetWeekStartTs(tPre.Unix()) {
 		return true
 	}
 	return false
 }
 
 func TsInSameWeek(tsNow, tsPre int64) bool {
-	tNow := time.Unix(tsNow, 0)
-	tPre := time.Unix(tsPre, 0)
+	tNow := time.Unix(tsNow, 0).Local()
+	tPre := time.Unix(tsPre, 0).Local()
 	return InSameWeek(tNow, tPre)
 }
 
@@ -143,3 +141,44 @@ func InTimeRange(beginHour, beginMinute, endHour, endMinute, checkHour, checkMin
 	checkTime := checkHour*100 + checkMinute
 	return beginTime <= checkTime && checkTime <= endTime
 }
+
+// GetWeekStartTs 获取本周开始的时间戳,周一为周的开始
+func GetWeekStartTs(ts int64) int64 {
+	now := time.Unix(ts, 0).Local()
+	year, month, day := now.Date()
+	today := time.Date(year, month, day, 0, 0, 0, 0, time.Local)
+	n := today.Weekday()
+	if today.Weekday() == 0 {
+		n = 7
+	}
+	st := today.AddDate(0, 0, -int(n-1)).Unix()
+	return st
+}
+
+func GetDayStartTs(ts int64) int64 {
+	now := time.Unix(ts, 0).Local()
+	year, month, day := now.Date()
+	today := time.Date(year, month, day, 0, 0, 0, 0, time.Local)
+	return today.Unix()
+}
+
+func GetDayNextStartTs(ts int64) int64 {
+	return GetDayStartTs(ts) + 86400
+}
+
+func GetMonthTimestamp() []int64 {
+	now := time.Now().Local()
+	year, month, _ := now.Date()
+	// 本月起始日期
+	st := time.Date(year, month, 1, 0, 0, 0, 0, time.Local).Unix()
+	// 计算下个月的年和月
+	if month == time.December {
+		year = year + 1
+		month = time.January
+	} else {
+		month = month + 1
+	}
+	// 构建下个月的第一天的时间
+	et := time.Date(year, month, 1, 0, 0, 0, 0, now.Location()).Unix()
+	return []int64{st, et}
+}

data/DB_CollectBox.dat

@@ -1,16 +1,15 @@
 
-

ъ
У†

-
ъ
Ф†

-
ъ
Х†

-
ъ
Ц†

-
ъ
Ч†

-
И
Ш†

-
И
Щ†

-
И
Ъ†

-
	И
Ы†

+

иУ†

+
иФ†

+
иХ†

+
иЦ†

+
ЮЧ†

+2Ш†

+2Щ†

+2Ъ†

+	2Ы†

 
-
-Ь†

-
2ЎЌђN
-¬ЎЌР†
-
2ЎЌ Ќ
+
Ь†

+фЎЌђN
+dЎЌР†
+
ЎЌ Ќ

data/DB_CollectBox.json

@@ -2,91 +2,91 @@
 	"Arr": [
 		{
 			"Id": 1,
-			"Rate": 250,
+			"Rate": 1000,
 			"ItemID": {
 				"50003": 1
 			}
 		},
 		{
 			"Id": 2,
-			"Rate": 250,
+			"Rate": 1000,
 			"ItemID": {
 				"50004": 1
 			}
 		},
 		{
 			"Id": 3,
-			"Rate": 250,
+			"Rate": 1000,
 			"ItemID": {
 				"50005": 1
 			}
 		},
 		{
 			"Id": 4,
-			"Rate": 250,
+			"Rate": 1000,
 			"ItemID": {
 				"50006": 1
 			}
 		},
 		{
 			"Id": 5,
-			"Rate": 250,
+			"Rate": 350,
 			"ItemID": {
 				"50007": 1
 			}
 		},
 		{
 			"Id": 6,
-			"Rate": 200,
+			"Rate": 50,
 			"ItemID": {
 				"50008": 1
 			}
 		},
 		{
 			"Id": 7,
-			"Rate": 200,
+			"Rate": 50,
 			"ItemID": {
 				"50009": 1
 			}
 		},
 		{
 			"Id": 8,
-			"Rate": 200,
+			"Rate": 50,
 			"ItemID": {
 				"50010": 1
 			}
 		},
 		{
 			"Id": 9,
-			"Rate": 200,
+			"Rate": 50,
 			"ItemID": {
 				"50011": 1
 			}
 		},
 		{
 			"Id": 10,
-			"Rate": 10,
+			"Rate": 1,
 			"ItemID": {
 				"50012": 1
 			}
 		},
 		{
 			"Id": 11,
-			"Rate": 50,
+			"Rate": 500,
 			"ItemID": {
 				"100001": 10000
 			}
 		},
 		{
 			"Id": 12,
-			"Rate": 300,
+			"Rate": 100,
 			"ItemID": {
 				"100001": 50000
 			}
 		},
 		{
 			"Id": 13,
-			"Rate": 50,
+			"Rate": 20,
 			"ItemID": {
 				"100001": 100000
 			}

data/DB_DiamondLottery.dat

@@ -0,0 +1,17 @@
+
+

红米手机 æÑ(

+
金å¸<C3A5> ¡<>( Â0Þ
+
酷帕碎片 ¡œ
(
0ï
+
积分 ¬<>(20Þ
+!
2å…ƒè¯<C3A8>费直兑券 ¹ê
(
0,
+
金å¸<C3A5> ¡<>(€­â0X
+
魔法师碎片 £œ
(
0°

+
哈奴曼啤酒 ©º(
0
+	
积分 ¬<>(d0ï
+
+
è<>¶å¥³ç¢Žç‰‡ ¢œ
(
0Þ
+
钻石 ¢<>(0Þ
+!
5å…ƒè¯<C3A8>费直兑券 ºê
(
0
+

钻石 ¢<>(0¸
+
积分 ¬<>(È
0¸
+1å…ƒè¯<C3A8>费直兑券 ¸ê
(

data/DB_DiamondLottery.json

@@ -0,0 +1,122 @@
+{
+	"Arr": [
+		{
+			"Id": 1,
+			"Type": 1,
+			"Name": "红米手机",
+			"Item_Id": 76006,
+			"Grade": 1
+		},
+		{
+			"Id": 2,
+			"Type": 1,
+			"Name": "金币",
+			"Item_Id": 100001,
+			"Grade": 500000,
+			"Oddrate": 1758
+		},
+		{
+			"Id": 3,
+			"Type": 1,
+			"Name": "酷帕碎片",
+			"Item_Id": 20001,
+			"Grade": 1,
+			"Oddrate": 879
+		},
+		{
+			"Id": 4,
+			"Type": 1,
+			"Name": "积分",
+			"Item_Id": 100012,
+			"Grade": 50,
+			"Oddrate": 1758
+		},
+		{
+			"Id": 5,
+			"Type": 1,
+			"Name": "2元话费直兑券",
+			"Item_Id": 30009,
+			"Grade": 1,
+			"Oddrate": 44
+		},
+		{
+			"Id": 6,
+			"Type": 1,
+			"Name": "金币",
+			"Item_Id": 100001,
+			"Grade": 10000000,
+			"Oddrate": 88
+		},
+		{
+			"Id": 7,
+			"Type": 1,
+			"Name": "魔法师碎片",
+			"Item_Id": 20003,
+			"Grade": 1,
+			"Oddrate": 176
+		},
+		{
+			"Id": 8,
+			"Type": 1,
+			"Name": "哈奴曼啤酒",
+			"Item_Id": 73001,
+			"Grade": 1,
+			"Oddrate": 5
+		},
+		{
+			"Id": 9,
+			"Type": 1,
+			"Name": "积分",
+			"Item_Id": 100012,
+			"Grade": 100,
+			"Oddrate": 879
+		},
+		{
+			"Id": 10,
+			"Type": 1,
+			"Name": "蝶女碎片",
+			"Item_Id": 20002,
+			"Grade": 1,
+			"Oddrate": 1758
+		},
+		{
+			"Id": 11,
+			"Type": 1,
+			"Name": "钻石",
+			"Item_Id": 100002,
+			"Grade": 5,
+			"Oddrate": 1758
+		},
+		{
+			"Id": 12,
+			"Type": 1,
+			"Name": "5元话费直兑券",
+			"Item_Id": 30010,
+			"Grade": 1,
+			"Oddrate": 17
+		},
+		{
+			"Id": 13,
+			"Type": 1,
+			"Name": "钻石",
+			"Item_Id": 100002,
+			"Grade": 20,
+			"Oddrate": 440
+		},
+		{
+			"Id": 14,
+			"Type": 1,
+			"Name": "积分",
+			"Item_Id": 100012,
+			"Grade": 200,
+			"Oddrate": 440
+		},
+		{
+			"Id": 15,
+			"Type": 2,
+			"Name": "1元话费直兑券",
+			"Item_Id": 30008,
+			"Grade": 1
+		}
+	]
+}

data/DB_GameCoinPool.dat

@@ -76,4 +76,30 @@
 9ѓр<D193>
<18>№ ПЕџџџџ
 <20><>пРJ(<28>ЈжЙ0d8 @<40>џџџџџџџџ
Hрљџџџџџџџ
P
 :єр<D194>
<18>АЄМ<D084>§џџџ
 <20>алУє(<28>ШЏ %0d8 @<40>џџџџџџџџ
Hрљџџџџџџџ
P
 ;ѕр<D195>
<18>№Е­Йёџџџ
 <20><>ЪвЦ(<28>шэЁК
0d8 @<40>џџџџџџџџ
Hрљџџџџџџџ
P
-;öà–
€À×µåÅÿÿÿ
 €À¨Êš:(€ ·‡é0d8 @œÿÿÿÿÿÿÿÿ
Hàùÿÿÿÿÿÿÿ
P
+;öà–
€À×µåÅÿÿÿ
 €À¨Êš:(€ ·‡é0d8 @œÿÿÿÿÿÿÿÿ
Hàùÿÿÿÿÿÿÿ
P
+ÑÛ·
€ŽÎ€áë €„¯_XÈ
`À¤ÿ
+ ÒÛ·
€Œ<E282AC>ž€Êµî
 €¨Ö¹XÈ
`€íøµ
+ ÓÛ·
€¼Á–€ò‹¨	 €È¯ %XÈ
`€¡Ü<C2A1>
+ ÔÛ·
€ø‚­€ä—Ð €<>ßÀJXÈ
`€Â¸›
+᩸
€ŽÎ€áë €„¯_XÈ
`À¤ÿ
+ ⩸
€Œ<E282AC>ž€Êµî
 €¨Ö¹XÈ
`€íøµ
+ 㩸
€¼Á–€ò‹¨	 €È¯ %XÈ
`€¡Ü<C2A1>
+ 䩸
€ø‚­€ä—Ð €<>ßÀJXÈ
`€Â¸›
+ñ÷¸
€ŽÎ€áë €„¯_XÈ
`À¤ÿ
+ ò÷¸
€Œ<E282AC>ž€Êµî
 €¨Ö¹XÈ
`€íøµ
+ ó÷¸
€¼Á–€ò‹¨	 €È¯ %XÈ
`€¡Ü<C2A1>
+ ô÷¸
€ø‚­€ä—Ð €<>ßÀJXÈ
`€Â¸›
+<08>ƹ
€ŽÎ€áë €¨Ö¹XÈ
`À¤ÿ
+ ‚ƹ
€¼Á–€ò‹¨	 €È¯ %XÈ
`€¡Ü<C2A1>
+ ƒÆ¹
€ø‚­€ä—Ð €<>ßÀJXÈ
`€Â¸›
+‘”º
€ŽÎ€áë €¨Ö¹XÈ
`À¤ÿ
+ ’”º
€¼Á–€ò‹¨	 €È¯ %XÈ
`€¡Ü<C2A1>
+ “”º
€ø‚­€ä—Ð €<>ßÀJXÈ
`€Â¸›
+¡âº
€›îÀ–± €ÚÄ	XÈ
` ÝŒ
+¢âº
€ŽÎ€áë €„¯_XÈ
`À¤ÿ
+£âº
€Æ†<C386>
€åšw €”ëÜXÈ
`À¶üš

+ ¤âº
€Œ<E282AC>ž€Êµî
 €¨Ö¹XÈ
`€íøµ
+±°»
€›îÀ–± €ÚÄ	XÈ
` ÝŒ
+²°»
€ŽÎ€áë €„¯_XÈ
`À¤ÿ
+³°»
€Æ†<C386>
€åšw €”ëÜXÈ
`À¶üš

+ ´°»
€Œ<E282AC>ž€Êµî
 €¨Ö¹XÈ
`€íøµ

data/DB_GameCoinPool.json

@@ -857,6 +857,214 @@
 			"LowerOdds": -100,
 			"LowerOddsMax": -800,
 			"ProfitRate": 20
+		},
+		{
+			"Id": 3010001,
+			"InitValue": 60000000,
+			"LowerLimit": 50000000,
+			"UpperLimit": 200000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 65000000
+		},
+		{
+			"Id": 3010002,
+			"InitValue": 600000000,
+			"LowerLimit": 500000000,
+			"UpperLimit": 2000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 650000000
+		},
+		{
+			"Id": 3010003,
+			"InitValue": 3000000000,
+			"LowerLimit": 2500000000,
+			"UpperLimit": 10000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 3250000000
+		},
+		{
+			"Id": 3010004,
+			"InitValue": 6000000000,
+			"LowerLimit": 5000000000,
+			"UpperLimit": 20000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 6500000000
+		},
+		{
+			"Id": 3020001,
+			"InitValue": 60000000,
+			"LowerLimit": 50000000,
+			"UpperLimit": 200000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 65000000
+		},
+		{
+			"Id": 3020002,
+			"InitValue": 600000000,
+			"LowerLimit": 500000000,
+			"UpperLimit": 2000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 650000000
+		},
+		{
+			"Id": 3020003,
+			"InitValue": 3000000000,
+			"LowerLimit": 2500000000,
+			"UpperLimit": 10000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 3250000000
+		},
+		{
+			"Id": 3020004,
+			"InitValue": 6000000000,
+			"LowerLimit": 5000000000,
+			"UpperLimit": 20000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 6500000000
+		},
+		{
+			"Id": 3030001,
+			"InitValue": 60000000,
+			"LowerLimit": 50000000,
+			"UpperLimit": 200000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 65000000
+		},
+		{
+			"Id": 3030002,
+			"InitValue": 600000000,
+			"LowerLimit": 500000000,
+			"UpperLimit": 2000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 650000000
+		},
+		{
+			"Id": 3030003,
+			"InitValue": 3000000000,
+			"LowerLimit": 2500000000,
+			"UpperLimit": 10000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 3250000000
+		},
+		{
+			"Id": 3030004,
+			"InitValue": 6000000000,
+			"LowerLimit": 5000000000,
+			"UpperLimit": 20000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 6500000000
+		},
+		{
+			"Id": 3040001,
+			"InitValue": 60000000,
+			"LowerLimit": 50000000,
+			"UpperLimit": 2000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 65000000
+		},
+		{
+			"Id": 3040002,
+			"InitValue": 3000000000,
+			"LowerLimit": 2500000000,
+			"UpperLimit": 10000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 3250000000
+		},
+		{
+			"Id": 3040003,
+			"InitValue": 6000000000,
+			"LowerLimit": 5000000000,
+			"UpperLimit": 20000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 6500000000
+		},
+		{
+			"Id": 3050001,
+			"InitValue": 60000000,
+			"LowerLimit": 50000000,
+			"UpperLimit": 2000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 65000000
+		},
+		{
+			"Id": 3050002,
+			"InitValue": 3000000000,
+			"LowerLimit": 2500000000,
+			"UpperLimit": 10000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 3250000000
+		},
+		{
+			"Id": 3050003,
+			"InitValue": 6000000000,
+			"LowerLimit": 5000000000,
+			"UpperLimit": 20000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 6500000000
+		},
+		{
+			"Id": 3060001,
+			"InitValue": 6000000,
+			"LowerLimit": 5000000,
+			"UpperLimit": 20000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 6500000
+		},
+		{
+			"Id": 3060002,
+			"InitValue": 60000000,
+			"LowerLimit": 50000000,
+			"UpperLimit": 200000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 65000000
+		},
+		{
+			"Id": 3060003,
+			"InitValue": 300000000,
+			"LowerLimit": 250000000,
+			"UpperLimit": 1000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 325000000
+		},
+		{
+			"Id": 3060004,
+			"InitValue": 600000000,
+			"LowerLimit": 500000000,
+			"UpperLimit": 2000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 650000000
+		},
+		{
+			"Id": 3070001,
+			"InitValue": 6000000,
+			"LowerLimit": 5000000,
+			"UpperLimit": 20000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 6500000
+		},
+		{
+			"Id": 3070002,
+			"InitValue": 60000000,
+			"LowerLimit": 50000000,
+			"UpperLimit": 200000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 65000000
+		},
+		{
+			"Id": 3070003,
+			"InitValue": 300000000,
+			"LowerLimit": 250000000,
+			"UpperLimit": 1000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 325000000
+		},
+		{
+			"Id": 3070004,
+			"InitValue": 600000000,
+			"LowerLimit": 500000000,
+			"UpperLimit": 2000000000,
+			"CtrlRate": 200,
+			"InitNovicValue": 650000000
 		}
 	]
 }

data/DB_GameRule.json

@@ -54,18 +54,6 @@
 			"GameId": 401,
 			"GameDif": "401"
 		},
-		{
-			"Id": 30600,
-			"Name": "水果拉霸",
-			"GameId": 306,
-			"GameDif": "306"
-		},
-		{
-			"Id": 30400,
-			"Name": "冰河世纪",
-			"GameId": 304,
-			"GameDif": "304"
-		},
 		{
 			"Id": 52100,
 			"Name": "ChessCambodian",
@@ -165,6 +153,54 @@
 			"Name": "小火箭",
 			"GameId": 607,
 			"GameDif": "607"
+		},
+		{
+			"Id": 60800,
+			"Name": "娃娃机",
+			"GameId": 608,
+			"GameDif": "608"
+		},
+		{
+			"Id": 30100,
+			"Name": "财运神",
+			"GameId": 301,
+			"GameDif": "301"
+		},
+		{
+			"Id": 30200,
+			"Name": "复仇者联盟",
+			"GameId": 302,
+			"GameDif": "302"
+		},
+		{
+			"Id": 30300,
+			"Name": "复活节岛",
+			"GameId": 303,
+			"GameDif": "303"
+		},
+		{
+			"Id": 30400,
+			"Name": "冰河世纪",
+			"GameId": 304,
+			"GameDif": "304"
+		},
+		{
+			"Id": 30500,
+			"Name": "百战成神",
+			"GameId": 305,
+			"GameDif": "305"
+		},
+		{
+			"Id": 30600,
+			"Name": "水果拉霸",
+			"GameId": 306,
+			"GameDif": "306"
+		},
+		{
+			"Id": 30700,
+			"Name": "多财多福",
+			"GameId": 307,
+			"GameDif": "307"
 		}
 	]
 }

data/DB_Game_Drop.dat

@@ -1,210 +1,55 @@
 
-
Я
а(Бъ
:


-Я
<18>'(Бъ
:


-Я
<18>N(Бъ
:


-Я
<18>u(Бъ
:


-Я
 <>
(Бъ
:


-Я
ЈУ
(Бъ
:


-Я
Аъ
(Бъ
:


-Я
И<>(Бъ
:


-	Я
РИ(Бъ
:


+
Ð ±ê
(2


+ˆ' ±ê
(12


+<10>N ±ê
(c2


+˜u ±ê
(•
2


+ œ
 ±ê
(Æ
2


+¨Ã
 ±ê
(÷
2


+°ê
 ±ê
(©2


+¸‘ ±ê
(Û2


+	À¸ ±ê
(Œ2


 
-Я
Шп(Бъ
:


-Я
а<>(Бъ
:


-Я
и­(Бъ
:


-
Я
рд(Бъ
:


-Я
шћ(Бъ
:


-Я
№Ђ(Бъ
:


-Я
јЩ(Бъ
:


-Я
<18>ё(Бъ
:


-Я
<18><>(Бъ
:


-Я
<18>П(Бъ
:


-Я
<18>ц(Бъ
:


-Я
 <>(Бъ
:


-Я
№<>	(Бъ
:


-Я
Р<>(Бъ
:


-Я
<18>Ё(Бъ
:


-Я
рЇ(Бъ
:

-Я
АЎ(Бъ
:

-Я
<18>Е(Бъ
:

-Я
аЛ(Бъ
:

-Я
 Т(Бъ
:
-Я
№Ш!(Бъ
:
-Я
РЯ$(Бъ
:
- Я
<18>ж'(Бъ
:
-!Я
рм*(Бъ
:
-"Я
Ау-(Бъ
:
-#Я
<18>ъ0(Бъ
:
-$Я
а№3(Бъ
:
-%Я
 ї6(Бъ
:
-&Я
№§9(Бъ
:
-'Я
Р<>=(Бъ
:
-(Я
<18><>z(Бъ
:
-
-)Я
Р<>Б(Бъ
:
-
-*Я
<18>­т(Бъ
:2
-+Я
РУ<D0A0>(Бъ
:2K
-,Я
<18>кФ	(Бъ
:Kd
--Я
Р№ѕ(Бъ
:d}
-.Я
<18><>Ї(Бъ
:}<7D>

-/Я
Р<>и(Бъ
:<04>
Џ

-0Я
<18>Д<EFBFBD>(Бъ
:Џ
Ш

-1Я
РЪК(Бъ
:Ш
с

-2Я
<18>сы(Бъ
:с
њ

-3а
а(Бъ
:


-4а
<18>'(Бъ
:


-5а
<18>N(Бъ
:


-6а
<18>u(Бъ
:


-7а
 <>
(Бъ
:


-8а
ЈУ
(Бъ
:


-9а
Аъ
(Бъ
:


-:а
И<>(Бъ
:


-;а
РИ(Бъ
:


-<а
Шп(Бъ
:


-=а
а<>(Бъ
:


->а
и­(Бъ
:


-?а
рд(Бъ
:


-@а
шћ(Бъ
:


-Aа
№Ђ(Бъ
:


-Bа
јЩ(Бъ
:


-Cа
<18>ё(Бъ
:


-Dа
<18><>(Бъ
:


-Eа
<18>П(Бъ
:


-Fа
<18>ц(Бъ
:


-Gа
 <>(Бъ
:


-Hа
№<>	(Бъ
:


-Iа
Р<>(Бъ
:


-Jа
<18>Ё(Бъ
:


-Kа
рЇ(Бъ
:

-Lа
АЎ(Бъ
:

-Mа
<18>Е(Бъ
:

-Nа
аЛ(Бъ
:

-Oа
 Т(Бъ
:
-Pа
№Ш!(Бъ
:
-Qа
РЯ$(Бъ
:
-Rа
<18>ж'(Бъ
:
-Sа
рм*(Бъ
:
-Tа
Ау-(Бъ
:
-Uа
<18>ъ0(Бъ
:
-Vа
а№3(Бъ
:
-Wа
 ї6(Бъ
:
-Xа
№§9(Бъ
:
-Yа
Р<>=(Бъ
:
-Zа
<18><>z(Бъ
:
-
-[а
Р<>Б(Бъ
:
-
-\а
<18>­т(Бъ
:2
-]а
РУ<D0A0>(Бъ
:2K
-^а
<18>кФ	(Бъ
:Kd
-_а
Р№ѕ(Бъ
:d}
-`а
<18><>Ї(Бъ
:}<7D>

-aа
Р<>и(Бъ
:<04>
Џ

-bа
<18>Д<EFBFBD>(Бъ
:Џ
Ш

-cа
РЪК(Бъ
:Ш
с

-dа
<18>сы(Бъ
:с
њ

-eб
а(Бъ
:


-fб
<18>'(Бъ
:


-gб
<18>N(Бъ
:


-hб
<18>u(Бъ
:


-iб
 <>
(Бъ
:


-jб
ЈУ
(Бъ
:


-kб
Аъ
(Бъ
:


-lб
И<>(Бъ
:


-mб
РИ(Бъ
:


-nб
Шп(Бъ
:


-oб
а<>(Бъ
:


-pб
и­(Бъ
:


-qб
рд(Бъ
:


-rб
шћ(Бъ
:


-sб
№Ђ(Бъ
:


-tб
јЩ(Бъ
:


-uб
<18>ё(Бъ
:


-vб
<18><>(Бъ
:


-wб
<18>П(Бъ
:


-xб
<18>ц(Бъ
:


-yб
 <>(Бъ
:


-zб
№<>	(Бъ
:


-{б
Р<>(Бъ
:


-|б
<18>Ё(Бъ
:


-}б
рЇ(Бъ
:

-~б
АЎ(Бъ
:

-б
<18>Е(Бъ
:

-<08>
б
аЛ(Бъ
:

-<08>
б
 Т(Бъ
:
-<08>
б
№Ш!(Бъ
:
-<08>
б
РЯ$(Бъ
:
-<08>
б
<18>ж'(Бъ
:
-<08>
б
рм*(Бъ
:
-<08>
б
Ау-(Бъ
:
-<08>
б
<18>ъ0(Бъ
:
-<08>
б
а№3(Бъ
:
-<08>
б
 ї6(Бъ
:
-<08>
б
№§9(Бъ
:
-<08>
б
Р<>=(Бъ
:
-<08>
б
<18><>z(Бъ
:
-
-<08>
б
Р<>Б(Бъ
:
-
-<08>
б
<18>­т(Бъ
:2
-<08>
б
РУ<D0A0>(Бъ
:2K
-<08>
б
<18>кФ	(Бъ
:Kd
-<08>
б
Р№ѕ(Бъ
:d}
-<08>
б
<18><>Ї(Бъ
:}<7D>

-<08>
б
Р<>и(Бъ
:<04>
Џ

-<08>
б
<18>Д<EFBFBD>(Бъ
:Џ
Ш

-<08>
б
РЪК(Бъ
:Ш
с

-<08>
б
<18>сы(Бъ
:с
њ

-<08>
в
а(Бъ
:


-<08>
в
<18>'(Бъ
:


-<08>
в
<18>N(Бъ
:


-<08>
в
<18>u(Бъ
:


-<08>
в
 <>
(Бъ
:


-<08>
в
ЈУ
(Бъ
:


-<08>
в
Аъ
(Бъ
:


-<08>
в
И<>(Бъ
:


-<08>
в
РИ(Бъ
:


- 
в
Шп(Бъ
:


-Ё
в
а<>(Бъ
:


-Ђ
в
и­(Бъ
:


-Ѓ
в
рд(Бъ
:


-Є
в
шћ(Бъ
:


-Ѕ
в
№Ђ(Бъ
:


-І
в
јЩ(Бъ
:


-Ї
в
<18>ё(Бъ
:


-Ј
в
<18><>(Бъ
:


-Љ
в
<18>П(Бъ
:


-Њ
в
<18>ц(Бъ
:


-Ћ
в
 <>(Бъ
:


-Ќ
в
№<>	(Бъ
:


-­
в
Р<>(Бъ
:


-Ў
в
<18>Ё(Бъ
:


-Џ
в
рЇ(Бъ
:

-А
в
АЎ(Бъ
:

-Б
в
<18>Е(Бъ
:

-В
в
аЛ(Бъ
:

-Г
в
 Т(Бъ
:
-Д
в
№Ш!(Бъ
:
-Е
в
РЯ$(Бъ
:
-Ж
в
<18>ж'(Бъ
:
-З
в
рм*(Бъ
:
-И
в
Ау-(Бъ
:
-Й
в
<18>ъ0(Бъ
:
-К
в
а№3(Бъ
:
-Л
в
 ї6(Бъ
:
-М
в
№§9(Бъ
:
-Н
в
Р<>=(Бъ
:
-О
в
<18><>z(Бъ
:
-
-П
в
Р<>Б(Бъ
:
-
-Р
в
<18>­т(Бъ
:2
-С
в
РУ<D0A0>(Бъ
:2K
-Т
в
<18>кФ	(Бъ
:Kd
-У
в
Р№ѕ(Бъ
:d}
-Ф
в
<18><>Ї(Бъ
:}<7D>

-Х
в
Р<>и(Бъ
:<04>
Џ

-Ц
в
<18>Д<EFBFBD>(Бъ
:Џ
Ш

-Ч
в
РЪК(Бъ
:Ш
с

-Ш
в
<18>сы(Бъ
:с
њ

+Èß ±ê
(½2


+І ±ê
(ï2


+Ø­ ±ê
(¡2


+
àÔ ±ê
(Ò2


+èû ±ê
(ƒ2


+𢠱ê
(µ2


+øÉ ±ê
(ç2


+€ñ ±ê
(˜2


+ˆ˜ ±ê
(É2


+<10>¿ ±ê
(û2


+˜æ ±ê
(­2


+ <> ±ê
(Þ2


+ð“	 ±ê
(Í2


+Àš ±ê
(¼2


+<10>¡ ±ê
(«2


+ৠ±ê
(š2


+°® ±ê
(‰2


+€µ ±ê
(ø2


+л ±ê
(ç"2


+ Â ±ê
(Ö&2


+ðÈ! ±ê
(Å*2


+ÀÏ$ ±ê
(´.2


+ <10>Ö' ±ê
(£22


+!àÜ* ±ê
(ë32


+"°ã- ±ê
(³52


+#€ê0 ±ê
(û62


+$Ðð3 ±ê
(Ã82


+% ÷6 ±ê
(‹:2


+&ðý9 ±ê
(Ó;2


+'À„= ±ê
(›=2


+(€‰z ±ê
(ã>2

+)À–± ±ê
(«@2
+*€­â ±ê
(<28>N2
++ÀÓ ±ê
(<28>N2
+,€ÚÄ	 ±ê
(<28>N2
+-Àðõ ±ê
(<28>N2
+.€‡§ ±ê
(<28>N2$
+/À<>Ø ±ê
(<28>N2$*
+0€´‰ ±ê
(<28>N2)0
+1Àʺ ±ê
(<28>N2.6
+2€áë ±ê
(<28>N23<
+3€Â×/ ±ê
(<28>N2e{
+4€£ÃG ±ê
(<28>N2–
¤

+5€„¯_ ±ê
(<28>N2Ç
ö

data/DB_GiftCard.json

@@ -0,0 +1,20 @@
+{
+	"Arr": [
+		{
+			"Id": 1,
+			"ShopID": 970001,
+			"Name": "7日礼品卡",
+			"Rewards": {
+				"100001": 5000000,
+				"50001": 10
+			},
+			"DayRewards": {
+				"100001": 1000000
+			},
+			"Time": 7,
+			"Equity": [
+				0
+			]
+		}
+	]
+}

data/DB_PassShow.dat

@@ -0,0 +1,5 @@
+
+

<18>‰z Łś

+
+‘N ‘N
+â§

data/DB_PassShow.json

@@ -0,0 +1,21 @@
+{
+	"Arr": [
+		{
+			"Id": 1,
+			"ShowType": 1,
+			"ShowVolume": 2000003,
+			"Location": 20003
+		},
+		{
+			"Id": 2,
+			"ShowType": 2,
+			"ShowVolume": 10001,
+			"Location": 10001
+		},
+		{
+			"Id": 3,
+			"ShowType": 3,
+			"ShowVolume": 300002
+		}
+	]
+}

data/DB_PetSkill.dat

@@ -0,0 +1,14 @@
+
+W
鮮
 ﾁ<>=(
2驥鷹ｸ｡螳亥梱:1蝨ｨ陲ｫ轤ｸ蠑ｹ譏守｡ｮ謾ｻ蜃ｻ譌ｶ{0}%讎ら紫螳悟<E89EB3>蜈咲稔@
J<08>
+W鮮
 ﾁ<>=(2驥鷹ｸ｡螳亥梱:1蝨ｨ陲ｫ轤ｸ蠑ｹ譏守｡ｮ謾ｻ蜃ｻ譌ｶ{0}%讎ら紫螳悟<E89EB3>蜈咲稔@J<08>
+W鮮
 ﾁ<>=(2驥鷹ｸ｡螳亥梱:1蝨ｨ陲ｫ轤ｸ蠑ｹ譏守｡ｮ謾ｻ蜃ｻ譌ｶ{0}%讎ら紫螳悟<E89EB3>蜈咲稔@J<08>
+W鮮
 ﾁ<>=(2驥鷹ｸ｡螳亥梱:1蝨ｨ陲ｫ轤ｸ蠑ｹ譏守｡ｮ謾ｻ蜃ｻ譌ｶ{0}%讎ら紫螳悟<E89EB3>蜈咲稔@J<08>
+W鮮
 ﾁ<>=(2驥鷹ｸ｡螳亥梱:1蝨ｨ陲ｫ轤ｸ蠑ｹ譏守｡ｮ謾ｻ蜃ｻ譌ｶ{0}%讎ら紫螳悟<E89EB3>蜈咲稔@J<08>
+W鮮
 ﾁ<>=(2驥鷹ｸ｡螳亥梱:1蝨ｨ陲ｫ轤ｸ蠑ｹ譏守｡ｮ謾ｻ蜃ｻ譌ｶ{0}%讎ら紫螳悟<E89EB3>蜈咲稔@J<08>
+W鮮
 ﾁ<>=(2驥鷹ｸ｡螳亥梱:1蝨ｨ陲ｫ轤ｸ蠑ｹ譏守｡ｮ謾ｻ蜃ｻ譌ｶ{0}%讎ら紫螳悟<E89EB3>蜈咲稔@J<08>"
+W鮮
 ﾁ<>=(2驥鷹ｸ｡螳亥梱:1蝨ｨ陲ｫ轤ｸ蠑ｹ譏守｡ｮ謾ｻ蜃ｻ譌ｶ{0}%讎ら紫螳悟<E89EB3>蜈咲稔@J<08>7
+W	鮮
 ﾁ<>=(	2驥鷹ｸ｡螳亥梱:1蝨ｨ陲ｫ轤ｸ蠑ｹ譏守｡ｮ謾ｻ蜃ｻ譌ｶ{0}%讎ら紫螳悟<E89EB3>蜈咲稔@	J<08>Y
+X
+鮮
 ﾁ<>=(
+2驥鷹ｸ｡螳亥梱:1蝨ｨ陲ｫ轤ｸ蠑ｹ譏守｡ｮ謾ｻ蜃ｻ譌ｶ{0}%讎ら紫螳悟<E89EB3>蜈咲稔@
+J<08><10>

data/DB_PetSkill.json

@@ -0,0 +1,134 @@
+{
+	"Arr": [
+		{
+			"Id": 1,
+			"SkillId": 10001,
+			"SkillType": 1,
+			"PetId": 1000001,
+			"SkillLevel": 1,
+			"SkillName": "金鸡守卫",
+			"SkillDes": "在被炸弹明确攻击时{0}%概率完全免疫",
+			"SKillValue": 1,
+			"ItemConsum": {
+				"11001": 20
+			}
+		},
+		{
+			"Id": 2,
+			"SkillId": 10001,
+			"SkillType": 1,
+			"PetId": 1000001,
+			"SkillLevel": 2,
+			"SkillName": "金鸡守卫",
+			"SkillDes": "在被炸弹明确攻击时{0}%概率完全免疫",
+			"SKillValue": 2,
+			"ItemConsum": {
+				"11001": 3
+			}
+		},
+		{
+			"Id": 3,
+			"SkillId": 10001,
+			"SkillType": 1,
+			"PetId": 1000001,
+			"SkillLevel": 3,
+			"SkillName": "金鸡守卫",
+			"SkillDes": "在被炸弹明确攻击时{0}%概率完全免疫",
+			"SKillValue": 3,
+			"ItemConsum": {
+				"11001": 5
+			}
+		},
+		{
+			"Id": 4,
+			"SkillId": 10001,
+			"SkillType": 1,
+			"PetId": 1000001,
+			"SkillLevel": 4,
+			"SkillName": "金鸡守卫",
+			"SkillDes": "在被炸弹明确攻击时{0}%概率完全免疫",
+			"SKillValue": 4,
+			"ItemConsum": {
+				"11001": 8
+			}
+		},
+		{
+			"Id": 5,
+			"SkillId": 10001,
+			"SkillType": 1,
+			"PetId": 1000001,
+			"SkillLevel": 5,
+			"SkillName": "金鸡守卫",
+			"SkillDes": "在被炸弹明确攻击时{0}%概率完全免疫",
+			"SKillValue": 5,
+			"ItemConsum": {
+				"11001": 13
+			}
+		},
+		{
+			"Id": 6,
+			"SkillId": 10001,
+			"SkillType": 1,
+			"PetId": 1000001,
+			"SkillLevel": 6,
+			"SkillName": "金鸡守卫",
+			"SkillDes": "在被炸弹明确攻击时{0}%概率完全免疫",
+			"SKillValue": 6,
+			"ItemConsum": {
+				"11001": 21
+			}
+		},
+		{
+			"Id": 7,
+			"SkillId": 10001,
+			"SkillType": 1,
+			"PetId": 1000001,
+			"SkillLevel": 7,
+			"SkillName": "金鸡守卫",
+			"SkillDes": "在被炸弹明确攻击时{0}%概率完全免疫",
+			"SKillValue": 7,
+			"ItemConsum": {
+				"11001": 34
+			}
+		},
+		{
+			"Id": 8,
+			"SkillId": 10001,
+			"SkillType": 1,
+			"PetId": 1000001,
+			"SkillLevel": 8,
+			"SkillName": "金鸡守卫",
+			"SkillDes": "在被炸弹明确攻击时{0}%概率完全免疫",
+			"SKillValue": 8,
+			"ItemConsum": {
+				"11001": 55
+			}
+		},
+		{
+			"Id": 9,
+			"SkillId": 10001,
+			"SkillType": 1,
+			"PetId": 1000001,
+			"SkillLevel": 9,
+			"SkillName": "金鸡守卫",
+			"SkillDes": "在被炸弹明确攻击时{0}%概率完全免疫",
+			"SKillValue": 9,
+			"ItemConsum": {
+				"11001": 89
+			}
+		},
+		{
+			"Id": 10,
+			"SkillId": 10001,
+			"SkillType": 1,
+			"PetId": 1000001,
+			"SkillLevel": 10,
+			"SkillName": "金鸡守卫",
+			"SkillDes": "在被炸弹明确攻击时{0}%概率完全免疫",
+			"SKillValue": 10,
+			"ItemConsum": {
+				"11001": 144
+			}
+		}
+	]
+}

data/DB_PigBank_Diamond.dat

@@ -0,0 +1,4 @@
+
+


 (Ђ­в0–
8Ўи;@dH–
Pc
+ ((Ђ­в0¬8ўи;@dH¬PЗ

+яБЧ/ 2(Ђ­в0о8Ји;@dHоPу

data/DB_PigBank_Diamond.json

@@ -0,0 +1,40 @@
+{
+	"Arr": [
+		{
+			"Id": 1,
+			"BuyCountMin": 1,
+			"BuyCountMax": 1,
+			"CostDiamond": 30,
+			"MaxGold": 10000000,
+			"MaxDiamond": 150,
+			"DiamondId": 980001,
+			"CoinPrice": 100,
+			"DiamondPrice": 150,
+			"DiamondNowPrice": 99
+		},
+		{
+			"Id": 2,
+			"BuyCountMin": 2,
+			"BuyCountMax": 2,
+			"CostDiamond": 40,
+			"MaxGold": 10000000,
+			"MaxDiamond": 300,
+			"DiamondId": 980002,
+			"CoinPrice": 100,
+			"DiamondPrice": 300,
+			"DiamondNowPrice": 199
+		},
+		{
+			"Id": 3,
+			"BuyCountMin": 3,
+			"BuyCountMax": 99999999,
+			"CostDiamond": 50,
+			"MaxGold": 10000000,
+			"MaxDiamond": 750,
+			"DiamondId": 980003,
+			"CoinPrice": 100,
+			"DiamondPrice": 750,
+			"DiamondNowPrice": 499
+		}
+	]
+}

data/DB_Pigbank_Prop.dat

@@ -0,0 +1,9 @@
+
+
WinCoinRate
+LoseCoinRate
+
+DayBuyMaxCnt
+WinCoinRateDiamond
+LoseCoinRateDiamond
+
+DayBuyMaxCntDiamond

data/DB_Pigbank_Prop.json

@@ -0,0 +1,34 @@
+{
+	"Arr": [
+		{
+			"Id": 1,
+			"PorpName": "WinCoinRate",
+			"PropValue": 5
+		},
+		{
+			"Id": 2,
+			"PorpName": "LoseCoinRate",
+			"PropValue": 10
+		},
+		{
+			"Id": 3,
+			"PorpName": "DayBuyMaxCnt",
+			"PropValue": 3
+		},
+		{
+			"Id": 4,
+			"PorpName": "WinCoinRateDiamond",
+			"PropValue": 5
+		},
+		{
+			"Id": 5,
+			"PorpName": "LoseCoinRateDiamond",
+			"PropValue": 10
+		},
+		{
+			"Id": 6,
+			"PorpName": "DayBuyMaxCntDiamond",
+			"PropValue": 3
+		}
+	]
+}

data/DB_PropExchange.json

@@ -63,6 +63,54 @@
 			"Gain": {
 				"100002": 500
 			}
-		}
+		},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{},
+		{}
 	]
 }

data/DB_Skin.json

@@ -0,0 +1,147 @@
+{
+	"Arr": [
+		{
+			"Id": 300001,
+			"SkinClass": 4,
+			"Model": "juese",
+			"SkinPic": "icon_300001",
+			"SkinName": "活力-黄",
+			"SkinType": "mg_01",
+			"SkinSkillName": "0",
+			"SkinSkillIcon": "0",
+			"SkinSkillDes": "0",
+			"Turn": [
+				0
+			],
+			"TurnKey": [
+				"0"
+			]
+		},
+		{
+			"Id": 300002,
+			"SkinClass": 2,
+			"Model": "juese",
+			"SkinPic": "icon_300002",
+			"SkinName": "财神送福",
+			"SkinType": "mg_06",
+			"UnlockType": 2,
+			"UnlockItem": {
+				"310002": 20
+			},
+			"SkinSkillName": "福气东来",
+			"SkinSkillIcon": "SkillIcon-30002",
+			"SkinSkillDes": "排位赛积分提升",
+			"Turn": [
+				1
+			],
+			"TurnKey": [
+				"DBSkinUnlock_300002_t1"
+			]
+		},
+		{
+			"Id": 300003,
+			"SkinClass": 2,
+			"Model": "juese",
+			"SkinPic": "icon_300003",
+			"SkinName": "活力-粉",
+			"SkinType": "mg_02",
+			"UnlockType": 3,
+			"UnlockItem": {
+				"5": 0
+			},
+			"SkinSkillName": "活力满满",
+			"SkinSkillIcon": "SkillIcon-30003",
+			"SkinSkillDes": "VIP赛每日免费报名次数提升",
+			"Turn": [
+				2
+			],
+			"TurnKey": [
+				"DBSkinUnlock_300003_t1"
+			]
+		},
+		{
+			"Id": 300004,
+			"SkinClass": 2,
+			"Model": "juese",
+			"SkinPic": "icon_300004",
+			"SkinName": "活力-青",
+			"SkinType": "mg_03",
+			"UnlockType": 3,
+			"UnlockItem": {
+				"2": 0
+			},
+			"SkinSkillName": "金币满满",
+			"SkinSkillIcon": "SkillIcon-30004",
+			"SkinSkillDes": "每日礼包金币奖励提升",
+			"Turn": [
+				2
+			],
+			"TurnKey": [
+				"DBSkinUnlock_300004_t1"
+			]
+		},
+		{
+			"Id": 300005,
+			"SkinClass": 2,
+			"Model": "juese",
+			"SkinPic": "icon_300005",
+			"SkinName": "摇滚小子",
+			"SkinType": "mg_04",
+			"UnlockType": 2,
+			"UnlockItem": {
+				"310005": 20
+			},
+			"SkinSkillName": "金币加成",
+			"SkinSkillIcon": "SkillIcon-30005",
+			"SkinSkillDes": "每日任务金币奖励加成",
+			"Turn": [
+				3
+			],
+			"TurnKey": [
+				"DBSkinUnlock_300005_t1"
+			]
+		},
+		{
+			"Id": 300006,
+			"SkinClass": 4,
+			"Model": "juese",
+			"SkinPic": "icon_300006",
+			"SkinName": "潜水员",
+			"SkinType": "mg_05",
+			"UnlockType": 2,
+			"UnlockItem": {
+				"310006": 20
+			},
+			"SkinSkillName": "0",
+			"SkinSkillIcon": "0",
+			"SkinSkillDes": "0",
+			"Turn": [
+				4
+			],
+			"TurnKey": [
+				"DBSkinUnlock_300006_t1"
+			]
+		},
+		{
+			"Id": 300007,
+			"SkinClass": 2,
+			"Model": "juese",
+			"SkinPic": "icon_300007",
+			"SkinName": "冲浪健将",
+			"SkinType": "mg_07",
+			"UnlockType": 2,
+			"UnlockItem": {
+				"310007": 20
+			},
+			"SkinSkillName": "好运加成",
+			"SkinSkillIcon": "SkillIcon-30007",
+			"SkinSkillDes": "每次钻石抽奖幸运值提升",
+			"Turn": [
+				5
+			],
+			"TurnKey": [
+				"DBSkinUnlock_300007_t1"
+			]
+		}
+	]
+}

data/DB_SkinLevel.dat

@@ -0,0 +1,89 @@
+
+
á§
B
0
+á§"ñõB
0
+á§"ñõB
0
+á§"ñõB
0
+á§"ñõ
B
0
+á§"ñõB
0
+á§"ñõ"B
0
+á§"ñõ7B
0
+	á§	"ñõYB
0
+
+á§
+"ñõ<10>
B
0
++â§
(²ê
0
8
B排ä½<C3A4>赛积分æ<E280A0><C3A6>å<EFBFBD>‡{0}%
+3â§"òõ(²ê
08B排ä½<C3A4>赛积分æ<E280A0><C3A6>å<EFBFBD>‡{0}%
+3
â§"òõ(²ê
08B排ä½<C3A4>赛积分æ<E280A0><C3A6>å<EFBFBD>‡{0}%
+3â§"òõ(²ê
08B排ä½<C3A4>赛积分æ<E280A0><C3A6>å<EFBFBD>‡{0}%
+3â§"òõ
(²ê
08B排ä½<C3A4>赛积分æ<E280A0><C3A6>å<EFBFBD>‡{0}%
+3â§"òõ(²ê
08B排ä½<C3A4>赛积分æ<E280A0><C3A6>å<EFBFBD>‡{0}%
+3â§"òõ"(²ê
08B排ä½<C3A4>赛积分æ<E280A0><C3A6>å<EFBFBD>‡{0}%
+3â§"òõ7(²ê
08B排ä½<C3A4>赛积分æ<E280A0><C3A6>å<EFBFBD>‡{0}%
+3â§	"òõY(²ê
0	8	B排ä½<C3A4>赛积分æ<E280A0><C3A6>å<EFBFBD>‡{0}%
+4â§
+"òõ<10>
(²ê
0
+8
+B排ä½<C3A4>赛积分æ<E280A0><C3A6>å<EFBFBD>‡{0}%
+9ã§
(³ê
0
8
B'VIPèµ›æ¯<C3A6>æ—¥å…<C3A5>费报å<C2A5><C3A5>次数æ<C2B0><C3A6>å<EFBFBD>‡{0}
+Aã§"óõ(³ê
08B'VIPèµ›æ¯<C3A6>æ—¥å…<C3A5>费报å<C2A5><C3A5>次数æ<C2B0><C3A6>å<EFBFBD>‡{0}
+Aã§"óõ(³ê
08B'VIPèµ›æ¯<C3A6>æ—¥å…<C3A5>费报å<C2A5><C3A5>次数æ<C2B0><C3A6>å<EFBFBD>‡{0}
+Aã§"óõ(³ê
08B'VIPèµ›æ¯<C3A6>æ—¥å…<C3A5>费报å<C2A5><C3A5>次数æ<C2B0><C3A6>å<EFBFBD>‡{0}
+Aã§"óõ
(³ê
08B'VIPèµ›æ¯<C3A6>æ—¥å…<C3A5>费报å<C2A5><C3A5>次数æ<C2B0><C3A6>å<EFBFBD>‡{0}
+Aã§"óõ(³ê
08B'VIPèµ›æ¯<C3A6>æ—¥å…<C3A5>费报å<C2A5><C3A5>次数æ<C2B0><C3A6>å<EFBFBD>‡{0}
+Aã§"óõ"(³ê
08B'VIPèµ›æ¯<C3A6>æ—¥å…<C3A5>费报å<C2A5><C3A5>次数æ<C2B0><C3A6>å<EFBFBD>‡{0}
+Aã§"óõ7(³ê
08B'VIPèµ›æ¯<C3A6>æ—¥å…<C3A5>费报å<C2A5><C3A5>次数æ<C2B0><C3A6>å<EFBFBD>‡{0}
+Aã§	"óõY(³ê
0	8	B'VIPèµ›æ¯<C3A6>æ—¥å…<C3A5>费报å<C2A5><C3A5>次数æ<C2B0><C3A6>å<EFBFBD>‡{0}
+Bã§
+"óõ<10>
(³ê
0
+8
+B'VIPèµ›æ¯<C3A6>æ—¥å…<C3A5>费报å<C2A5><C3A5>次数æ<C2B0><C3A6>å<EFBFBD>‡{0}
+4ä§
(´ê
0
8
B"æ¯<C3A6>日礼包金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+< ä§"ôõ(´ê
08B"æ¯<C3A6>日礼包金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<!ä§"ôõ(´ê
08B"æ¯<C3A6>日礼包金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<"ä§"ôõ(´ê
08B"æ¯<C3A6>日礼包金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<#ä§"ôõ
(´ê
08B"æ¯<C3A6>日礼包金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<$ä§"ôõ(´ê
08B"æ¯<C3A6>日礼包金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<%ä§"ôõ"(´ê
08B"æ¯<C3A6>日礼包金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<&ä§"ôõ7(´ê
08B"æ¯<C3A6>日礼包金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<'ä§	"ôõY(´ê
0	8	B"æ¯<C3A6>日礼包金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+=(ä§
+"ôõ<10>
(´ê
0
+8
+B"æ¯<C3A6>日礼包金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+4)å§
(µê
0
8
B"æ¯<C3A6>日任务金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<*å§"õõ(µê
08B"æ¯<C3A6>日任务金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<+å§"õõ(µê
08B"æ¯<C3A6>日任务金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<,å§"õõ(µê
08B"æ¯<C3A6>日任务金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<-å§"õõ
(µê
08B"æ¯<C3A6>日任务金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<.å§"õõ(µê
08B"æ¯<C3A6>日任务金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+</å§"õõ"(µê
08B"æ¯<C3A6>日任务金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<0å§"õõ7(µê
08B"æ¯<C3A6>日任务金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+<1å§	"õõY(µê
0	8	B"æ¯<C3A6>日任务金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+=2å§
+"õõ<10>
(µê
0
+8
+B"æ¯<C3A6>日任务金å¸<C3A5>奖励æ<C2B1><C3A6>å<EFBFBD>‡{0}%
+3æ§
B
0
+4æ§"öõB
0
+5æ§"öõB
0
+6æ§"öõB
0
+7æ§"öõ
B
0
+8æ§"öõB
0
+9æ§"öõ"B
0
+:æ§"öõ7B
0
+;æ§	"öõYB
0
+<æ§
+"öõ<10>
B
0
+7=ç§
(·ê
0
8
B%æ¯<C3A6>次钻石抽奖幸è¿<C3A8>值æ<C2BC><C3A6>å<EFBFBD>‡{0}%
+?>ç§"÷õ(·ê
08B%æ¯<C3A6>次钻石抽奖幸è¿<C3A8>值æ<C2BC><C3A6>å<EFBFBD>‡{0}%
+??ç§"÷õ(·ê
08B%æ¯<C3A6>次钻石抽奖幸è¿<C3A8>值æ<C2BC><C3A6>å<EFBFBD>‡{0}%
+?@ç§"÷õ(·ê
08B%æ¯<C3A6>次钻石抽奖幸è¿<C3A8>值æ<C2BC><C3A6>å<EFBFBD>‡{0}%
+?Aç§"÷õ
(·ê
08B%æ¯<C3A6>次钻石抽奖幸è¿<C3A8>值æ<C2BC><C3A6>å<EFBFBD>‡{0}%
+?Bç§"÷õ(·ê
08B%æ¯<C3A6>次钻石抽奖幸è¿<C3A8>值æ<C2BC><C3A6>å<EFBFBD>‡{0}%
+?Cç§"÷õ"(·ê
08B%æ¯<C3A6>次钻石抽奖幸è¿<C3A8>值æ<C2BC><C3A6>å<EFBFBD>‡{0}%
+?Dç§"÷õ7(·ê
08B%æ¯<C3A6>次钻石抽奖幸è¿<C3A8>值æ<C2BC><C3A6>å<EFBFBD>‡{0}%
+?Eç§	"÷õY(·ê
0	8	B%æ¯<C3A6>次钻石抽奖幸è¿<C3A8>值æ<C2BC><C3A6>å<EFBFBD>‡{0}%
+@Fç§
+"÷õ<10>
(·ê
0
+8
+B%æ¯<C3A6>次钻石抽奖幸è¿<C3A8>值æ<C2BC><C3A6>å<EFBFBD>‡{0}%

data/DB_SkinLevel.json

@@ -0,0 +1,763 @@
+{
+	"Arr": [
+		{
+			"Id": 1,
+			"SkinId": 300001,
+			"Level": 1,
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 2,
+			"SkinId": 300001,
+			"Level": 2,
+			"UpItem": {
+				"310001": 3
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 3,
+			"SkinId": 300001,
+			"Level": 3,
+			"UpItem": {
+				"310001": 5
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 4,
+			"SkinId": 300001,
+			"Level": 4,
+			"UpItem": {
+				"310001": 8
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 5,
+			"SkinId": 300001,
+			"Level": 5,
+			"UpItem": {
+				"310001": 13
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 6,
+			"SkinId": 300001,
+			"Level": 6,
+			"UpItem": {
+				"310001": 21
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 7,
+			"SkinId": 300001,
+			"Level": 7,
+			"UpItem": {
+				"310001": 34
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 8,
+			"SkinId": 300001,
+			"Level": 8,
+			"UpItem": {
+				"310001": 55
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 9,
+			"SkinId": 300001,
+			"Level": 9,
+			"UpItem": {
+				"310001": 89
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 10,
+			"SkinId": 300001,
+			"Level": 10,
+			"UpItem": {
+				"310001": 144
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 11,
+			"SkinId": 300002,
+			"Level": 1,
+			"SkinSkillId": 30002,
+			"SkinSkillLevel": 1,
+			"SkinSkillValue": 1,
+			"SkinSkillDes": "排位赛积分提升{0}%"
+		},
+		{
+			"Id": 12,
+			"SkinId": 300002,
+			"Level": 2,
+			"UpItem": {
+				"310002": 3
+			},
+			"SkinSkillId": 30002,
+			"SkinSkillLevel": 2,
+			"SkinSkillValue": 2,
+			"SkinSkillDes": "排位赛积分提升{0}%"
+		},
+		{
+			"Id": 13,
+			"SkinId": 300002,
+			"Level": 3,
+			"UpItem": {
+				"310002": 5
+			},
+			"SkinSkillId": 30002,
+			"SkinSkillLevel": 3,
+			"SkinSkillValue": 3,
+			"SkinSkillDes": "排位赛积分提升{0}%"
+		},
+		{
+			"Id": 14,
+			"SkinId": 300002,
+			"Level": 4,
+			"UpItem": {
+				"310002": 8
+			},
+			"SkinSkillId": 30002,
+			"SkinSkillLevel": 4,
+			"SkinSkillValue": 4,
+			"SkinSkillDes": "排位赛积分提升{0}%"
+		},
+		{
+			"Id": 15,
+			"SkinId": 300002,
+			"Level": 5,
+			"UpItem": {
+				"310002": 13
+			},
+			"SkinSkillId": 30002,
+			"SkinSkillLevel": 5,
+			"SkinSkillValue": 5,
+			"SkinSkillDes": "排位赛积分提升{0}%"
+		},
+		{
+			"Id": 16,
+			"SkinId": 300002,
+			"Level": 6,
+			"UpItem": {
+				"310002": 21
+			},
+			"SkinSkillId": 30002,
+			"SkinSkillLevel": 6,
+			"SkinSkillValue": 6,
+			"SkinSkillDes": "排位赛积分提升{0}%"
+		},
+		{
+			"Id": 17,
+			"SkinId": 300002,
+			"Level": 7,
+			"UpItem": {
+				"310002": 34
+			},
+			"SkinSkillId": 30002,
+			"SkinSkillLevel": 7,
+			"SkinSkillValue": 7,
+			"SkinSkillDes": "排位赛积分提升{0}%"
+		},
+		{
+			"Id": 18,
+			"SkinId": 300002,
+			"Level": 8,
+			"UpItem": {
+				"310002": 55
+			},
+			"SkinSkillId": 30002,
+			"SkinSkillLevel": 8,
+			"SkinSkillValue": 8,
+			"SkinSkillDes": "排位赛积分提升{0}%"
+		},
+		{
+			"Id": 19,
+			"SkinId": 300002,
+			"Level": 9,
+			"UpItem": {
+				"310002": 89
+			},
+			"SkinSkillId": 30002,
+			"SkinSkillLevel": 9,
+			"SkinSkillValue": 9,
+			"SkinSkillDes": "排位赛积分提升{0}%"
+		},
+		{
+			"Id": 20,
+			"SkinId": 300002,
+			"Level": 10,
+			"UpItem": {
+				"310002": 144
+			},
+			"SkinSkillId": 30002,
+			"SkinSkillLevel": 10,
+			"SkinSkillValue": 10,
+			"SkinSkillDes": "排位赛积分提升{0}%"
+		},
+		{
+			"Id": 21,
+			"SkinId": 300003,
+			"Level": 1,
+			"SkinSkillId": 30003,
+			"SkinSkillLevel": 1,
+			"SkinSkillValue": 1,
+			"SkinSkillDes": "VIP赛每日免费报名次数提升{0}"
+		},
+		{
+			"Id": 22,
+			"SkinId": 300003,
+			"Level": 2,
+			"UpItem": {
+				"310003": 3
+			},
+			"SkinSkillId": 30003,
+			"SkinSkillLevel": 2,
+			"SkinSkillValue": 2,
+			"SkinSkillDes": "VIP赛每日免费报名次数提升{0}"
+		},
+		{
+			"Id": 23,
+			"SkinId": 300003,
+			"Level": 3,
+			"UpItem": {
+				"310003": 5
+			},
+			"SkinSkillId": 30003,
+			"SkinSkillLevel": 3,
+			"SkinSkillValue": 3,
+			"SkinSkillDes": "VIP赛每日免费报名次数提升{0}"
+		},
+		{
+			"Id": 24,
+			"SkinId": 300003,
+			"Level": 4,
+			"UpItem": {
+				"310003": 8
+			},
+			"SkinSkillId": 30003,
+			"SkinSkillLevel": 4,
+			"SkinSkillValue": 4,
+			"SkinSkillDes": "VIP赛每日免费报名次数提升{0}"
+		},
+		{
+			"Id": 25,
+			"SkinId": 300003,
+			"Level": 5,
+			"UpItem": {
+				"310003": 13
+			},
+			"SkinSkillId": 30003,
+			"SkinSkillLevel": 5,
+			"SkinSkillValue": 5,
+			"SkinSkillDes": "VIP赛每日免费报名次数提升{0}"
+		},
+		{
+			"Id": 26,
+			"SkinId": 300003,
+			"Level": 6,
+			"UpItem": {
+				"310003": 21
+			},
+			"SkinSkillId": 30003,
+			"SkinSkillLevel": 6,
+			"SkinSkillValue": 6,
+			"SkinSkillDes": "VIP赛每日免费报名次数提升{0}"
+		},
+		{
+			"Id": 27,
+			"SkinId": 300003,
+			"Level": 7,
+			"UpItem": {
+				"310003": 34
+			},
+			"SkinSkillId": 30003,
+			"SkinSkillLevel": 7,
+			"SkinSkillValue": 7,
+			"SkinSkillDes": "VIP赛每日免费报名次数提升{0}"
+		},
+		{
+			"Id": 28,
+			"SkinId": 300003,
+			"Level": 8,
+			"UpItem": {
+				"310003": 55
+			},
+			"SkinSkillId": 30003,
+			"SkinSkillLevel": 8,
+			"SkinSkillValue": 8,
+			"SkinSkillDes": "VIP赛每日免费报名次数提升{0}"
+		},
+		{
+			"Id": 29,
+			"SkinId": 300003,
+			"Level": 9,
+			"UpItem": {
+				"310003": 89
+			},
+			"SkinSkillId": 30003,
+			"SkinSkillLevel": 9,
+			"SkinSkillValue": 9,
+			"SkinSkillDes": "VIP赛每日免费报名次数提升{0}"
+		},
+		{
+			"Id": 30,
+			"SkinId": 300003,
+			"Level": 10,
+			"UpItem": {
+				"310003": 144
+			},
+			"SkinSkillId": 30003,
+			"SkinSkillLevel": 10,
+			"SkinSkillValue": 10,
+			"SkinSkillDes": "VIP赛每日免费报名次数提升{0}"
+		},
+		{
+			"Id": 31,
+			"SkinId": 300004,
+			"Level": 1,
+			"SkinSkillId": 30004,
+			"SkinSkillLevel": 1,
+			"SkinSkillValue": 1,
+			"SkinSkillDes": "每日礼包金币奖励提升{0}%"
+		},
+		{
+			"Id": 32,
+			"SkinId": 300004,
+			"Level": 2,
+			"UpItem": {
+				"310004": 3
+			},
+			"SkinSkillId": 30004,
+			"SkinSkillLevel": 2,
+			"SkinSkillValue": 2,
+			"SkinSkillDes": "每日礼包金币奖励提升{0}%"
+		},
+		{
+			"Id": 33,
+			"SkinId": 300004,
+			"Level": 3,
+			"UpItem": {
+				"310004": 5
+			},
+			"SkinSkillId": 30004,
+			"SkinSkillLevel": 3,
+			"SkinSkillValue": 3,
+			"SkinSkillDes": "每日礼包金币奖励提升{0}%"
+		},
+		{
+			"Id": 34,
+			"SkinId": 300004,
+			"Level": 4,
+			"UpItem": {
+				"310004": 8
+			},
+			"SkinSkillId": 30004,
+			"SkinSkillLevel": 4,
+			"SkinSkillValue": 4,
+			"SkinSkillDes": "每日礼包金币奖励提升{0}%"
+		},
+		{
+			"Id": 35,
+			"SkinId": 300004,
+			"Level": 5,
+			"UpItem": {
+				"310004": 13
+			},
+			"SkinSkillId": 30004,
+			"SkinSkillLevel": 5,
+			"SkinSkillValue": 5,
+			"SkinSkillDes": "每日礼包金币奖励提升{0}%"
+		},
+		{
+			"Id": 36,
+			"SkinId": 300004,
+			"Level": 6,
+			"UpItem": {
+				"310004": 21
+			},
+			"SkinSkillId": 30004,
+			"SkinSkillLevel": 6,
+			"SkinSkillValue": 6,
+			"SkinSkillDes": "每日礼包金币奖励提升{0}%"
+		},
+		{
+			"Id": 37,
+			"SkinId": 300004,
+			"Level": 7,
+			"UpItem": {
+				"310004": 34
+			},
+			"SkinSkillId": 30004,
+			"SkinSkillLevel": 7,
+			"SkinSkillValue": 7,
+			"SkinSkillDes": "每日礼包金币奖励提升{0}%"
+		},
+		{
+			"Id": 38,
+			"SkinId": 300004,
+			"Level": 8,
+			"UpItem": {
+				"310004": 55
+			},
+			"SkinSkillId": 30004,
+			"SkinSkillLevel": 8,
+			"SkinSkillValue": 8,
+			"SkinSkillDes": "每日礼包金币奖励提升{0}%"
+		},
+		{
+			"Id": 39,
+			"SkinId": 300004,
+			"Level": 9,
+			"UpItem": {
+				"310004": 89
+			},
+			"SkinSkillId": 30004,
+			"SkinSkillLevel": 9,
+			"SkinSkillValue": 9,
+			"SkinSkillDes": "每日礼包金币奖励提升{0}%"
+		},
+		{
+			"Id": 40,
+			"SkinId": 300004,
+			"Level": 10,
+			"UpItem": {
+				"310004": 144
+			},
+			"SkinSkillId": 30004,
+			"SkinSkillLevel": 10,
+			"SkinSkillValue": 10,
+			"SkinSkillDes": "每日礼包金币奖励提升{0}%"
+		},
+		{
+			"Id": 41,
+			"SkinId": 300005,
+			"Level": 1,
+			"SkinSkillId": 30005,
+			"SkinSkillLevel": 1,
+			"SkinSkillValue": 1,
+			"SkinSkillDes": "每日任务金币奖励提升{0}%"
+		},
+		{
+			"Id": 42,
+			"SkinId": 300005,
+			"Level": 2,
+			"UpItem": {
+				"310005": 3
+			},
+			"SkinSkillId": 30005,
+			"SkinSkillLevel": 2,
+			"SkinSkillValue": 2,
+			"SkinSkillDes": "每日任务金币奖励提升{0}%"
+		},
+		{
+			"Id": 43,
+			"SkinId": 300005,
+			"Level": 3,
+			"UpItem": {
+				"310005": 5
+			},
+			"SkinSkillId": 30005,
+			"SkinSkillLevel": 3,
+			"SkinSkillValue": 3,
+			"SkinSkillDes": "每日任务金币奖励提升{0}%"
+		},
+		{
+			"Id": 44,
+			"SkinId": 300005,
+			"Level": 4,
+			"UpItem": {
+				"310005": 8
+			},
+			"SkinSkillId": 30005,
+			"SkinSkillLevel": 4,
+			"SkinSkillValue": 4,
+			"SkinSkillDes": "每日任务金币奖励提升{0}%"
+		},
+		{
+			"Id": 45,
+			"SkinId": 300005,
+			"Level": 5,
+			"UpItem": {
+				"310005": 13
+			},
+			"SkinSkillId": 30005,
+			"SkinSkillLevel": 5,
+			"SkinSkillValue": 5,
+			"SkinSkillDes": "每日任务金币奖励提升{0}%"
+		},
+		{
+			"Id": 46,
+			"SkinId": 300005,
+			"Level": 6,
+			"UpItem": {
+				"310005": 21
+			},
+			"SkinSkillId": 30005,
+			"SkinSkillLevel": 6,
+			"SkinSkillValue": 6,
+			"SkinSkillDes": "每日任务金币奖励提升{0}%"
+		},
+		{
+			"Id": 47,
+			"SkinId": 300005,
+			"Level": 7,
+			"UpItem": {
+				"310005": 34
+			},
+			"SkinSkillId": 30005,
+			"SkinSkillLevel": 7,
+			"SkinSkillValue": 7,
+			"SkinSkillDes": "每日任务金币奖励提升{0}%"
+		},
+		{
+			"Id": 48,
+			"SkinId": 300005,
+			"Level": 8,
+			"UpItem": {
+				"310005": 55
+			},
+			"SkinSkillId": 30005,
+			"SkinSkillLevel": 8,
+			"SkinSkillValue": 8,
+			"SkinSkillDes": "每日任务金币奖励提升{0}%"
+		},
+		{
+			"Id": 49,
+			"SkinId": 300005,
+			"Level": 9,
+			"UpItem": {
+				"310005": 89
+			},
+			"SkinSkillId": 30005,
+			"SkinSkillLevel": 9,
+			"SkinSkillValue": 9,
+			"SkinSkillDes": "每日任务金币奖励提升{0}%"
+		},
+		{
+			"Id": 50,
+			"SkinId": 300005,
+			"Level": 10,
+			"UpItem": {
+				"310005": 144
+			},
+			"SkinSkillId": 30005,
+			"SkinSkillLevel": 10,
+			"SkinSkillValue": 10,
+			"SkinSkillDes": "每日任务金币奖励提升{0}%"
+		},
+		{
+			"Id": 51,
+			"SkinId": 300006,
+			"Level": 1,
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 52,
+			"SkinId": 300006,
+			"Level": 2,
+			"UpItem": {
+				"310006": 3
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 53,
+			"SkinId": 300006,
+			"Level": 3,
+			"UpItem": {
+				"310006": 5
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 54,
+			"SkinId": 300006,
+			"Level": 4,
+			"UpItem": {
+				"310006": 8
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 55,
+			"SkinId": 300006,
+			"Level": 5,
+			"UpItem": {
+				"310006": 13
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 56,
+			"SkinId": 300006,
+			"Level": 6,
+			"UpItem": {
+				"310006": 21
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 57,
+			"SkinId": 300006,
+			"Level": 7,
+			"UpItem": {
+				"310006": 34
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 58,
+			"SkinId": 300006,
+			"Level": 8,
+			"UpItem": {
+				"310006": 55
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 59,
+			"SkinId": 300006,
+			"Level": 9,
+			"UpItem": {
+				"310006": 89
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 60,
+			"SkinId": 300006,
+			"Level": 10,
+			"UpItem": {
+				"310006": 144
+			},
+			"SkinSkillDes": "0"
+		},
+		{
+			"Id": 61,
+			"SkinId": 300007,
+			"Level": 1,
+			"SkinSkillId": 30007,
+			"SkinSkillLevel": 1,
+			"SkinSkillValue": 1,
+			"SkinSkillDes": "每次钻石抽奖幸运值提升{0}%"
+		},
+		{
+			"Id": 62,
+			"SkinId": 300007,
+			"Level": 2,
+			"UpItem": {
+				"310007": 3
+			},
+			"SkinSkillId": 30007,
+			"SkinSkillLevel": 2,
+			"SkinSkillValue": 2,
+			"SkinSkillDes": "每次钻石抽奖幸运值提升{0}%"
+		},
+		{
+			"Id": 63,
+			"SkinId": 300007,
+			"Level": 3,
+			"UpItem": {
+				"310007": 5
+			},
+			"SkinSkillId": 30007,
+			"SkinSkillLevel": 3,
+			"SkinSkillValue": 3,
+			"SkinSkillDes": "每次钻石抽奖幸运值提升{0}%"
+		},
+		{
+			"Id": 64,
+			"SkinId": 300007,
+			"Level": 4,
+			"UpItem": {
+				"310007": 8
+			},
+			"SkinSkillId": 30007,
+			"SkinSkillLevel": 4,
+			"SkinSkillValue": 4,
+			"SkinSkillDes": "每次钻石抽奖幸运值提升{0}%"
+		},
+		{
+			"Id": 65,
+			"SkinId": 300007,
+			"Level": 5,
+			"UpItem": {
+				"310007": 13
+			},
+			"SkinSkillId": 30007,
+			"SkinSkillLevel": 5,
+			"SkinSkillValue": 5,
+			"SkinSkillDes": "每次钻石抽奖幸运值提升{0}%"
+		},
+		{
+			"Id": 66,
+			"SkinId": 300007,
+			"Level": 6,
+			"UpItem": {
+				"310007": 21
+			},
+			"SkinSkillId": 30007,
+			"SkinSkillLevel": 6,
+			"SkinSkillValue": 6,
+			"SkinSkillDes": "每次钻石抽奖幸运值提升{0}%"
+		},
+		{
+			"Id": 67,
+			"SkinId": 300007,
+			"Level": 7,
+			"UpItem": {
+				"310007": 34
+			},
+			"SkinSkillId": 30007,
+			"SkinSkillLevel": 7,
+			"SkinSkillValue": 7,
+			"SkinSkillDes": "每次钻石抽奖幸运值提升{0}%"
+		},
+		{
+			"Id": 68,
+			"SkinId": 300007,
+			"Level": 8,
+			"UpItem": {
+				"310007": 55
+			},
+			"SkinSkillId": 30007,
+			"SkinSkillLevel": 8,
+			"SkinSkillValue": 8,
+			"SkinSkillDes": "每次钻石抽奖幸运值提升{0}%"
+		},
+		{
+			"Id": 69,
+			"SkinId": 300007,
+			"Level": 9,
+			"UpItem": {
+				"310007": 89
+			},
+			"SkinSkillId": 30007,
+			"SkinSkillLevel": 9,
+			"SkinSkillValue": 9,
+			"SkinSkillDes": "每次钻石抽奖幸运值提升{0}%"
+		},
+		{
+			"Id": 70,
+			"SkinId": 300007,
+			"Level": 10,
+			"UpItem": {
+				"310007": 144
+			},
+			"SkinSkillId": 30007,
+			"SkinSkillLevel": 10,
+			"SkinSkillValue": 10,
+			"SkinSkillDes": "每次钻石抽奖幸运值提升{0}%"
+		}
+	]
+}

data/DB_VIP.json

@@ -3,8 +3,8 @@
 		{
 			"Name": "不是VIP",
 			"Privilege1": [
-				100000,
-				2
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -28,7 +28,12 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 1000
 		},
 		{
 			"Id": 1,
@@ -36,8 +41,8 @@
 			"Count": 1000,
 			"VipExp": 1000,
 			"Privilege1": [
-				100000,
-				100
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -62,7 +67,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 1,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 2000
 		},
 		{
 			"Id": 2,
@@ -70,8 +81,8 @@
 			"Count": 2000,
 			"VipExp": 2000,
 			"Privilege1": [
-				150000,
-				150
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -96,7 +107,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 2,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 3000
 		},
 		{
 			"Id": 3,
@@ -104,8 +121,8 @@
 			"Count": 5000,
 			"VipExp": 5000,
 			"Privilege1": [
-				200000,
-				200
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -130,7 +147,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 3,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 4000
 		},
 		{
 			"Id": 4,
@@ -138,8 +161,8 @@
 			"Count": 10000,
 			"VipExp": 10000,
 			"Privilege1": [
-				300000,
-				250
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -164,7 +187,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 4,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 5000
 		},
 		{
 			"Id": 5,
@@ -172,8 +201,8 @@
 			"Count": 20000,
 			"VipExp": 20000,
 			"Privilege1": [
-				400000,
-				300
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -198,7 +227,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 5,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 6000
 		},
 		{
 			"Id": 6,
@@ -206,8 +241,8 @@
 			"Count": 50000,
 			"VipExp": 50000,
 			"Privilege1": [
-				500000,
-				350
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -232,7 +267,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 6,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 7000
 		},
 		{
 			"Id": 7,
@@ -240,8 +281,8 @@
 			"Count": 100000,
 			"VipExp": 100000,
 			"Privilege1": [
-				600000,
-				400
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -266,7 +307,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 7,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 8000
 		},
 		{
 			"Id": 8,
@@ -274,8 +321,8 @@
 			"Count": 200000,
 			"VipExp": 200000,
 			"Privilege1": [
-				700000,
-				450
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -300,7 +347,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 8,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 9000
 		},
 		{
 			"Id": 9,
@@ -308,8 +361,8 @@
 			"Count": 500000,
 			"VipExp": 500000,
 			"Privilege1": [
-				800000,
-				500
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -334,7 +387,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 9,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 10000
 		},
 		{
 			"Id": 10,
@@ -342,8 +401,8 @@
 			"Count": 1000000,
 			"VipExp": 1000000,
 			"Privilege1": [
-				900000,
-				550
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -368,7 +427,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 10,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 11000
 		},
 		{
 			"Id": 11,
@@ -376,8 +441,8 @@
 			"Count": 2000000,
 			"VipExp": 2000000,
 			"Privilege1": [
-				1000000,
-				600
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -402,7 +467,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 11,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 12000
 		},
 		{
 			"Id": 12,
@@ -410,8 +481,8 @@
 			"Count": 5000000,
 			"VipExp": 5000000,
 			"Privilege1": [
-				2000000,
-				650
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -436,7 +507,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 12,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 13000
 		},
 		{
 			"Id": 13,
@@ -444,8 +521,8 @@
 			"Count": 10000000,
 			"VipExp": 10000000,
 			"Privilege1": [
-				3000000,
-				700
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -470,7 +547,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 13,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 14000
 		},
 		{
 			"Id": 14,
@@ -478,8 +561,8 @@
 			"Count": 20000000,
 			"VipExp": 20000000,
 			"Privilege1": [
-				4000000,
-				750
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -504,7 +587,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 14,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 15000
 		},
 		{
 			"Id": 15,
@@ -512,8 +601,8 @@
 			"Count": 50000000,
 			"VipExp": 50000000,
 			"Privilege1": [
-				5000000,
-				800
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -538,7 +627,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
+			],
+			"MatchFreeTimes": 15,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 16000
 		},
 		{
 			"Id": 16,
@@ -546,8 +641,8 @@
 			"Count": 100000000,
 			"VipExp": 100000000,
 			"Privilege1": [
-				6000000,
-				850
+				0,
+				0
 			],
 			"Privilege2": [
 				0,
@@ -572,8 +667,13 @@
 				"获得专属头像框",
 				"获得专属炮台",
 				"更多VIP功能正待开发"
-			]
-		},
-		{}
+			],
+			"MatchFreeTimes": 16,
+			"Privilege9": [
+				0,
+				0
+			],
+			"PrivilegeShow": 17000
+		}
 	]
 }

data/DB_VIPShow.dat

@@ -0,0 +1,3 @@
+
+
罘
+荅

data/DB_VIPShow.json

@@ -0,0 +1,13 @@
+{
+	"Arr": [
+		{
+			"Id": 1,
+			"SkinId": 300003
+		},
+		{
+			"Id": 2,
+			"SkinId": 300004,
+			"VIPLevel": 3
+		}
+	]
+}

data/gameconfig/machine.json

@@ -0,0 +1,19 @@
+{
+	"GameName":"娃娃机",
+	"GameId":608,
+	"GameMode":[0],
+	"SceneType":[1],
+	"CanForceStart":false,
+	"MinPlayerCnt":1,
+	"DefaultPlayerCnt":1,
+	"MaxIndex":0,
+	"TimeFreeStart":0,
+	"TimeFreeEnd":0,
+	"DependentPlayerCnt":true,
+	"EnterAfterStart":false,
+	"PerGameTakeCard":100,
+	"ViewLogCnt":-1,
+	"BetState":0,
+	"Params":[
+	]
+}

data/gameparam.json

@@ -1,5 +1,5 @@
 {
-  "NewPlayerCoin":1000000,
+  "NewPlayerCoin":100000000,
   "UpgradeAccountGiveCoin":0,
   "LogBatchWriteCount":1024,
   "LogBatchWriteInterval":1,
@@ -22,5 +22,7 @@
   "RobotInviteIntervalMax": 1,
   "ClosePreCreateRoom": true,
   "AgoraAddress": "http://47.105.78.29:8081",
-  "InviteUrl": "http://47.105.78.29:8000/"
+  "InviteUrl": "http://47.105.78.29:8000/",
+  "RankTimeout": 2,
+  "PermitInitScore": 0
 }

data/i18n/languages.json

@@ -7,5 +7,7 @@
 	"RankAwardTitle": "{\"zh\":\"赛季奖励-%v\",\"vi\":\"Hạng bạc-%v\",\"en\":\"Season rewards-%v\",\"kh\":\"រង្វាន់រដូវកាល-%v\"}",
 	"RankAward": "{\"zh\":\"您上赛季有未领取的奖励\",\"vi\":\"Bạn có phần thưởng chưa được nhận từ mùa giải trước\",\"en\":\"You have unclaimed rewards from last season\",\"kh\":\"អ្នកមិនទាន់បានយករង្វាន់តាំងពីរដូវកាលមុន\"}",
 	"MatchAwardTitle": "{\"zh\":\"话费充值兑换码\",\"vi\":\"Mã nạp tiền ĐT\",\"en\":\"Phone recharge code\",\"kh\":\"កូដបញ្ចូលទូរស័ព្ទ\"}",
-	"MatchAward": "{\"zh\":\"恭喜您获得电话预付卡“%v$”话费充值奖励,兑换码:%v,请尽快使用\",\"vi\":\"Chúc mừng bạn đã nhận được Thẻ trả trước ĐT “%v$” phần thưởng nạp tiền tín dụng ĐT, mã đổi thưởng %v xin sử dụng ngay lập tức\",\"en\":\"Congratulations, you have received the phone prepaid card “%v$” mobile credit top-up reward, redemption code: %v please use it immediately.\",\"kh\":\"សូមអបអរសាទរ អ្នកទទួលបានរង្វាន់កាតបញ្ចូលទូរស័ព្ទ កាតទូរស័ព្ទបង់ប្រាក់ជាមុន “%v$”លេខកូដដោះដូរ %v សូមប្រើវាភ្លាមៗ\"}"
+	"MatchAward": "{\"zh\":\"恭喜您获得电话预付卡“%v$”话费充值奖励,兑换码:%v,请尽快使用\",\"vi\":\"Chúc mừng bạn đã nhận được Thẻ trả trước ĐT “%v$” phần thưởng nạp tiền tín dụng ĐT, mã đổi thưởng %v xin sử dụng ngay lập tức\",\"en\":\"Congratulations, you have received the phone prepaid card “%v$” mobile credit top-up reward, redemption code: %v please use it immediately.\",\"kh\":\"សូមអបអរសាទរ អ្នកទទួលបានរង្វាន់កាតបញ្ចូលទូរស័ព្ទ កាតទូរស័ព្ទបង់ប្រាក់ជាមុន “%v$”លេខកូដដោះដូរ %v សូមប្រើវាភ្លាមៗ\"}",
+	"PermitAwardTitle": "{\"zh\":\"通行证排行奖励\",\"vi\":\"Vượt qua phần thưởng xếp hạng\",\"en\":\"Pass Ranking Rewards\",\"kh\":\"រង្វាន់ចំណាត់ថ្នាក់ឆ្លងកាត់\"}",
+	"PermitAward": "{\"zh\":\"恭喜您在上个赛季通行证排行中名次达到%v名，排行奖励已发放，请查收\",\"vi\":\"Chúc mừng bạn đã đạt được %v trong bảng xếp hạng vượt qua. Phần thưởng xếp hạng đã được phân phối, vui lòng kiểm tra.\",\"en\":\"Congratulations on reaching %vth place in the pass ranking. Ranking rewards have been issued. Please check.\",\"kh\":\"សូមអបអរសាទរចំពោះការឈានដល់ចំណាត់ថ្នាក់ទី %v ក្នុងចំណាត់ថ្នាក់ឆ្លងកាត់។ រង្វាន់ចំណាត់ថ្នាក់ត្រូវបានចេញ។ សូមត្រួតពិនិត្យ។\"}"
 }

dbproxy/config.json

@@ -44,6 +44,15 @@
     "AppId": "5c56d1644966f078bfb90c71",
     "IsDevMode": true
   },
+  "data":{
+    "RootPath":"../data"
+  },
+  "etcd": {
+    "Url": ["127.0.0.1:2379"],
+    "UserName": "",
+    "Password": "",
+    "DialTimeout": 60
+  },
   "costum": {
     "MgoRpcCliNet": "tcp",
     "MgoRpcCliAddr": "127.0.0.1:8999",
@@ -51,11 +60,6 @@
     "RMQExchange": "win88",
     "RMQQosPrefetchCount": 2,
     "RMQQosPrefetchSize": 0,
-    "RMQQosGlobal": true,
-    "etcdurl": [
-      "127.0.0.1:2379"
-    ],
-    "etcduser": "",
-    "etcdpwd": ""
+    "RMQQosGlobal": true
   }
 }

dbproxy/etcd.go

@@ -1,10 +1,10 @@
 package main
 
 import (
+	"context"
 	"strings"
 
 	"go.etcd.io/etcd/client/v3"
-
 	"mongo.games.com/goserver/core/logger"
 
 	"mongo.games.com/game/dbproxy/mongo"
@@ -13,7 +13,7 @@ import (
 )
 
 func init() {
-	etcd.Register(etcd.ETCDKEY_SYS_PLT_DBCFG_PREFIX, webapi.PlatformDbConfig{}, func(completeKey string, isInit bool, event *clientv3.Event, data interface{}) {
+	etcd.Register(etcd.ETCDKEY_SYS_PLT_DBCFG_PREFIX, webapi.PlatformDbConfig{}, func(ctx context.Context, completeKey string, isInit bool, event *clientv3.Event, data interface{}) {
 		if event.Type == clientv3.EventTypeDelete {
 			return
 		}

dbproxy/main.go

@@ -7,53 +7,44 @@ import (
 	"net/rpc"
 
 	"mongo.games.com/goserver/core"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
+	"mongo.games.com/goserver/core/etcd"
 	"mongo.games.com/goserver/core/module"
 
 	_ "mongo.games.com/game"
-	_ "mongo.games.com/game/dbproxy/mq"
-
 	"mongo.games.com/game/common"
+	_ "mongo.games.com/game/dbproxy/mq"
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
+	_ "mongo.games.com/game/srvdata"
 )
 
-var rabbitMqConsumer *mq.RabbitMQConsumer
-
-func init() {
-	core.RegisteHook(core.HOOK_BEFORE_START, func() error {
-		model.InitGameParam()
-		rabbitMqConsumer = mq.NewRabbitMQConsumer(common.CustomConfig.GetString("RabbitMQURL"), rabbitmq.Exchange{Name: common.CustomConfig.GetString("RMQExchange"), Durable: true})
-		if rabbitMqConsumer != nil {
-			rabbitMqConsumer.Start()
-		}
-
-		//尝试初始化
-		svc.GetOnePlayerIdFromBucket()
-		return nil
-	})
-
-	core.RegisteHook(core.HOOK_AFTER_STOP, func() error {
-		if rabbitMqConsumer != nil {
-			rabbitMqConsumer.Stop()
-		}
-		model.ShutdownRPClient()
-		return nil
-	})
-}
-
 func main() {
+	// 自定义配置文件
+	model.InitGameParam()
+	// package模块
 	defer core.ClosePackages()
 	core.LoadPackages("config.json")
-
-	rpc.HandleHTTP() // 采用http协议作为rpc载体
-	lis, err := net.Listen(common.CustomConfig.GetString("MgoRpcCliNet"), common.CustomConfig.GetString("MgoRpcCliAddr"))
-	if err != nil {
-		log.Fatalln("fatal error: ", err)
-	}
-	go http.Serve(lis, nil)
-
-	waitor := module.Start()
-	waitor.Wait("main()")
+	// core hook
+	core.RegisteHook(core.HOOK_BEFORE_START, func() error {
+		etcd.Start()
+		mq.StartConsumer(common.CustomConfig.GetString("RabbitMQURL"), common.CustomConfig.GetString("RMQExchange"), true)
+		mq.StartPublisher(common.CustomConfig.GetString("RabbitMQURL"), common.CustomConfig.GetString("RMQExchange"), true, common.CustomConfig.GetInt("RMQPublishBacklog"))
+		// 尝试初始化玩家id
+		svc.GetOnePlayerIdFromBucket()
+		// rpc 服务
+		rpc.HandleHTTP() // 采用http协议作为rpc载体
+		lis, err := net.Listen(common.CustomConfig.GetString("MgoRpcCliNet"), common.CustomConfig.GetString("MgoRpcCliAddr"))
+		if err != nil {
+			log.Fatalln("rpc start fatal error: ", err)
+		}
+		go http.Serve(lis, nil)
+		return nil
+	})
+	core.RegisteHook(core.HOOK_AFTER_STOP, func() error {
+		return nil
+	})
+	// module模块
+	w := module.Start()
+	w.Wait("main()")
 }

dbproxy/mongo/newmongo.go

@@ -0,0 +1,53 @@
+package mongo
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	newMongo "go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"mongo.games.com/goserver/core/logger"
+)
+
+var globalMongoSession *newMongo.Client
+
+func mongoURI(user, password, host string, port int32, options string) string {
+	login := ""
+	if user != "" {
+		login = user + ":" + password + "@"
+	}
+	if host == "" {
+		host = "localhost"
+	}
+	if port == 0 {
+		port = 27017
+	}
+	if options != "" {
+		options = "?" + options
+	}
+	url := fmt.Sprintf("mongodb://%s%s:%d/admin%s", login, host, port, options)
+	return url
+}
+
+func NewMongoClient() (*newMongo.Client, error) {
+	if globalMongoSession != nil {
+		return globalMongoSession, nil
+	}
+	cfg, b := MgoSessionMgrSington.GetCfg(G_P, "user")
+	if !b {
+		return nil, errors.New("not db")
+	}
+	ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)
+	client, err := newMongo.Connect(ctx, options.Client().ApplyURI(mongoURI(cfg.Username, cfg.Password, cfg.HostName, cfg.HostPort, cfg.Options)))
+	if err != nil {
+		logger.Logger.Errorf("NewMongoClient error:%v", err)
+		return nil, err
+	}
+	if client == nil {
+		return nil, errors.New("not db client")
+	}
+	globalMongoSession = client
+	return client, nil
+}

dbproxy/mongo/sessionmgr.go

@@ -143,8 +143,10 @@ func newMgoSession(user, password, host string, port int32, options string) (s *
 	// [mongodb://][user:pass@]host1[:port1][,host2[:port2],...][/database][?options]
 	url := fmt.Sprintf("mongodb://%s%s:%d/admin%s", login, host, port, options)
 	//fmt.Println(url)
+	logger.Logger.Tracef("newMgoSession url:%s", url)
 	session, err := mgo.Dial(url)
 	if err != nil {
+		logger.Logger.Errorf("newMgoSession err:%v", err)
 		return nil, err
 	}
 	session.SetSafe(&mgo.Safe{})
@@ -240,7 +242,7 @@ func (msm *MgoSessionMgr) GetPltMgoSession(plt, key string) *Session {
 	if c, ok := msm.GetCfg(plt, key); ok {
 		s, err := newMgoSession(c.Username, c.Password, c.HostName, c.HostPort, c.Options)
 		if s == nil || err != nil {
-			logger.Logger.Error("GetPltMgoSession(%s,%s) err:%v", plt, key, err)
+			logger.Logger.Errorf("GetPltMgoSession(%s,%s) err:%v config:%+v", plt, key, err, *c)
 			return nil
 		}
 		ss := &Session{Session: s, cfg: c}

dbproxy/mq/c_apilog.go

@@ -2,11 +2,13 @@ package mq
 
 import (
 	"encoding/json"
+
+	"mongo.games.com/goserver/core/broker"
+	"mongo.games.com/goserver/core/broker/rabbitmq"
+
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
-	"mongo.games.com/goserver/core/broker"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
 )
 
 func init() {
@@ -14,13 +16,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.APILog

dbproxy/mq/c_clientlog.go

@@ -1,56 +0,0 @@
-package mq
-
-func init() {
-	//mq.RegisteSubscriber(model.ClientLogCollName, func(e broker.Event) (err error) {
-	//	msg := e.Message()
-	//	if msg != nil {
-	//		defer func() {
-	//			if err != nil {
-	//				mq.BackUp(e, err)
-	//			}
-	//
-	//			e.Ack()
-	//
-	//			recover()
-	//		}()
-	//
-	//		var log model.ClientLog
-	//		err = json.Unmarshal(msg.Body, &log)
-	//		if err != nil {
-	//			logger.Logger.Errorf("[mq] %s %v", model.ClientLogCollName, err)
-	//			return
-	//		}
-	//
-	//		logger.Logger.Tracef("[mq] %s %v", model.ClientLogCollName, string(msg.Body))
-	//
-	//		data := map[string]interface{}{}
-	//		err = json.Unmarshal([]byte(log.Data), &data)
-	//		if err != nil {
-	//			logger.Logger.Errorf("[mq] %s %v", model.ClientLogCollName, err)
-	//			return
-	//		}
-	//
-	//		// 获取平台id
-	//		platform := log.Platform
-	//		if log.Platform == "" {
-	//			id, ok := data["platform"]
-	//			if ok {
-	//				platform = string(id.([]byte))
-	//			}
-	//		}
-	//
-	//		data["ts"] = log.Ts
-	//		if log.Snid > 0 {
-	//			data["snid"] = log.Snid
-	//		}
-	//
-	//		c := svc.ClientLogStartCollection(platform)
-	//		if c != nil {
-	//			err = c.Insert(data)
-	//		}
-	//
-	//		return
-	//	}
-	//	return nil
-	//}, broker.Queue(model.ClientLogCollName), broker.DisableAutoAck(), rabbitmq.DurableQueue())
-}

dbproxy/mq/c_coingivelog.go

@@ -2,11 +2,13 @@ package mq
 
 import (
 	"encoding/json"
+
+	"mongo.games.com/goserver/core/broker"
+	"mongo.games.com/goserver/core/broker/rabbitmq"
+
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
-	"mongo.games.com/goserver/core/broker"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
 )
 
 func init() {
@@ -14,13 +16,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.CoinGiveLog

dbproxy/mq/c_coinlog.go

@@ -2,11 +2,13 @@ package mq
 
 import (
 	"encoding/json"
+
+	"mongo.games.com/goserver/core/broker"
+	"mongo.games.com/goserver/core/broker/rabbitmq"
+
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
-	"mongo.games.com/goserver/core/broker"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
 )
 
 func init() {
@@ -14,13 +16,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.CoinLog
@@ -30,7 +26,7 @@ func init() {
 			}
 
 			if log.Count == 0 { //玩家冲账探针
-				RabbitMQPublisher.Send(model.TopicProbeCoinLogAck, log)
+				mq.Send(model.TopicProbeCoinLogAck, log)
 			} else {
 				c := svc.CoinLogsCollection(log.Platform)
 				if c != nil {

dbproxy/mq/c_friendrecordlog.go

@@ -2,11 +2,13 @@ package mq
 
 import (
 	"encoding/json"
+
+	"mongo.games.com/goserver/core/broker"
+	"mongo.games.com/goserver/core/broker/rabbitmq"
+
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
-	"mongo.games.com/goserver/core/broker"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
 )
 
 func init() {
@@ -14,13 +16,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.FriendRecord

dbproxy/mq/c_gamegamedetailedlog.go

@@ -2,12 +2,14 @@ package mq
 
 import (
 	"encoding/json"
-	"mongo.games.com/game/dbproxy/svc"
-	"mongo.games.com/game/model"
-	"mongo.games.com/game/mq"
+
 	"mongo.games.com/goserver/core/broker"
 	"mongo.games.com/goserver/core/broker/rabbitmq"
 	"mongo.games.com/goserver/core/logger"
+
+	"mongo.games.com/game/dbproxy/svc"
+	"mongo.games.com/game/model"
+	"mongo.games.com/game/mq"
 )
 
 func init() {
@@ -15,13 +17,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.GameDetailedLog

dbproxy/mq/c_gameplayerlistlog.go

@@ -2,11 +2,13 @@ package mq
 
 import (
 	"encoding/json"
+
+	"mongo.games.com/goserver/core/broker"
+	"mongo.games.com/goserver/core/broker/rabbitmq"
+
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
-	"mongo.games.com/goserver/core/broker"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
 )
 
 func init() {
@@ -14,13 +16,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.GamePlayerListLog

dbproxy/mq/c_invite.go

@@ -1,71 +1,310 @@
 package mq
 
 import (
+	"context"
 	"encoding/json"
-	"fmt"
+	"errors"
 	"time"
 
-	"github.com/astaxie/beego/cache"
+	"go.mongodb.org/mongo-driver/bson"
+	newMongo "go.mongodb.org/mongo-driver/mongo"
 	"mongo.games.com/goserver/core/broker"
 	"mongo.games.com/goserver/core/broker/rabbitmq"
 	"mongo.games.com/goserver/core/logger"
 
+	"mongo.games.com/game/common"
+	"mongo.games.com/game/dbproxy/mongo"
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
 )
 
-var InviteNumCache = cache.NewMemoryCache()
-
 func init() {
-	mq.RegisterSubscriber(model.EvtBindInvite, func(e broker.Event) (err error) {
+	mq.RegisterSubscriber(model.EvtInvite, func(e broker.Event) (err error) {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
-			var log model.BindInvite
+			var log model.EvtInviteMsg
 			err = json.Unmarshal(msg.Body, &log)
 			if err != nil {
+				logger.Logger.Errorf("EvtInvite json.Unmarshal error:%v msg:%v", err, string(msg.Body))
 				return
 			}
+			logger.Logger.Tracef("EvtInvite log:%+v", log)
 
-			// 绑定
-			err = svc.BindInviteSnId(log.Platform, log.SnId, log.InviteSnId, log.Ts)
-			if err != nil {
-				logger.Logger.Errorf("BindInviteSnId error:%v", err)
-				return err
-			}
-
-			name := fmt.Sprintf("%v", log.InviteSnId)
-			b := InviteNumCache.Get(name)
-			n, _ := b.(int32)
-			if n > 0 {
-				n++
-			} else {
-				n, err = svc.GetInviteNum(log.Platform, log.InviteSnId)
+			var addRechargeScore bool
+			if log.Tp != common.InviteScoreCheckWeek {
+				addRechargeScore, err = svc.CheckInviteScore(&log.InviteScore)
 				if err != nil {
-					logger.Logger.Errorf("BindInviteSnId error:%v", err)
+					logger.Logger.Errorf("EvtInvite SaveInviteScore error:%v msg:%+v %+v", err, log.InviteScore, log)
 					return err
 				}
 			}
-			InviteNumCache.Put(name, n, int64(time.Hour.Seconds()))
 
-			// 更新绑定数量
-			RabbitMQPublisher.Send(model.AckBindNum, &model.BindNum{
-				SnId: log.InviteSnId,
-				Num:  n,
+			now := time.Unix(log.Ts, 0).Local() // 数据创建时间
+
+			get := func(snid int32) (*model.EvtInviteAckMsg, error) {
+				if snid == 0 {
+					return nil, errors.New("not found")
+				}
+				n := new(model.EvtInviteAckMsg)
+				n.Platform = log.Platform
+				n.Snid = snid
+				n.Score, n.Num, n.Money, _, err = svc.GetInviteData(log.Platform, snid)
+				return n, err
+			}
+
+			// 重置积分
+			reset := func(snid int32) error {
+				if snid == 0 {
+					return nil
+				}
+				_, _, _, ts, err := svc.GetInviteData(log.Platform, snid) // 上次更新时间
+				if err != nil {
+					logger.Logger.Errorf("EvtInvite GetInviteData error:%v snid:%v", err, snid)
+					return err
+				}
+				inSameWeek := common.InSameWeek(ts, now)
+				if !inSameWeek {
+					err = svc.ClearInviteScore(log.Platform, snid, now)
+					if err != nil {
+						logger.Logger.Errorf("EvtInvite ClearInviteScore error:%v snid:%v", err, snid)
+						return err
+					}
+					msg, err := get(snid)
+					if err != nil {
+						logger.Logger.Errorf("EvtInvite get error:%v snid:%v", err, snid)
+						return err
+					}
+					msg.Score = 0
+					mq.Send(model.EvtInviteAck, msg)
+				}
+				return nil
+			}
+
+			// 当前玩家积分是否跨周重置
+			tmpSnid := log.SnId
+			for i := 0; i < 6; i++ {
+				if tmpSnid > 0 {
+					err = reset(tmpSnid)
+					if err != nil {
+						logger.Logger.Errorf("EvtInvite reset %v error:%v snid:%v", i, err, tmpSnid)
+						return err
+					}
+				}
+				if tmpSnid > 0 {
+					tmpSnid, err = svc.GetPSnId(log.Platform, tmpSnid)
+					if err != nil {
+						logger.Logger.Errorf("EvtInvite GetPSnId %v error:%v snid:%v", i, err, tmpSnid)
+						return err
+					}
+				}
+			}
+
+			mongoClient, err := mongo.NewMongoClient()
+			if err != nil {
+				logger.Logger.Errorf("EvtInvite NewMongoClient error:%v", err)
+				return err
+			}
+			session, err := mongoClient.StartSession()
+			if err != nil {
+				logger.Logger.Errorf("EvtInvite StartSession error:%v", err)
+				return err
+			}
+			defer session.EndSession(context.Background())
+			// 事务不支持创建集合和索引，需要提前创建
+			svc.InviteScoreCollection(log.Platform)
+			svc.RankInviteCollection(log.Platform)
+
+			var notifySnId []int32
+			// 修改积分
+			err = newMongo.WithSession(context.Background(), session, func(sc newMongo.SessionContext) error {
+				err := session.StartTransaction()
+				if err != nil {
+					return err
+				}
+
+				// 增加积分
+				add := func(psnid, snid, level, tp int32, score, money, rate int64, addMoney bool) error {
+					if psnid <= 0 {
+						return nil
+					}
+					notifySnId = append(notifySnId, psnid)
+					err = svc.AddInviteScore(mongoClient, sc, log.Platform, psnid, snid, level, tp, score*rate/10000, rate, money, now, addMoney)
+					if err != nil {
+						logger.Logger.Errorf("EvtInvite add error:%v psnid:%v score:%v rate:%v", err, psnid, score, rate)
+						return err
+					}
+					return nil
+				}
+
+				getPSnId := func(platform string, snid int32) (int32, error) {
+					cfg, b := mongo.MgoSessionMgrSington.GetCfg(platform, svc.PlayerDBName)
+					if !b {
+						return 0, errors.New("not db")
+					}
+					playerDB := mongoClient.Database(cfg.Database)
+					type M struct {
+						PSnId int32
+					}
+					res := &M{}
+					c := playerDB.Collection(svc.PlayerCollName)
+					err = c.FindOne(context.TODO(), bson.D{{"snid", snid}}).Decode(res)
+					if err != nil && !errors.Is(err, newMongo.ErrNoDocuments) {
+						return 0, err
+					}
+					return res.PSnId, nil
+				}
+
+				switch log.Tp {
+				case common.InviteScoreTypeBind:
+					// 更新绑定数量
+					// 更新邀请积分
+					// 1.邀请人增加积分
+					err = add(log.InviteSnId, log.SnId, 0, log.Tp, log.Score, log.Money, 10000, false)
+					if err != nil {
+						session.AbortTransaction(sc)
+						return err
+					}
+					// 2.上级增加积分
+					var psnid int32
+					if len(log.Rate) > 0 {
+						psnid, err = getPSnId(log.Platform, log.InviteSnId)
+						if err != nil {
+							session.AbortTransaction(sc)
+							logger.Logger.Errorf("EvtInvite GetPSnId 2 error:%v snid:%v", err, log.InviteSnId)
+							return err
+						}
+						if psnid > 0 {
+							err = add(psnid, log.InviteSnId, 1, log.Tp, log.Score, log.Money, log.Rate[0], false)
+							if err != nil {
+								session.AbortTransaction(sc)
+								return err
+							}
+						}
+					}
+					if len(log.Rate) > 1 && psnid > 0 {
+						psnid, err = getPSnId(log.Platform, psnid)
+						if err != nil {
+							session.AbortTransaction(sc)
+							logger.Logger.Errorf("EvtInvite GetPSnId 2 error:%v snid:%v", err, log.InviteSnId)
+							return err
+						}
+						if psnid > 0 {
+							err = add(psnid, log.InviteSnId, 2, log.Tp, log.Score, log.Money, log.Rate[1], false)
+							if err != nil {
+								session.AbortTransaction(sc)
+								return err
+							}
+						}
+					}
+					if len(log.Rate) > 2 && psnid > 0 {
+						psnid, err = getPSnId(log.Platform, psnid)
+						if err != nil {
+							session.AbortTransaction(sc)
+							logger.Logger.Errorf("EvtInvite GetPSnId 3 error:%v snid:%v", err, log.InviteSnId)
+							return err
+						}
+						if psnid > 0 {
+							err = add(psnid, log.InviteSnId, 3, log.Tp, log.Score, log.Money, log.Rate[2], false)
+							if err != nil {
+								session.AbortTransaction(sc)
+								return err
+							}
+						}
+					}
+
+				case common.InviteScoreTypePay:
+					// 更新充值积分,上级积分增加
+					add(log.SnId, 0, 0, common.InviteScoreTypePayMe, log.Score, log.Money, 10000, false)
+					var psnid int32
+					if len(log.Rate) > 0 {
+						err = add(log.InviteSnId, log.SnId, 1, log.Tp, log.Score, log.Money, log.Rate[0], true)
+						if err != nil {
+							session.AbortTransaction(sc)
+							return err
+						}
+						psnid, err = getPSnId(log.Platform, log.InviteSnId)
+						if err != nil {
+							session.AbortTransaction(sc)
+							logger.Logger.Errorf("EvtInvite GetPSnId 3 error:%v snid:%v", err, log.InviteSnId)
+							return err
+						}
+					}
+					if len(log.Rate) > 1 && psnid > 0 {
+						err = add(psnid, log.SnId, 2, log.Tp, log.Score, log.Money, log.Rate[1], false)
+						if err != nil {
+							session.AbortTransaction(sc)
+							return err
+						}
+						psnid, err = getPSnId(log.Platform, psnid)
+						if err != nil {
+							session.AbortTransaction(sc)
+							logger.Logger.Errorf("EvtInvite GetPSnId 4 error:%v snid:%v", err, psnid)
+							return err
+						}
+					}
+					if len(log.Rate) > 2 && psnid > 0 {
+						err = add(psnid, log.SnId, 3, log.Tp, log.Score, log.Money, log.Rate[2], false)
+						if err != nil {
+							session.AbortTransaction(sc)
+							return err
+						}
+					}
+					if addRechargeScore {
+						err = add(log.InviteSnId, log.SnId, 1, common.InviteScoreTypeRecharge, log.RechargeScore, log.Money, 10000, true)
+						if err != nil {
+							session.AbortTransaction(sc)
+							return err
+						}
+					}
+
+				case common.InviteScoreTypeRecharge:
+					// 更新自己的积分
+					if addRechargeScore {
+						err = add(log.InviteSnId, log.SnId, 1, log.Tp, log.RechargeScore, log.Money, 10000, true)
+					} else {
+						// 只增加充值金额
+						err = add(log.InviteSnId, log.SnId, 0, log.Tp, 0, log.Money, 10000, true)
+					}
+					if err != nil {
+						session.AbortTransaction(sc)
+						return err
+					}
+
+				case common.InviteScoreCheckWeek:
+
+				default:
+					logger.Logger.Errorf("EvtInvite tp error, %v", log.Tp)
+					return err
+				}
+
+				// 提交事务
+				err = session.CommitTransaction(sc)
+				if err != nil {
+					logger.Logger.Errorf("EvtInvite CommitTransaction error:%v", err)
+					return err
+				}
+				return nil
 			})
+			if err != nil {
+				logger.Logger.Errorf("EvtInvite WithSession error:%v", err)
+				return err
+			}
+			// 通知变更
+			for _, v := range notifySnId {
+				msg, err := get(v)
+				if err != nil {
+					logger.Logger.Errorf("EvtInvite add find error:%v psnid:%v score:%v rate:%v", err, v, log.Score, log.Rate)
+					return err
+				}
+				mq.Send(model.EvtInviteAck, msg)
+			}
 
-			return
 		}
 		return nil
-	}, broker.Queue(model.EvtBindInvite), broker.DisableAutoAck(), rabbitmq.DurableQueue())
+	}, broker.Queue(model.EvtInvite), broker.DisableAutoAck(), rabbitmq.DurableQueue())
 }

dbproxy/mq/c_itemlog.go

@@ -2,11 +2,13 @@ package mq
 
 import (
 	"encoding/json"
+
+	"mongo.games.com/goserver/core/broker"
+	"mongo.games.com/goserver/core/broker/rabbitmq"
+	
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
-	"mongo.games.com/goserver/core/broker"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
 )
 
 func init() {
@@ -14,13 +16,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.ItemLog

dbproxy/mq/c_jackpotlog.go

@@ -1,31 +0,0 @@
-package mq
-
-//func init() {
-//	mq.RegisteSubscriber(model.JackPotLogCollName, func(e broker.Event) (err error) {
-//		msg := e.Message()
-//		if msg != nil {
-//			defer func() {
-//				if err != nil {
-//					mq.BackUp(e, err)
-//				}
-//
-//				e.Ack()
-//
-//				recover()
-//			}()
-//
-//			var log model.JackPotLog
-//			err = json.Unmarshal(msg.Body, &log)
-//			if err != nil {
-//				return
-//			}
-//
-//			c := svc.JackPotLogsCollection(log.Platform)
-//			if c != nil {
-//				_, err = c.Upsert(bson.M{"_id": log.LogId}, log)
-//			}
-//			return
-//		}
-//		return nil
-//	}, broker.Queue(model.JackPotLogCollName), broker.DisableAutoAck(), rabbitmq.DurableQueue())
-//}

dbproxy/mq/c_loginlog.go

@@ -2,11 +2,13 @@ package mq
 
 import (
 	"encoding/json"
+
+	"mongo.games.com/goserver/core/broker"
+	"mongo.games.com/goserver/core/broker/rabbitmq"
+
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
-	"mongo.games.com/goserver/core/broker"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
 )
 
 func init() {
@@ -14,13 +16,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.LoginLog

dbproxy/mq/c_onlinelog.go

@@ -16,13 +16,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.OnlineLog

dbproxy/mq/c_rank.go

@@ -2,14 +2,16 @@ package mq
 
 import (
 	"encoding/json"
-	"mongo.games.com/game/dbproxy/svc"
-	"mongo.games.com/game/model"
-	"mongo.games.com/game/mq"
+
 	"mongo.games.com/goserver/core"
 	"mongo.games.com/goserver/core/basic"
 	"mongo.games.com/goserver/core/broker"
 	"mongo.games.com/goserver/core/broker/rabbitmq"
 	"mongo.games.com/goserver/core/logger"
+
+	"mongo.games.com/game/dbproxy/svc"
+	"mongo.games.com/game/model"
+	"mongo.games.com/game/mq"
 )
 
 func init() {
@@ -18,13 +20,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.PlayerRankScore
@@ -53,13 +49,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.RankPlayerCoin
@@ -82,4 +72,61 @@ func init() {
 		}
 		return nil
 	}, broker.Queue(model.MQRankPlayerCoin), broker.DisableAutoAck(), rabbitmq.DurableQueue())
+
+	//等级榜
+	mq.RegisterSubscriber(model.MQRankPlayerLevel, func(e broker.Event) (err error) {
+		msg := e.Message()
+		if msg != nil {
+			defer func() {
+				e.Ack()
+			}()
+
+			var log model.PlayerLevelInfo
+			err = json.Unmarshal(msg.Body, &log)
+			if err != nil {
+				return
+			}
+
+			logger.Logger.Tracef("SubscriberRankPlayerLevel: %+v", log)
+
+			core.CoreObject().SendCommand(basic.CommandWrapper(func(o *basic.Object) error {
+				err := svc.RankPlayerLevelUpsert(&log)
+				if err != nil {
+					logger.Logger.Errorf("RankPlayerCoinUpsert err: %v", err)
+				}
+				return nil
+			}), true)
+
+			return
+		}
+		return nil
+	}, broker.Queue(model.MQRankPlayerLevel), broker.DisableAutoAck(), rabbitmq.DurableQueue())
+	// 赛季通行证积分
+	mq.RegisterSubscriber(model.MQRankPlayerPermit, func(e broker.Event) (err error) {
+		msg := e.Message()
+		if msg != nil {
+			defer func() {
+				e.Ack()
+			}()
+
+			var log model.PermitScore
+			err = json.Unmarshal(msg.Body, &log)
+			if err != nil {
+				return
+			}
+
+			logger.Logger.Tracef("SubscriberRankPlayerPermit: %+v", log)
+
+			core.CoreObject().SendCommand(basic.CommandWrapper(func(o *basic.Object) error {
+				err := svc.RankPlayerPermitUpsert(&log)
+				if err != nil {
+					logger.Logger.Errorf("RankPlayerPermitUpsert err: %v", err)
+				}
+				return nil
+			}), true)
+
+			return
+		}
+		return nil
+	}, broker.Queue(model.MQRankPlayerPermit), broker.DisableAutoAck(), rabbitmq.DurableQueue())
 }

dbproxy/mq/c_scenecoinlog.go

@@ -2,11 +2,13 @@ package mq
 
 import (
 	"encoding/json"
+
+	"mongo.games.com/goserver/core/broker"
+	"mongo.games.com/goserver/core/broker/rabbitmq"
+
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
-	"mongo.games.com/goserver/core/broker"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
 )
 
 func init() {
@@ -14,13 +16,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.SceneCoinLog

dbproxy/mq/c_vipgiftlog.go

@@ -0,0 +1,36 @@
+package mq
+
+import (
+	"encoding/json"
+
+	"mongo.games.com/goserver/core/broker"
+	"mongo.games.com/goserver/core/broker/rabbitmq"
+
+	"mongo.games.com/game/dbproxy/svc"
+	"mongo.games.com/game/model"
+	"mongo.games.com/game/mq"
+)
+
+func init() {
+	mq.RegisterSubscriber(mq.DBVipGiftLog, func(e broker.Event) (err error) {
+		msg := e.Message()
+		if msg != nil {
+			defer func() {
+				e.Ack()
+			}()
+
+			var log model.DbVip
+			err = json.Unmarshal(msg.Body, &log)
+			if err != nil {
+				return
+			}
+
+			c := svc.DbVipLogCollection(log.Platform)
+			if c != nil {
+				err = c.Insert(log)
+			}
+			return
+		}
+		return nil
+	}, broker.Queue(mq.DBVipGiftLog), broker.DisableAutoAck(), rabbitmq.DurableQueue())
+}

dbproxy/mq/c_welfarelog.go

@@ -3,11 +3,12 @@ package mq
 import (
 	"encoding/json"
 
+	"mongo.games.com/goserver/core/broker"
+	"mongo.games.com/goserver/core/broker/rabbitmq"
+
 	"mongo.games.com/game/dbproxy/svc"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
-	"mongo.games.com/goserver/core/broker"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
 )
 
 func init() {
@@ -15,13 +16,7 @@ func init() {
 		msg := e.Message()
 		if msg != nil {
 			defer func() {
-				if err != nil {
-					mq.BackUp(e, err)
-				}
-
 				e.Ack()
-
-				recover()
 			}()
 
 			var log model.WelfareLog

dbproxy/mq/publisher.go

@@ -1,33 +0,0 @@
-package mq
-
-import (
-	"mongo.games.com/game/common"
-	"mongo.games.com/game/mq"
-	"mongo.games.com/goserver/core"
-	"mongo.games.com/goserver/core/broker/rabbitmq"
-)
-
-var RabbitMQPublisher *mq.RabbitMQPublisher
-
-func init() {
-	////首先加载游戏配置
-	core.RegisteHook(core.HOOK_BEFORE_START, func() error {
-		//rabbitmq打开链接
-		RabbitMQPublisher = mq.NewRabbitMQPublisher(common.CustomConfig.GetString("RabbitMQURL"), rabbitmq.Exchange{Name: common.CustomConfig.GetString("RMQExchange"), Durable: true}, common.CustomConfig.GetInt("RMQPublishBacklog"))
-		if RabbitMQPublisher != nil {
-			err := RabbitMQPublisher.Start()
-			if err != nil {
-				panic(err)
-			}
-		}
-		return nil
-	})
-	core.RegisteHook(core.HOOK_AFTER_STOP, func() error {
-		//关闭rabbitmq连接
-		if RabbitMQPublisher != nil {
-			RabbitMQPublisher.Stop()
-		}
-
-		return nil
-	})
-}

dbproxy/svc/l_announcerlog.go

@@ -0,0 +1,90 @@
+package svc
+
+import (
+	"errors"
+	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+	"mongo.games.com/game/dbproxy/mongo"
+	"mongo.games.com/game/model"
+	"mongo.games.com/goserver/core/logger"
+	"net/rpc"
+)
+
+var (
+	AnnouncerLogDBErr = errors.New("log_announcerlog db open failed.")
+)
+
+func AnnouncerLogCollection(plt string) *mongo.Collection {
+	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, model.AnnouncerLogDBName)
+	if s != nil {
+		c, first := s.DB().C(model.AnnouncerLogCollName)
+		if first {
+		}
+		return c
+	}
+	return nil
+}
+
+func InsertAnnouncerLog(logs ...*model.AnnouncerLog) (err error) {
+	clog := AnnouncerLogCollection(logs[0].Platform)
+	if clog == nil {
+		return
+	}
+	switch len(logs) {
+	case 0:
+		return errors.New("no data")
+	case 1:
+		err = clog.Insert(logs[0])
+	default:
+		docs := make([]interface{}, 0, len(logs))
+		for _, log := range logs {
+			docs = append(docs, log)
+		}
+		err = clog.Insert(docs...)
+	}
+	if err != nil {
+		logger.Logger.Warn("InsertAnnouncerLog error:", err)
+		return
+	}
+	return
+}
+
+// 取最新100条数据
+func FetchAnnouncerLog(plt string) (recs []model.AnnouncerLog, err error) {
+	query := bson.M{}
+	err = AnnouncerLogCollection(plt).Find(query).Sort("-_id").Limit(100).All(&recs)
+	return
+}
+
+type AnnouncerLogSvc struct {
+}
+
+func (svc *AnnouncerLogSvc) InsertAnnouncerLog(args []*model.AnnouncerLog, ret *bool) (err error) {
+	err = InsertAnnouncerLog(args...)
+	if err == nil {
+		*ret = true
+	}
+	return
+}
+
+func (svc *AnnouncerLogSvc) FetchAnnouncerLog(args *model.FetchAnnouncerLogArgs, ret *[]model.AnnouncerLog) (err error) {
+	*ret, err = FetchAnnouncerLog(args.Plt)
+	return
+}
+
+func (svc *AwardLogSvc) UpsertAnnouncerLog(args *model.FetchAnnouncerLogArgs, ret *model.AnnouncerLog) error {
+	cc := AnnouncerLogCollection(args.Plt)
+	if cc == nil {
+		return nil
+	}
+	_, err := cc.Upsert(bson.M{"platform": args.Plt}, args.Data)
+	if err != nil && err != mgo.ErrNotFound {
+		logger.Logger.Error("UpsertAnnouncerLog is err: ", err)
+		return err
+	}
+	ret = args.Data
+	return nil
+}
+func init() {
+	rpc.Register(new(AnnouncerLogSvc))
+}

dbproxy/svc/l_awardlog.go

@@ -0,0 +1,56 @@
+package svc
+
+import (
+	"errors"
+	"github.com/globalsign/mgo/bson"
+	"mongo.games.com/game/dbproxy/mongo"
+	"mongo.games.com/game/model"
+	"mongo.games.com/goserver/core/logger"
+	"net/rpc"
+)
+
+var (
+	AwardLogDBErr = errors.New("log_awardlog db open failed.")
+)
+
+func AwardLogCollection(plt string) *mongo.Collection {
+	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, model.AwardLogDBName)
+	if s != nil {
+		c, first := s.DB().C(model.AwardLogCollName)
+		if first {
+		}
+		return c
+	}
+	return nil
+}
+
+func FetchAwardLog(plt string) (recs model.AwardLog, err error) {
+	err = AwardLogCollection(plt).Find(bson.M{}).One(&recs)
+	return
+}
+
+type AwardLogSvc struct {
+}
+
+func (svc *AwardLogSvc) FetchAwardLog(args *model.FetchAwardLogArgs, ret *model.AwardLog) (err error) {
+	*ret, err = FetchAwardLog(args.Plt)
+	return
+}
+
+func (svc *AwardLogSvc) UpsertAwardLog(args *model.FetchAwardLogArgs, ret *model.AwardLog) error {
+	cc := AwardLogCollection(args.Plt)
+	if cc == nil {
+		return AwardLogDBErr
+	}
+	_, err := cc.Upsert(bson.M{}, args.Data)
+	if err != nil {
+		logger.Logger.Error("UpsertAwardLog is err: ", err)
+		return err
+	}
+	ret = args.Data
+	return nil
+}
+
+func init() {
+	rpc.Register(new(AwardLogSvc))
+}

dbproxy/svc/l_coinlog.go

@@ -31,6 +31,8 @@ func CoinLogsCollection(plt string) *mongo.Collection {
 			c_coinlogrec.EnsureIndex(mgo.Index{Key: []string{"gamefreeid"}, Background: true, Sparse: true})
 			c_coinlogrec.EnsureIndex(mgo.Index{Key: []string{"cointype"}, Background: true, Sparse: true})
 			c_coinlogrec.EnsureIndex(mgo.Index{Key: []string{"ts"}, Background: true, Sparse: true})
+			c_coinlogrec.EnsureIndex(mgo.Index{Key: []string{"channel"}, Background: true, Sparse: true})
+			c_coinlogrec.EnsureIndex(mgo.Index{Key: []string{"-ts", "logtype", "cointype", "channel"}, Background: true, Sparse: true})
 		}
 		return c_coinlogrec
 	}

dbproxy/svc/l_dbshoplog.go

@@ -1,6 +1,7 @@
 package svc
 
 import (
+	"errors"
 	"github.com/globalsign/mgo"
 	"github.com/globalsign/mgo/bson"
 	"mongo.games.com/game/dbproxy/mongo"
@@ -18,6 +19,8 @@ func DbShopLogCollection(plt string) *mongo.Collection {
 			dbShopRec.EnsureIndex(mgo.Index{Key: []string{"pageid"}, Background: true, Sparse: true})
 			dbShopRec.EnsureIndex(mgo.Index{Key: []string{"state"}, Background: true, Sparse: true})
 			dbShopRec.EnsureIndex(mgo.Index{Key: []string{"shopid"}, Background: true, Sparse: true})
+			dbShopRec.EnsureIndex(mgo.Index{Key: []string{"ts"}, Background: true, Sparse: true})
+			dbShopRec.EnsureIndex(mgo.Index{Key: []string{"-ts"}, Background: true, Sparse: true})
 		}
 		return dbShopRec
 	}
@@ -98,6 +101,29 @@ func (svc *DbShopLogSvc) GetDbShopLogsByState(args *model.DbShopLogArgs, dbShops
 	}
 	return
 }
+
+func GetMoneyTotal(platform string, snid int32) int64 {
+	c := DbShopLogCollection(platform)
+	if c == nil {
+		logger.Logger.Error("UpdateDbShopState  == nil")
+		return 0
+	}
+	var err error
+	type m struct {
+		Total int64 `bson:"total"`
+	}
+	tc := new(m)
+	err = c.Pipe([]bson.M{
+		{"$match": bson.M{"snid": snid, "state": 1, "consumetypenum": bson.M{"$gt": 0}}},
+		{"$group": bson.M{"_id": nil, "total": bson.M{"$sum": "$consumetypenum"}}},
+	}).AllowDiskUse().One(tc)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		logger.Logger.Error("GetMoneyTotal error:", err)
+		return 0
+	}
+	return tc.Total
+}
+
 func init() {
 	rpc.Register(new(DbShopLogSvc))
 }

dbproxy/svc/l_friendapply.go

@@ -2,12 +2,14 @@ package svc
 
 import (
 	"errors"
+	"net/rpc"
+
 	"github.com/globalsign/mgo"
 	"github.com/globalsign/mgo/bson"
+	"mongo.games.com/goserver/core/logger"
+
 	"mongo.games.com/game/dbproxy/mongo"
 	"mongo.games.com/game/model"
-	"mongo.games.com/goserver/core/logger"
-	"net/rpc"
 )
 
 var (
@@ -16,6 +18,12 @@ var (
 	FriendApplyColError = errors.New("friendapply collection open failed")
 )
 
+var (
+	FriendApplyListDBName   = "log"
+	FriendApplyListCollName = "log_friendapplylist"
+	FriendApplyListColError = errors.New("friendapplylist collection open failed")
+)
+
 func FriendApplyCollection(plt string) *mongo.Collection {
 	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, FriendApplyDBName)
 	if s != nil {
@@ -28,6 +36,18 @@ func FriendApplyCollection(plt string) *mongo.Collection {
 	return nil
 }
 
+func FriendApplyListCollection(plt string) *mongo.Collection {
+	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, FriendApplyListDBName)
+	if s != nil {
+		c, first := s.DB().C(FriendApplyListCollName)
+		if first {
+			c.EnsureIndex(mgo.Index{Key: []string{"snid"}, Background: true, Sparse: true})
+		}
+		return c
+	}
+	return nil
+}
+
 type FriendApplySvc struct {
 }
 
@@ -71,6 +91,49 @@ func (svc *FriendApplySvc) DelFriendApply(args *model.FriendApplyByKey, ret *boo
 	return nil
 }
 
+func (svc *FriendApplySvc) UpsertApplyList(args *model.ApplyListReq, ret *model.ApplyListRes) error {
+	cc := FriendApplyListCollection(args.Platform)
+	if cc == nil {
+		return FriendApplyListColError
+	}
+	if args.Data == nil || args.Data.SnId <= 0 {
+		return nil
+	}
+	_, err := cc.Upsert(bson.M{"snid": args.Data.SnId}, args.Data)
+	if err != nil && err != mgo.ErrNotFound {
+		logger.Logger.Error("UpsertApplyList is err: ", err)
+		return err
+	}
+	ret.Data = args.Data
+	return nil
+}
+
+func (svc *FriendApplySvc) QueryFriendApplyListBySnid(args *model.FriendApplyByKey, ret *model.ApplyListRes) error {
+	fc := FriendApplyListCollection(args.Platform)
+	if fc == nil {
+		return FriendApplyListColError
+	}
+	err := fc.Find(bson.M{"snid": args.SnId}).One(&ret.Data)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		logger.Logger.Error("QueryFriendApplyListBySnid is err: ", err)
+		return err
+	}
+	return nil
+}
+
+func (svc *FriendApplySvc) DelFriendApplyList(args *model.FriendApplyByKey, ret *bool) error {
+	cc := FriendApplyListCollection(args.Platform)
+	if cc == nil {
+		return FriendApplyListColError
+	}
+	err := cc.Remove(bson.M{"snid": args.SnId})
+	if err != nil {
+		logger.Logger.Error("DelFriendApplyList is err: ", err)
+		return err
+	}
+	return nil
+}
+
 var _FriendApplySvc = &FriendApplySvc{}
 
 func init() {

dbproxy/svc/l_gamedetailed.go

@@ -18,11 +18,16 @@ func GameDetailedLogsCollection(plt string) *mongo.Collection {
 	if s != nil {
 		c_gamedetailed, first := s.DB().C(model.GameDetailedLogCollName)
 		if first {
+			c_gamedetailed.EnsureIndex(mgo.Index{Key: []string{"platform"}, Background: true, Sparse: true}) // 兼容老代码
 			c_gamedetailed.EnsureIndex(mgo.Index{Key: []string{"gameid"}, Background: true, Sparse: true})
 			c_gamedetailed.EnsureIndex(mgo.Index{Key: []string{"gamefreeid"}, Background: true, Sparse: true})
 			c_gamedetailed.EnsureIndex(mgo.Index{Key: []string{"logid"}, Background: true, Sparse: true})
 			c_gamedetailed.EnsureIndex(mgo.Index{Key: []string{"time"}, Background: true, Sparse: true})
+			c_gamedetailed.EnsureIndex(mgo.Index{Key: []string{"-time"}, Background: true, Sparse: true})
 			c_gamedetailed.EnsureIndex(mgo.Index{Key: []string{"ts"}, Background: true, Sparse: true})
+			c_gamedetailed.EnsureIndex(mgo.Index{Key: []string{"matchid"}, Background: true, Sparse: true})
+			c_gamedetailed.EnsureIndex(mgo.Index{Key: []string{"-ts", "gameid"}, Background: true, Sparse: true})
+			c_gamedetailed.EnsureIndex(mgo.Index{Key: []string{"-ts", "gamefreeid"}, Background: true, Sparse: true})
 		}
 		return c_gamedetailed
 	}

dbproxy/svc/l_gameplayerlistlog.go

@@ -8,9 +8,11 @@ import (
 
 	"github.com/globalsign/mgo"
 	"github.com/globalsign/mgo/bson"
+
 	"mongo.games.com/game/common"
 	"mongo.games.com/game/dbproxy/mongo"
 	"mongo.games.com/game/model"
+	"mongo.games.com/game/srvdata"
 	"mongo.games.com/goserver/core/logger"
 )
 
@@ -19,6 +21,7 @@ func GamePlayerListLogsCollection(plt string) *mongo.Collection {
 	if s != nil {
 		c_gameplayerlistlog, first := s.DB().C(model.GamePlayerListLogCollName)
 		if first {
+			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"platform"}, Background: true, Sparse: true}) // 兼容老代码
 			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"snid"}, Background: true, Sparse: true})
 			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"channel"}, Background: true, Sparse: true})
 			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"promoter"}, Background: true, Sparse: true})
@@ -30,7 +33,14 @@ func GamePlayerListLogsCollection(plt string) *mongo.Collection {
 			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"gamedetailedlogid"}, Background: true, Sparse: true})
 			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"ts"}, Background: true, Sparse: true})
 			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"time"}, Background: true, Sparse: true})
+			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"-time"}, Background: true, Sparse: true})
 			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"name"}, Background: true, Sparse: true})
+			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"matchid"}, Background: true, Sparse: true})
+			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"matchtype"}, Background: true, Sparse: true})
+			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"-ts", "gameid"}, Background: true, Sparse: true})
+			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"-ts", "gamefreeid"}, Background: true, Sparse: true})
+			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"-ts", "snid", "gameid"}, Background: true, Sparse: true})
+			c_gameplayerlistlog.EnsureIndex(mgo.Index{Key: []string{"-ts", "snid", "gamefreeid"}, Background: true, Sparse: true})
 		}
 		return c_gameplayerlistlog
 	}
@@ -454,7 +464,7 @@ func (svc *GamePlayerListSvc) GetWinCoinListTienlen(args *model.FindWinCoinListA
 	var tc []*M
 	err := c.Pipe([]bson.M{
 		{"$match": bson.M{
-			"gameid": bson.M{"$in": common.GetTienlenGameID()},
+			"gameid": bson.M{"$in": srvdata.GameFreeMgr.GetGameId(common.GameDifTienlen)},
 			"ts":     bson.M{"$gte": args.StartTs, "$lte": args.EndTs},
 		}},
 		{"$group": bson.M{
@@ -517,7 +527,7 @@ func (svc *GamePlayerListSvc) GetWinCoinTienlen(args *model.FindWinCoinArgs, ret
 	err := c.Pipe([]bson.M{
 		{"$match": bson.M{
 			"snid":   args.SnId,
-			"gameid": bson.M{"$in": common.GetTienlenGameID()},
+			"gameid": bson.M{"$in": srvdata.GameFreeMgr.GetGameId(common.GameDifTienlen)},
 			"ts":     bson.M{"$gte": args.StartTs, "$lte": args.EndTs},
 		}},
 		{"$group": bson.M{

dbproxy/svc/l_invitescore.go

@@ -0,0 +1,291 @@
+package svc
+
+import (
+	"errors"
+	"net/rpc"
+	"sort"
+	"time"
+
+	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+	"mongo.games.com/goserver/core/logger"
+
+	"mongo.games.com/game/common"
+	"mongo.games.com/game/dbproxy/mongo"
+	"mongo.games.com/game/model"
+)
+
+var (
+	InviteScoreDBName   = "log"
+	InviteScoreCollName = "log_invitescore"
+	InviteScoreColError = errors.New("InviteScore collection open failed")
+)
+
+func InviteScoreCollection(plt string) *mongo.Collection {
+	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, InviteScoreDBName)
+	if s != nil {
+		c, first := s.DB().C(InviteScoreCollName)
+		if first {
+			c.EnsureIndex(mgo.Index{Key: []string{"upsnid"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"downsnid"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"level"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"tp"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"ts"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"-ts"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"money"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"score"}, Background: true, Sparse: true})
+		}
+		return c
+	}
+
+	return nil
+}
+
+type BindScoreSvc struct {
+}
+
+func CheckInviteScore(req *model.InviteScore) (b bool, err error) {
+	logger.Logger.Tracef("SaveInviteScore req:%+v", *req)
+	if req.SnId == 0 {
+		return false, nil
+	}
+
+	u := PlayerDataCollection(req.Platform)
+	if u == nil {
+		return false, PlayerColError
+	}
+
+	// 不能重复绑定
+	//if req.Tp == common.InviteScoreTypeBind {
+	//	psnid, err := GetPSnId(req.Platform, req.SnId)
+	//	if err == nil && psnid > 0 {
+	//		// 已经绑定
+	//		return false, errors.New("already bind")
+	//	}
+	//}
+
+	// 必须已经绑定
+	if req.Tp != common.InviteScoreTypeBind {
+		psnid, err := GetPSnId(req.Platform, req.SnId)
+		if err != nil || psnid == 0 {
+			// 还没有绑定上级
+			logger.Logger.Errorf("not bind error:%v", err)
+			return false, err
+		}
+	}
+
+	// 充值成功记录
+	if (req.Tp == common.InviteScoreTypePay || req.Tp == common.InviteScoreTypeRecharge) && req.InviteSnId > 0 {
+		// 是否已经记录过
+		c := InviteScoreCollection(req.Platform)
+		if c == nil {
+			return false, InviteScoreColError
+		}
+		a := &model.LogInviteScore{}
+		err = c.Find(bson.M{"downsnid": req.SnId, "upsnid": req.InviteSnId, "tp": common.InviteScoreTypeRecharge}).One(a)
+		if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+			return false, errors.New("find error")
+		}
+		if err == nil && a.UpSnid > 0 {
+
+		} else {
+			b = true
+		}
+	}
+
+	return b, nil
+}
+
+// GetInviteRankList 获取周榜
+func (b *BindScoreSvc) GetInviteRankList(req *model.FindPlayerRankInviteListArgs, ret *model.FindPlayerRankInviteListReply) error {
+	c := RankInviteCollection(req.Platform)
+	if c == nil {
+		return RankInviteColError
+	}
+
+	ret.RankType = req.RankType
+
+	var st int64
+	switch req.RankType {
+	case 1: //todo 总榜
+		return nil
+	case 2: // 本周榜
+		st = common.GetWeekStartTs(time.Now().Unix())
+	case 3: //todo 月榜
+		return nil
+	case 4: // 上周榜
+		st = common.GetWeekStartTs(time.Now().Unix())
+		st -= 7 * 24 * 3600
+	}
+	var list []*model.RankInvite
+	err := c.Find(bson.M{"week": st}).Sort("-score").Limit(int(model.GameParamData.RankInviteMaxNum)).All(&list)
+	if err != nil {
+		logger.Logger.Errorf("GetInviteRankList error: %v", err)
+		return err
+	}
+
+	var conds []int32
+	if len(list) > 0 {
+		type PInfo struct {
+			SnId  int32
+			Name  string // 昵称
+			Roles *model.ModInfo
+		}
+		var retPlayerList []PInfo
+		cplayerdata := PlayerDataCollection(req.Platform)
+		if cplayerdata == nil {
+			return err
+		}
+
+		for i := 0; i < len(list); i++ {
+			conds = append(conds, list[i].SnId)
+		}
+
+		selecter := bson.M{"snid": bson.M{"$in": conds}}
+		err = cplayerdata.Find(selecter).Select(bson.M{"snid": 1, "name": 1, "roles": 1}).All(&retPlayerList)
+		if err != nil {
+			logger.Logger.Error("GetInviteRankList find player is error", err)
+			return err
+		}
+
+		for _, inviteInfo := range list {
+			for _, playerData := range retPlayerList {
+				if inviteInfo.SnId == playerData.SnId {
+					var RankInvite model.PlayerRankInvite
+					RankInvite.Name = playerData.Name
+					RankInvite.Score = inviteInfo.Score
+					RankInvite.SnId = inviteInfo.SnId
+
+					// 头像模型ID
+					roleId := common.DefaultRoleId
+					if playerData.Roles != nil {
+						roleId = int(playerData.Roles.ModId)
+					}
+					RankInvite.ModId = int32(roleId)
+
+					RankInvite.InviteNum = int32(inviteInfo.Num)
+					ret.List = append(ret.List, &RankInvite)
+					break
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+// GetInviteScoreByType 获取玩家排行信息
+func (b *BindScoreSvc) GetInviteScoreByType(req *model.FindPlayerRankInviteScoreArgs, ret *model.FindPlayerRankInviteScoreReply) error {
+	c := RankInviteCollection(req.Platform)
+	if c == nil {
+		return RankInviteColError
+	}
+
+	ret.RankType = req.RankType
+
+	var st int64
+	switch req.RankType {
+	case 1: //todo 总榜
+		return nil
+	case 2: // 本周榜
+		st = common.GetWeekStartTs(time.Now().Unix())
+	case 3: //todo 月榜
+		return nil
+	case 4: // 上周榜
+		st = common.GetWeekStartTs(time.Now().Unix())
+		st -= 7 * 24 * 3600
+	}
+	res := new(model.RankInvite)
+	err := c.Find(bson.M{"week": st, "snid": req.SnId}).One(res)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		logger.Logger.Warnf("GetInviteScoreByType error: %v", err)
+		return err
+	}
+
+	type PInfo struct {
+		SnId  int32
+		Name  string // 昵称
+		Roles *model.ModInfo
+	}
+
+	var retPlayer PInfo
+	u := PlayerDataCollection(req.Platform)
+	if u == nil {
+		return PlayerColError
+	}
+	err = u.Find(bson.M{"snid": req.SnId}).Select(bson.M{"snid": 1, "name": 1, "roles": 1}).One(&retPlayer)
+	if err != nil {
+		logger.Logger.Error("GetInviteScoreByType find player is error", err)
+		return err
+	}
+
+	// 头像模型ID
+	roleId := common.DefaultRoleId
+	if retPlayer.Roles != nil {
+		roleId = int(retPlayer.Roles.ModId)
+	}
+	ret.Data = model.PlayerRankInvite{
+		SnId:      req.SnId,
+		Score:     res.Score,
+		InviteNum: int32(res.Num),
+		Name:      retPlayer.Name,
+		ModId:     int32(roleId),
+	}
+	return nil
+}
+
+// GetInviteList 获取邀请列表
+func (b *BindScoreSvc) GetInviteList(req *model.InviteLisArgs, ret *model.InviteListRet) error {
+	c := PlayerDataCollection(req.Platform)
+	if c == nil {
+		return InviteScoreColError
+	}
+
+	type M struct {
+		Name       string
+		Roles      *model.ModInfo
+		CreateTime time.Time
+		SnId       int32
+		IScore     int64
+		IScoreTs   time.Time
+	}
+
+	var res []*M
+
+	err := c.Find(bson.M{"psnid": req.SnId}).Select(bson.M{"snid": 1, "iscore": 1, "iscorets": 1, "name": 1, "createtime": 1, "roles": 1}).All(&res)
+	if err != nil {
+		logger.Logger.Errorf("GetInviteList error:%v", err)
+		return err
+	}
+
+	now := time.Now().Local()
+	for _, v := range res {
+		if !common.InSameWeek(now, v.IScoreTs.Local()) {
+			v.IScore = 0
+		}
+		roleId := common.DefaultRoleId
+		if v.Roles != nil && v.Roles.ModId != 0 {
+			roleId = int(v.Roles.ModId)
+		}
+		ret.List = append(ret.List, &model.InviteInfo{
+			Name:     v.Name,
+			SnId:     v.SnId,
+			CreateTs: v.CreateTime.Unix(),
+			Score:    v.IScore,
+			ModId:    int32(roleId),
+		})
+	}
+	sort.Slice(ret.List, func(i, j int) bool {
+		return ret.List[i].Score > ret.List[j].Score
+	})
+
+	return nil
+}
+
+//todo 每周清理数据，绑定关系不能删除
+
+var GlobalBindScoreSvc = new(BindScoreSvc)
+
+func init() {
+	rpc.Register(GlobalBindScoreSvc)
+}

dbproxy/svc/l_itemlog.go

@@ -1,11 +1,16 @@
 package svc
 
 import (
+	"errors"
+	"net/rpc"
+
 	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+
+	"mongo.games.com/game/common"
 	"mongo.games.com/game/dbproxy/mongo"
 	"mongo.games.com/game/model"
 	"mongo.games.com/goserver/core/logger"
-	"net/rpc"
 )
 
 func ItemLogsCollection(plt string) *mongo.Collection {
@@ -13,8 +18,14 @@ func ItemLogsCollection(plt string) *mongo.Collection {
 	if s != nil {
 		c_itemlog, first := s.DB().C(model.ItemLogCollName)
 		if first {
-			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"snid"}, Background: true, Sparse: true})
-			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"platform"}, Background: true, Sparse: true})
+			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"logtype"}, Background: true, Sparse: true})
+			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"itemid"}, Background: true, Sparse: true})
+			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"createts"}, Background: true, Sparse: true})
+			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"-createts"}, Background: true, Sparse: true})
+			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"typeid"}, Background: true, Sparse: true})
+			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"gameid"}, Background: true, Sparse: true})
+			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"gamefreeid"}, Background: true, Sparse: true})
+			c_itemlog.EnsureIndex(mgo.Index{Key: []string{"snid", "logtype", "itemid", "typeid"}, Background: true, Sparse: true})
 		}
 		return c_itemlog
 	}
@@ -38,6 +49,68 @@ func (svc *ItemLogSvc) InsertItemLog(log *model.ItemLog, ret *bool) (err error)
 	return
 }
 
+// GetItemCount 获取v卡兑换消耗数量
+func GetItemCount(platform string, snid, id int32, tp int) (count int64) {
+	c := ItemLogsCollection(platform)
+	if c == nil {
+		return 0
+	}
+	var err error
+	var swapN int64
+	var costN int64
+	type m struct {
+		Count int64 `bson:"count"`
+	}
+	tc := new(m)
+	// 兑换返还
+	err = c.Pipe([]bson.M{
+		{"$match": bson.M{"snid": snid, "logtype": 0, "itemid": id, "typeid": common.GainWay_Exchange}},
+		{"$group": bson.M{"_id": nil, "count": bson.M{"$sum": "$count"}}},
+	}).AllowDiskUse().One(tc)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		logger.Logger.Warn("GetItemCount swapN error:", err)
+		return 0
+	}
+	swapN = tc.Count
+
+	// 消耗总数量
+	tc = new(m)
+	err = c.Pipe([]bson.M{
+		{"$match": bson.M{"snid": snid, "logtype": 1, "itemid": id, "typeid": common.GainWay_Exchange}},
+		{"$group": bson.M{"_id": nil, "count": bson.M{"$sum": "$count"}}},
+	}).AllowDiskUse().One(tc)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		logger.Logger.Warn("GetItemCount costN error:", err)
+		return 0
+	}
+	costN = tc.Count
+
+	if tp == 0 {
+		// 获得数量 = 获得总数量 - 兑换返还 - 比赛返回
+	} else {
+		// 消耗数量 = 消耗总数量 - 兑换返还
+		count = costN - swapN
+	}
+	if count < 0 {
+		count = 0
+	}
+	return count
+}
+
+func (svc *ItemLogSvc) GetItemCount(req *model.ItemCountParam, count *int64) error {
+	*count = GetItemCount(req.Platform, req.Snid, req.Id, req.Tp)
+	return nil
+}
+
+func (svc *ItemLogSvc) UpdateState(req *model.UpdateParam, res *model.UpdateRes) error {
+	c := ItemLogsCollection(req.Platform)
+	if c == nil {
+		return nil
+	}
+	err := c.UpdateId(req.LogId, bson.M{"$set": bson.M{"status": req.State}})
+	return err
+}
+
 func init() {
 	rpc.Register(new(ItemLogSvc))
 }

dbproxy/svc/l_matchawardlog.go

@@ -0,0 +1,67 @@
+package svc
+
+import (
+	"errors"
+	"github.com/globalsign/mgo/bson"
+	"mongo.games.com/game/dbproxy/mongo"
+	"mongo.games.com/game/model"
+	"net/rpc"
+)
+
+var (
+	MatchAwardLogDBErr = errors.New("log_matchawardlog db open failed.")
+)
+
+func MatchAwardLogCollection(plt string) *mongo.Collection {
+	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, model.MatchAwardLogDBName)
+	if s != nil {
+		c, _ := s.DB().C(model.MatchAwardLogCollName)
+		return c
+	}
+	return nil
+}
+
+func InsertOrUpdateMatchAwardLog(logs ...*model.MatchAwardLog) (err error) {
+	for _, log := range logs {
+		clog := MatchAwardLogCollection(log.Platform)
+		if clog == nil {
+			return
+		}
+		_, err = clog.Upsert(nil, log)
+		if err != nil {
+			// 处理错误
+			return err
+		}
+	}
+	return
+}
+
+type MatchAwardLogSvc struct {
+}
+
+func (svc *MatchAwardLogSvc) InsertOrUpdateMatchAwardLog(args []*model.MatchAwardLog, ret *bool) (err error) {
+	err = InsertOrUpdateMatchAwardLog(args...)
+	if err == nil {
+		*ret = true
+	}
+	return
+}
+func GetMatchAward(plt string, ret *model.MatchAwardLog) (err error) {
+	clog := MatchAwardLogCollection(plt)
+	if clog == nil {
+		return nil
+	}
+	selecter := bson.M{"platform": plt}
+	err = clog.Find(selecter).One(&ret)
+	if err != nil {
+		return nil
+	}
+	return
+}
+func (svc *MatchAwardLogSvc) GetMatchAward(Plt string, ret *model.MatchAwardLog) (err error) {
+	err = GetMatchAward(Plt, ret)
+	return err
+}
+func init() {
+	rpc.Register(new(MatchAwardLogSvc))
+}

dbproxy/svc/l_matchlog.go

@@ -22,6 +22,12 @@ func MatchLogCollection(plt string) *mongo.Collection {
 		c, first := s.DB().C(model.MatchLogCollName)
 		if first {
 			c.EnsureIndex(mgo.Index{Key: []string{"gamefreeid"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"matchid"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"starttime"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"-starttime"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"endtime"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"-endtime"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"sortid"}, Background: true, Sparse: true})
 		}
 		return c
 	}

dbproxy/svc/l_rankinvite.go

@@ -0,0 +1,55 @@
+package svc
+
+import (
+	"errors"
+
+	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+	"mongo.games.com/goserver/core/logger"
+
+	"mongo.games.com/game/common"
+	"mongo.games.com/game/dbproxy/mongo"
+	"mongo.games.com/game/model"
+)
+
+var (
+	RankInviteDBName   = "log"
+	RankInviteCollName = "log_rankinvite"
+	RankInviteColError = errors.New("RankInvite collection open failed")
+)
+
+func RankInviteCollection(plt string) *mongo.Collection {
+	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, RankInviteDBName)
+	if s != nil {
+		c, first := s.DB().C(RankInviteCollName)
+		if first {
+			c.EnsureIndex(mgo.Index{Key: []string{"snid"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"num"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"-score"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"score"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"ts"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"week", "-score"}, Background: true, Sparse: true})
+		}
+		return c
+	}
+
+	return nil
+}
+
+func SaveRankInvite(data *model.RankInvite) error {
+	c := RankInviteCollection(data.Platform)
+	if c == nil {
+		return RankInviteColError
+	}
+
+	data.Week = common.GetWeekStartTs(data.Ts)
+
+	_, err := c.Upsert(bson.M{"snid": data.SnId, "week": data.Week}, data)
+	if err != nil {
+		logger.Logger.Tracef("SaveRankInvite error:%v", err)
+		return err
+	}
+	return nil
+}
+
+//todo 每周清理数据

dbproxy/svc/l_rankplayercoin.go

@@ -23,7 +23,7 @@ func RankPlayerCoinCollection(plt string) *mongo.Collection {
 		c, first := s.DB().C(RankPlayerCoinCollName)
 		if first {
 			c.EnsureIndex(mgo.Index{Key: []string{"snid"}, Background: true, Sparse: true})
-			c.EnsureIndex(mgo.Index{Key: []string{"coin"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"-coin"}, Background: true, Sparse: true})
 		}
 		return c
 	}

dbproxy/svc/l_rankplayerlevel.go

@@ -0,0 +1,72 @@
+package svc
+
+import (
+	"errors"
+	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+	"mongo.games.com/game/dbproxy/mongo"
+	"mongo.games.com/game/model"
+	"mongo.games.com/goserver/core/logger"
+	"net/rpc"
+)
+
+var (
+	RankPlayerLevelDBName   = "log"
+	RankPlayerLevelCollName = "log_rankplayerlevel"
+	RankPlayerLevelColError = errors.New("RankPlayerLevel collection open failed")
+)
+
+func RankPlayerLevelCollection(plt string) *mongo.Collection {
+	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, RankPlayerLevelDBName)
+	if s != nil {
+		c, first := s.DB().C(RankPlayerLevelCollName)
+		if first {
+			c.EnsureIndex(mgo.Index{Key: []string{"snid"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"-exp"}, Background: true, Sparse: true})
+		}
+		return c
+	}
+	return nil
+}
+
+func RankPlayerLevelUpsert(args *model.PlayerLevelInfo) error {
+	cc := RankPlayerLevelCollection(args.Platform)
+	if cc == nil {
+		return RankPlayerLevelColError
+	}
+	_, err := cc.Upsert(bson.M{"snid": args.SnId}, args)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		logger.Logger.Error("RankPlayerCoinSvc.Upsert is err: ", err)
+		return err
+	}
+	return nil
+}
+
+type RankPlayerLevelSvc struct {
+}
+
+func (svc *RankPlayerLevelSvc) Upsert(args *model.PlayerLevelInfo, ret *bool) error {
+	err := RankPlayerLevelUpsert(args)
+	if err != nil {
+		return err
+	}
+	*ret = true
+	return nil
+}
+
+func (svc *RankPlayerLevelSvc) Find(args *model.FindPlayerLevelListArgs, ret *model.FindPlayerLevelListReply) error {
+	fc := RankPlayerLevelCollection(args.Platform)
+	if fc == nil {
+		return RankPlayerCoinColError
+	}
+
+	err := fc.Find(bson.M{}).Sort("-exp").Limit(model.GameParamData.RankPlayerLevelMaxNum).All(&ret.List)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		logger.Logger.Error("QueryMatchSeason is err: ", err)
+		return err
+	}
+	return nil
+}
+func init() {
+	rpc.Register(new(RankPlayerLevelSvc))
+}

dbproxy/svc/l_rankplayerpermit.go

@@ -0,0 +1,72 @@
+package svc
+
+import (
+	"errors"
+	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+	"mongo.games.com/game/dbproxy/mongo"
+	"mongo.games.com/game/model"
+	"mongo.games.com/goserver/core/logger"
+	"net/rpc"
+)
+
+var (
+	RankPlayerPermitDBName   = "log"
+	RankPlayerPermitCollName = "log_rankplayerpermit"
+	RankPlayerPermitColError = errors.New("RankPlayerPermit collection open failed")
+)
+
+func RankPlayerPermitCollection(plt string) *mongo.Collection {
+	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, RankPlayerPermitDBName)
+	if s != nil {
+		c, first := s.DB().C(RankPlayerPermitCollName)
+		if first {
+			c.EnsureIndex(mgo.Index{Key: []string{"snid"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"startts", "-exp", "-ts"}, Background: true, Sparse: true})
+		}
+		return c
+	}
+	return nil
+}
+
+func RankPlayerPermitUpsert(args *model.PermitScore) error {
+	cc := RankPlayerPermitCollection(args.Platform)
+	if cc == nil {
+		return RankPlayerPermitColError
+	}
+	_, err := cc.Upsert(bson.M{"startts": args.StartTs, "snid": args.SnId}, args)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		logger.Logger.Error("RankPlayerPermitSvc.Upsert is err: ", err)
+		return err
+	}
+	return nil
+}
+
+type RankPlayerPermitSvc struct {
+}
+
+func (svc *RankPlayerPermitSvc) Upsert(args *model.PermitScore, ret *bool) error {
+	err := RankPlayerPermitUpsert(args)
+	if err != nil {
+		return err
+	}
+	*ret = true
+	return nil
+}
+
+func (svc *RankPlayerPermitSvc) Find(args *model.FindPlayerPermitListArgs, ret *model.FindPlayerPermitListReply) error {
+	fc := RankPlayerPermitCollection(args.Platform)
+	if fc == nil {
+		return RankPlayerPermitColError
+	}
+
+	err := fc.Find(bson.M{"startts": args.StartTs}).Sort("-exp", "-ts").Limit(int(model.GameParamData.RankPlayerPermitMaxNum)).All(&ret.List)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		logger.Logger.Error("QueryPermit is err: ", err)
+		return err
+	}
+	return nil
+}
+func init() {
+	rpc.Register(new(RankPlayerPermitSvc))
+}

dbproxy/svc/l_rankseasion.go

@@ -26,7 +26,7 @@ func RankSeasonCollection(plt string, rankType int32) *mongo.Collection {
 		c, first := s.DB().C(fmt.Sprintf("%s_%d", RankSeasonCollName, rankType))
 		if first {
 			c.EnsureIndex(mgo.Index{Key: []string{"snid"}, Background: true, Sparse: true})
-			c.EnsureIndex(mgo.Index{Key: []string{"isrobot", "seasonid", "score"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"isrobot", "seasonid", "-score"}, Background: true, Sparse: true})
 		}
 		return c
 	}

dbproxy/svc/u_account.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"io"
 	"net/rpc"
+	"strings"
 	"time"
 
 	"github.com/globalsign/mgo"
@@ -59,6 +60,11 @@ func (svc *AccountSvc) AccountIsExist(args *model.AccIsExistArg, ret *model.AccR
 	}
 
 	acc := &model.Account{}
+	defer func() {
+		// 修改旧数据
+		// 补充渠道信息
+		svc.setParam(acc)
+	}()
 
 	switch args.LoginType {
 	case common.LoginTypeGuest:
@@ -103,10 +109,30 @@ func (svc *AccountSvc) AccountIsExist(args *model.AccIsExistArg, ret *model.AccR
 		err := caccounts.Find(bson.M{"tel": args.Tel, "tagkey": args.TagKey}).One(acc)
 		if err != nil {
 			if errors.Is(err, mgo.ErrNotFound) {
-				ret.Tag = common.LoginNew
-				return nil
+				// 兼容8550开头的手机号,8550和855算同一个区号
+				if strings.HasPrefix(args.Tel, "855") {
+					tel := make([]byte, len(args.Tel)+1)
+					copy(tel, "8550")
+					copy(tel[4:], args.Tel[3:])
+					err = caccounts.Find(bson.M{"tel": string(tel), "tagkey": args.TagKey}).One(acc)
+					if err != nil {
+						if errors.Is(err, mgo.ErrNotFound) {
+							ret.Tag = common.LoginNew
+							return nil
+						} else {
+							return err
+						}
+					} else {
+						acc.Tel = args.Tel
+						caccounts.Update(bson.M{"_id": acc.AccountId}, bson.D{{"$set", bson.D{{"tel", args.Tel}}}})
+					}
+				} else {
+					ret.Tag = common.LoginNew
+					return nil
+				}
+			} else {
+				return err
 			}
-			return err
 		}
 
 		if args.CodeValid {
@@ -229,6 +255,35 @@ func (svc *AccountSvc) AccountIsExist(args *model.AccIsExistArg, ret *model.AccR
 	return nil
 }
 
+func (svc *AccountSvc) setParam(acc *model.Account) {
+	if acc == nil || (acc.Channel != "" && acc.Channel != "0") {
+		return
+	}
+
+	c := PlayerDataCollection(acc.Platform)
+	if c == nil {
+		return
+	}
+	p := new(model.PlayerData)
+	err := c.Find(bson.M{"snid": acc.SnId}).One(p)
+	if err != nil {
+		logger.Logger.Errorf("setChannel error:%v", err)
+		return
+	}
+
+	c = AccountCollection(acc.Platform)
+	if c == nil {
+		return
+	}
+	acc.Channel = p.Channel
+	if acc.Channel != "" {
+		err = c.Update(bson.M{"_id": acc.AccountId}, bson.D{{"$set", bson.D{{"channel", acc.Channel}}}})
+		if err != nil {
+			logger.Logger.Errorf("setChannel error:%v", err)
+		}
+	}
+}
+
 func (svc *AccountSvc) AccountTelIsRegiste(args *model.AccIsExistArg, exist *bool) error {
 	caccounts := AccountCollection(args.Platform)
 	if caccounts != nil {
@@ -446,22 +501,22 @@ func (svc *AccountSvc) EditAccountPwd(acc *model.Account, ret *model.AccRet) err
 	return caccounts.Update(bson.M{"_id": acc.AccountId}, bson.D{{"$set", bson.D{{"backpassword", acc.TelPassWord}, {"telpassword", hashsum}}}})
 }
 
-func (svc *AccountSvc) ResetBackAccountPwd(args *model.AccIdArg, ret *model.AccRet) error {
-	caccounts := AccountCollection(args.Platform)
-	if caccounts == nil {
-		return ErrAccDBNotOpen
-	}
-
-	var acc model.Account
-	err := caccounts.Find(bson.M{"_id": bson.ObjectIdHex(args.AccId)}).One(&acc)
-	if err != nil {
-		return err
-	}
-	if len(acc.BackPassWord) > 0 {
-		return caccounts.Update(bson.M{"_id": acc.AccountId}, bson.D{{"$set", bson.D{{"telpassword", acc.BackPassWord}}}})
-	}
-	return nil
-}
+//func (svc *AccountSvc) ResetBackAccountPwd(args *model.AccIdArg, ret *model.AccRet) error {
+//	caccounts := AccountCollection(args.Platform)
+//	if caccounts == nil {
+//		return ErrAccDBNotOpen
+//	}
+//
+//	var acc model.Account
+//	err := caccounts.Find(bson.M{"_id": bson.ObjectIdHex(args.AccId)}).One(&acc)
+//	if err != nil {
+//		return err
+//	}
+//	if len(acc.BackPassWord) > 0 {
+//		return caccounts.Update(bson.M{"_id": acc.AccountId}, bson.D{{"$set", bson.D{{"telpassword", acc.BackPassWord}}}})
+//	}
+//	return nil
+//}
 
 /*
  * 修改帐号密码
@@ -506,7 +561,7 @@ func (svc *AccountSvc) UpdateAccountPlatformInfo(acc *model.Account, ret *model.
 
 	return caccounts.Update(bson.M{"_id": acc.AccountId},
 		bson.D{{"$set", bson.M{"platform": acc.Platform,
-			"channel": acc.Channel, "promoter": acc.Promoter, "inviterid": acc.InviterId, "packegetag": acc.PackegeTag, "promotertree": acc.PromoterTree}}})
+			"channel": acc.Channel, "packegetag": acc.PackegeTag}}})
 }
 
 func (svc *AccountSvc) GetRobotAccounts(limit int, accs *[]model.Account) error {

dbproxy/svc/u_bag.go

@@ -7,9 +7,11 @@ import (
 
 	"github.com/globalsign/mgo"
 	"github.com/globalsign/mgo/bson"
+	"mongo.games.com/goserver/core/logger"
+
+	"mongo.games.com/game/common"
 	"mongo.games.com/game/dbproxy/mongo"
 	"mongo.games.com/game/model"
-	"mongo.games.com/goserver/core/logger"
 )
 
 var (
@@ -95,22 +97,42 @@ func (svc *BagSvc) AddBagItem(args *model.BagInfo, ret *bool) error {
 	if bag.BagId == "" {
 		bag.BagId = bson.NewObjectId()
 	}
+	var vCard int64 // v卡返还
 	for id, v := range args.BagItem {
 		if item, exist := bag.BagItem[id]; !exist {
+			if v.ItemNum <= 0 {
+				continue
+			}
 			bag.BagItem[id] = &model.Item{
 				ItemId:     v.ItemId,
 				ItemNum:    v.ItemNum,
 				ObtainTime: time.Now().Unix(),
 			}
 		} else {
+			if v.ItemNum < 0 && -v.ItemNum > item.ItemNum {
+				v.ItemNum = -item.ItemNum
+			}
 			item.ItemNum += v.ItemNum
 		}
+		// v卡返还
+		if id == common.ItemIDVCard && args.GainWay == common.GainWay_Exchange && v.ItemNum > 0 {
+			vCard = v.ItemNum
+		}
 	}
 	_, err = cbag.Upsert(bson.M{"_id": bag.BagId}, bag)
 	if err != nil {
 		*ret = false
 		logger.Logger.Info("AddBagItem error ", err)
 	}
+
+	// v卡返还
+	if vCard > 0 {
+		c := PlayerDataCollection(args.Platform)
+		if c != nil {
+			err = c.Update(bson.M{"snid": args.SnId}, bson.M{"$inc": bson.M{"vcardcost": -vCard}})
+		}
+	}
+
 	return err
 }
 

dbproxy/svc/u_gamedata.go

@@ -53,6 +53,16 @@ func (svc *GameKVDataSvc) UptGameKVData(args *model.GameKVData, ret *bool) error
 	return nil
 }
 
+func (svc *GameKVDataSvc) GetGameKVData(args *model.GameKVData, ret *model.GameKVData) error {
+	c := GameKVDatasCollection()
+	if c != nil {
+		err := c.Find(bson.M{"key": args.Key}).One(ret)
+		logger.Logger.Tracef("GetGameKVData: %#v %v", ret, err)
+		return err
+	}
+	return nil
+}
+
 var _GameKVDataSvc = &GameKVDataSvc{}
 
 func init() {

dbproxy/svc/u_invitecode.go

@@ -21,7 +21,7 @@ import (
 
 var (
 	InviteCodeDBName   = "user"
-	InviteCodeCollName = "user_invitecode"
+	InviteCodeCollName = "user_icode"
 	InviteCodeColError = errors.New("InviteCode collection open failed")
 	InviteCodeMutex    = sync.Mutex{}
 )
@@ -105,6 +105,19 @@ func (i *InviteCodeSvc) GetSnIdByCode(req *model.InviteSnIdReq, ret *model.Invit
 	return nil
 }
 
+func GetCodeBySnId(platform string, snid int32) (string, error) {
+	c := InviteCodeCollection(platform)
+	if c == nil {
+		return "", InviteCodeColError
+	}
+	col := new(model.InviteCode)
+	err := c.Find(bson.M{"snid": snid}).One(col)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		return "", err
+	}
+	return col.Code, err
+}
+
 func init() {
 	rpc.Register(new(InviteCodeSvc))
 }

dbproxy/svc/u_invitescore.go

@@ -1,325 +0,0 @@
-package svc
-
-import (
-	"errors"
-	"net/rpc"
-	"time"
-
-	"github.com/globalsign/mgo"
-	"github.com/globalsign/mgo/bson"
-	"mongo.games.com/goserver/core/logger"
-
-	"mongo.games.com/game/common"
-	"mongo.games.com/game/dbproxy/mongo"
-	"mongo.games.com/game/model"
-	rankproto "mongo.games.com/game/protocol/rank"
-)
-
-var (
-	InviteScoreDBName   = "user"
-	InviteScoreCollName = "user_invitescore"
-	InviteScoreColError = errors.New("InviteScore collection open failed")
-)
-
-func InviteScoreCollection(plt string) *mongo.Collection {
-	s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, InviteScoreDBName)
-	if s != nil {
-		c, first := s.DB().C(InviteScoreCollName)
-		if first {
-			c.EnsureIndex(mgo.Index{Key: []string{"snid"}, Background: true, Sparse: true})
-			c.EnsureIndex(mgo.Index{Key: []string{"invitesnid"}, Background: true, Sparse: true})
-			c.EnsureIndex(mgo.Index{Key: []string{"tp"}, Background: true, Sparse: true})
-			c.EnsureIndex(mgo.Index{Key: []string{"ts"}, Background: true, Sparse: true})
-		}
-		return c
-	}
-
-	return nil
-}
-
-type BindScoreSvc struct {
-}
-
-func (b *BindScoreSvc) GetInviteScore(req *model.InviteScoreReq, ret *model.InviteScoreRet) error {
-	c := InviteScoreCollection(req.Platform)
-	if c == nil {
-		return InviteScoreColError
-	}
-
-	type M struct {
-		Score int64
-	}
-
-	var tc []M
-	err := c.Pipe([]bson.M{
-		{"$match": bson.M{
-			"invitesnid": req.SnId,
-		}},
-		{"$group": bson.M{
-			"_id":   nil,
-			"score": bson.M{"$sum": "$score"},
-		}},
-	}).AllowDiskUse().All(&tc)
-	if err != nil {
-		logger.Logger.Error("GetInviteScore AllowDiskUse is error", err)
-		return err
-	}
-
-	if len(tc) > 0 {
-		ret.Score = tc[0].Score
-		c := PlayerDataCollection(req.Platform)
-		if c == nil {
-			return PlayerColError
-		}
-		err = c.Update(bson.M{"snid": req.SnId}, bson.M{"$set": bson.M{"invitescore": tc[0].Score}})
-		if err != nil {
-			logger.Logger.Error("GetInviteScore update invitescore is error", err)
-			return err
-		}
-	}
-
-	tc = tc[:0]
-	err = c.Pipe([]bson.M{
-		{"$match": bson.M{
-			"invitesnid": req.SnId,
-			"score":      bson.M{"$gt": 0},
-		}},
-		{"$group": bson.M{
-			"_id":   nil,
-			"score": bson.M{"$sum": "$score"},
-		}},
-	}).AllowDiskUse().All(&tc)
-	if err != nil {
-		logger.Logger.Error("GetInviteScore z AllowDiskUse is error", err)
-		return err
-	}
-
-	if len(tc) > 0 {
-		ret.ZScore = tc[0].Score
-	}
-
-	return nil
-}
-
-func (b *BindScoreSvc) SaveInviteScore(req *model.InviteScore, ret *bool) error {
-	logger.Logger.Tracef("SaveInviteScore req:%+v", *req)
-	if req.InviteSnId == 0 {
-		return nil
-	}
-	req.Id = bson.NewObjectId()
-	u := PlayerDataCollection(req.Platform)
-	if u == nil {
-		return PlayerColError
-	}
-
-	type M struct {
-		InviteScore int64
-	}
-	r := new(M)
-	err := u.Find(bson.M{"snid": req.InviteSnId}).Select(bson.M{"invitescore": 1}).One(r)
-	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
-		logger.Logger.Errorf("GetInviteScore Find error:%v", err)
-		return err
-	}
-
-	if req.Score < 0 {
-		if -req.Score > r.InviteScore {
-			req.Score = -r.InviteScore
-		}
-	}
-
-	c := InviteScoreCollection(req.Platform)
-	if c == nil {
-		return InviteScoreColError
-	}
-
-	err = c.Insert(req)
-	if err != nil {
-		logger.Logger.Errorf("SaveInviteScore Insert error:%v", err)
-		return err
-	}
-
-	err = u.Update(bson.M{"snid": req.InviteSnId}, bson.M{"$inc": bson.M{"invitescore": req.Score}})
-	if err != nil {
-		logger.Logger.Errorf("inc InviteScore error:%v", err)
-		return err
-	}
-
-	*ret = true
-	return nil
-}
-
-func (b *BindScoreSvc) GetInviteRankList(req *model.FindPlayerRankInviteListArgs, ret *model.FindPlayerRankInviteListReply) error {
-	c := InviteScoreCollection(req.Platform)
-	if c == nil {
-		return InviteScoreColError
-	}
-
-	NowTime := time.Now().Local()
-	endTime := NowTime.UnixNano()
-	startTime := NowTime.AddDate(-100, 0, 0).UnixNano()
-
-	year, month, day := NowTime.Date()
-	today := time.Date(year, month, day, 0, 0, 0, 0, time.Local)
-	if req.RankType == int32(rankproto.RankInvite_InviteType_Week) {
-		// 本周起始日期（周日）
-		startTime = today.AddDate(0, 0, -int(today.Weekday())).UnixNano()
-	} else if req.RankType == int32(rankproto.RankInvite_InviteType_Month) {
-		// 本月起始日期
-		startTime = time.Date(year, month, 1, 0, 0, 0, 0, time.Local).UnixNano()
-		//startTime = NowTime.AddDate(0, 0, -NowTime.Day()+1).UnixNano()
-	}
-
-	type M struct {
-		InviteSnId int32 // 邀请人id
-		Score      int64 // 积分
-	}
-
-	var tc []M
-	err := c.Pipe([]bson.M{
-		{"$match": bson.M{
-			"score": bson.M{"$gt": 0},
-			"ts":    bson.M{"$gte": startTime, "$lte": endTime},
-		}},
-		{"$group": bson.M{
-			"_id": bson.M{
-				"invitesnid": "$invitesnid",
-			},
-			"invitesnid": bson.M{"$first": "$invitesnid"},
-			"score":      bson.M{"$sum": "$score"},
-		}},
-		{
-			"$sort": bson.M{"ts": -1},
-		},
-		{
-			"$sort": bson.M{"score": -1},
-		},
-		{
-			"$limit": model.GameParamData.RankInviteMaxNum,
-		},
-	}).AllowDiskUse().All(&tc)
-	if err != nil {
-		logger.Logger.Error("GetInviteRankList z AllowDiskUse is error", err)
-		return err
-	}
-
-	var conds []int32
-	if len(tc) > 0 {
-
-		type PInfo struct {
-			SnId  int32
-			Name  string // 昵称
-			Roles *model.RolePetInfo
-		}
-
-		var retPlayerList []PInfo
-
-		cplayerdata := PlayerDataCollection(req.Platform)
-		if cplayerdata == nil {
-			return err
-		}
-
-		for i := 0; i < len(tc); i++ {
-			conds = append(conds, tc[i].InviteSnId)
-		}
-
-		selecter := bson.M{"snid": bson.M{"$in": conds}}
-		//err = cplayerdata.Find(selecter).Select(bson.M{"snid": 1, "name": 1, "roles": 1}).All(&retPlayerList)
-		err = cplayerdata.Find(selecter).Select(bson.M{"snid": 1, "name": 1, "roles": 1}).All(&retPlayerList)
-		if err != nil {
-			logger.Logger.Error("svc.FindInvitePlayerList is error", err)
-			return nil
-		}
-
-		for _, inviteInfo := range tc {
-			for _, playerData := range retPlayerList {
-				if inviteInfo.InviteSnId == playerData.SnId {
-					var RankInvite model.PlayerRankInvite
-					RankInvite.Name = playerData.Name
-					RankInvite.Score = inviteInfo.Score
-					RankInvite.SnId = inviteInfo.InviteSnId
-
-					// 头像模型ID
-					roleId := common.DefaultRoleId
-					if playerData.Roles != nil {
-						roleId = int(playerData.Roles.ModId)
-					}
-					RankInvite.ModId = int32(roleId)
-
-					RankInvite.InviteNum, _ = GetInviteNum(req.Platform, inviteInfo.InviteSnId)
-					ret.List = append(ret.List, &RankInvite)
-
-					break
-				}
-			}
-		}
-		ret.RankType = req.RankType
-	}
-
-	return nil
-}
-
-func (b *BindScoreSvc) GetInviteList(req *model.InviteLisArgs, ret *model.InviteListRet) error {
-	c := InviteScoreCollection(req.Platform)
-	if c == nil {
-		return InviteScoreColError
-	}
-
-	type M struct {
-		SnId  int32
-		Score int64
-	}
-
-	var tc []M
-	err := c.Pipe([]bson.M{
-		{"$match": bson.M{
-			"invitesnid": req.SnId,
-		}},
-		{"$group": bson.M{
-			"_id": bson.M{
-				"snid": "$snid",
-			},
-			"snid":  bson.M{"$first": "$snid"},
-			"score": bson.M{"$sum": "$score"},
-		}},
-		{
-			"$sort": bson.M{
-				"score": -1,
-			},
-		},
-	}).AllowDiskUse().All(&tc)
-	if err != nil {
-		logger.Logger.Error("GetInviteList AllowDiskUse is error", err)
-		return err
-	}
-
-	u := PlayerDataCollection(req.Platform)
-	if u == nil {
-		return PlayerColError
-	}
-
-	for _, v := range tc {
-		d := &model.PlayerBaseInfo2{}
-		err = u.Find(bson.M{"snid": v.SnId}).Select(bson.M{"name": 1, "createtime": 1, "roles": 1}).One(d)
-		if err != nil {
-			logger.Logger.Warnf("GetInviteList Find player is error:%v", err)
-		}
-		roleId := common.DefaultRoleId
-		if d.Roles != nil && d.Roles.ModId != 0 {
-			roleId = int(d.Roles.ModId)
-		}
-		ret.List = append(ret.List, &model.InviteInfo{
-			Name:     d.Name,
-			SnId:     v.SnId,
-			CreateTs: d.CreateTime.Unix(),
-			Score:    v.Score,
-			ModId:    int32(roleId),
-		})
-	}
-
-	return nil
-}
-
-func init() {
-	rpc.Register(new(BindScoreSvc))
-}

dbproxy/svc/u_message.go

@@ -18,6 +18,10 @@ func MessageCollection(plt string) *mongo.Collection {
 		if first {
 			c.EnsureIndex(mgo.Index{Key: []string{"snid"}, Background: true, Sparse: true})
 			c.EnsureIndex(mgo.Index{Key: []string{"state"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"mtype"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"srcid"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"-creatts"}, Background: true, Sparse: true})
+			c.EnsureIndex(mgo.Index{Key: []string{"creatts"}, Background: true, Sparse: true})
 		}
 		return c
 	}

dbproxy/svc/u_player.go

@@ -11,14 +11,19 @@ import (
 	"strings"
 	"time"
 
+	newMongo "go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
 	"mongo.games.com/goserver/core/basic"
+	"mongo.games.com/goserver/core/logger"
 	"mongo.games.com/goserver/core/task"
 
 	"github.com/globalsign/mgo"
 	"github.com/globalsign/mgo/bson"
+	newBson "go.mongodb.org/mongo-driver/bson"
+
+	"mongo.games.com/game/common"
 	"mongo.games.com/game/dbproxy/mongo"
 	"mongo.games.com/game/model"
-	"mongo.games.com/goserver/core/logger"
 )
 
 var (
@@ -37,13 +42,12 @@ func PlayerDataCollection(plt string) *mongo.Collection {
 			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"snid"}, Unique: true, Background: true, Sparse: true})
 			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"channel"}, Background: true, Sparse: true})
 			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"tel"}, Background: true, Sparse: true})
-			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"bankaccount"}, Background: true, Sparse: true})
-			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"alipayaccount"}, Background: true, Sparse: true})
-			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"alipayaccname"}, Background: true, Sparse: true})
-			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"bankaccname"}, Background: true, Sparse: true})
-			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"invitecode"}, Background: true, Sparse: true})
-			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"invitesnid"}, Background: true, Sparse: true})
 			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"name"}, Background: true, Sparse: true})
+			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"createtime"}, Background: true, Sparse: true})
+			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"-createtime"}, Background: true, Sparse: true})
+			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"icode"}, Background: true, Sparse: true})
+			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"psnid"}, Background: true, Sparse: true})
+			c_playerdata.EnsureIndex(mgo.Index{Key: []string{"pcode"}, Background: true, Sparse: true})
 		}
 		return c_playerdata
 	}
@@ -147,8 +151,8 @@ func (svc *PlayerDataSvc) GetPlayerData(args *model.GetPlayerDataArgs, ret *mode
 			name = "Guest"
 		}
 
-		pd = model.NewPlayerData(args.Acc, name, id, a.Channel, a.Platform, a.Promoter, a.InviterId, a.PromoterTree, a.Params,
-			a.Tel, a.PackegeTag, dataParams.Ip, 0, dataParams.UnionId, a.DeviceInfo, a.SubPromoter, a.TagKey, a.AccountType)
+		pd = model.NewPlayerData(args.Acc, name, id, a.Channel, a.Platform, a.Params,
+			a.Tel, a.PackegeTag, dataParams.Ip, 0, dataParams.UnionId, a.DeviceInfo, a.TagKey, a.AccountType, a.ChannelId)
 		if pd != nil {
 			err = cplayerdata.Insert(pd)
 			if err != nil {
@@ -222,8 +226,8 @@ func (svc *PlayerDataSvc) CreatePlayerDataByThird(args *model.CreatePlayer, ret
 		}
 		var dataParams model.PlayerParams
 		json.Unmarshal([]byte(a.Params), &dataParams)
-		pd = model.NewPlayerDataThird(acc, name, args.HeadUrl, id, a.Channel, a.Platform, a.Promoter, a.InviterId,
-			a.PromoterTree, a.Params, a.Tel, a.PackegeTag, dataParams.Ip, a.SubPromoter, a.TagKey, a.AccountType, a.DeviceOs)
+		pd = model.NewPlayerDataThird(acc, name, args.HeadUrl, id, a.Channel, a.Platform, a.Params,
+			a.Tel, a.PackegeTag, dataParams.Ip, a.TagKey, a.AccountType, a.DeviceOs)
 		if pd != nil {
 			err = cplayerdata.Insert(pd)
 			if err != nil {
@@ -245,7 +249,7 @@ func (svc *PlayerDataSvc) CreatePlayerDataByThird(args *model.CreatePlayer, ret
 func (svc *PlayerDataSvc) CreatePlayerDataOnRegister(args *model.PlayerDataArg, ret *model.PlayerDataRet) (err error) {
 	cplayerdata := PlayerDataCollection(args.Plt)
 	if cplayerdata == nil {
-		return
+		return PlayerColError
 	}
 	acc := args.AccId
 	pd := &model.PlayerData{}
@@ -265,13 +269,13 @@ func (svc *PlayerDataSvc) CreatePlayerDataOnRegister(args *model.PlayerDataArg,
 
 		if !bson.IsObjectIdHex(acc) {
 			logger.Logger.Warn("NewPlayer failed: acc is illeage ", acc)
-			return
+			return errors.New("acc is illeage")
 		}
 		var a *model.Account
 		a, err = _AccountSvc.getAccount(args.Plt, args.AccId)
 		if err != nil {
 			logger.Logger.Warnf("_AccountSvc.getAccount(%v,%v) failed:%v", args.Plt, args.AccId, err)
-			return
+			return err
 		}
 
 		id := a.SnId
@@ -279,7 +283,7 @@ func (svc *PlayerDataSvc) CreatePlayerDataOnRegister(args *model.PlayerDataArg,
 			id, err = GetOnePlayerIdFromBucket()
 			if err != nil {
 				logger.Logger.Warn("NewPlayer failed:", err)
-				return
+				return err
 			}
 		}
 
@@ -292,26 +296,30 @@ func (svc *PlayerDataSvc) CreatePlayerDataOnRegister(args *model.PlayerDataArg,
 		}
 		var dataParams model.PlayerParams
 		json.Unmarshal([]byte(a.Params), &dataParams)
-		pd = model.NewPlayerData(acc, name, id, a.Channel, a.Platform, a.Promoter, a.InviterId,
-			a.PromoterTree, a.Params, a.Tel, a.PackegeTag, dataParams.Ip, int64(args.AddCoin),
-			"", a.DeviceInfo, a.SubPromoter, a.TagKey, a.AccountType)
+		pd = model.NewPlayerData(acc, name, id, a.Channel, a.Platform, a.Params, a.Tel, a.PackegeTag,
+			dataParams.Ip, int64(args.AddCoin), "", a.DeviceInfo, a.TagKey, a.AccountType, a.ChannelId)
 		pd.HeadUrl = args.HeadUrl
 		if pd != nil {
+			if pd.ICode == "" {
+				code, _ := GetInviteCode(pd.Platform, pd.SnId)
+				pd.ICode = code
+				pd.IScoreTs = time.Now()
+			}
 			err = cplayerdata.Insert(pd)
 			if err != nil {
 				logger.Logger.Trace("CreatePlayerDataOnRegister Insert failed:", err)
-				return
+				return err
 			}
 			ret.Pd = pd
 			ret.IsNew = true
-			return
+			return nil
 		}
-		return
+		return nil
 	}
 	if CorrectData(pd) {
 	}
 	ret.Pd = pd
-	return
+	return nil
 }
 
 func (svc *PlayerDataSvc) GetPlayerDataBySnId(args *model.GetPlayerDataBySnIdArgs, ret *model.PlayerDataRet) (err error) {
@@ -320,6 +328,39 @@ func (svc *PlayerDataSvc) GetPlayerDataBySnId(args *model.GetPlayerDataBySnIdArg
 		return nil
 	}
 
+	//defer func() {
+	//	logger.Logger.Debugf("Player Data: snid:%v VCardCost:%v MoneyTotal:%v", ret.Pd.SnId, ret.Pd.VCardCost, ret.Pd.MoneyTotal)
+	//}()
+
+	f := func(p *model.PlayerData) {
+		// 更新一下绑定关系
+		if p.PSnId > 0 && p.PCode != "" {
+			return
+		}
+		c := InviteScoreCollection(args.Plt)
+		if c == nil {
+			return
+		}
+		res := new(model.LogInviteScore)
+		c.Find(bson.M{"downsnid": args.SnId, "tp": common.InviteScoreTypeBind}).One(res)
+		param := bson.M{}
+		if res.UpSnid > 0 {
+			p.PSnId = int32(res.UpSnid)
+			param["psnid"] = p.PSnId
+			code, _ := GetCodeBySnId(args.Plt, p.PSnId)
+			if code != "" {
+				p.PCode = code
+				param["pcode"] = code
+			}
+			cplayerdata.Update(bson.M{"snid": args.SnId}, bson.M{"$set": param})
+		}
+		if p.GuideStep >= 0 && p.CreateTime.Unix() < model.GameParamData.GuideTs {
+			p.GuideStep = -1
+			param["guidestep"] = p.GuideStep
+			cplayerdata.Update(bson.M{"snid": args.SnId}, bson.M{"$set": param})
+		}
+	}
+
 	var code string
 	err = cplayerdata.Find(bson.M{"snid": args.SnId}).One(&ret.Pd)
 	if err != nil {
@@ -342,18 +383,19 @@ func (svc *PlayerDataSvc) GetPlayerDataBySnId(args *model.GetPlayerDataBySnIdArg
 				name = "Guest"
 			}
 
-			pd := model.NewPlayerData(a.AccountId.Hex(), name, a.SnId, a.Channel, a.Platform, a.Promoter, a.InviterId, a.PromoterTree, a.Params,
-				a.Tel, a.PackegeTag, dataParams.Ip, 0, dataParams.UnionId, a.DeviceInfo, a.SubPromoter, a.TagKey, a.AccountType)
+			pd := model.NewPlayerData(a.AccountId.Hex(), name, a.SnId, a.Channel, a.Platform, a.Params,
+				a.Tel, a.PackegeTag, dataParams.Ip, 0, dataParams.UnionId, a.DeviceInfo, a.TagKey, a.AccountType, a.ChannelId)
 			if pd != nil {
+				if pd.ICode == "" {
+					code, _ = GetInviteCode(pd.Platform, pd.SnId)
+					pd.ICode = code
+					pd.IScoreTs = time.Now()
+				}
 				err = cplayerdata.Insert(pd)
 				if err != nil {
 					logger.Logger.Errorf("GetPlayerDataBySnId Insert err:%v acc:%v snid:%v", err, a.AccountId.Hex(), a.SnId)
 					return err
 				}
-				if pd.InviteCode == "" {
-					code, err = GetInviteCode(pd.Platform, pd.SnId)
-					pd.InviteCode = code
-				}
 				ret.IsNew = true
 				ret.Pd = pd
 				return nil
@@ -361,14 +403,22 @@ func (svc *PlayerDataSvc) GetPlayerDataBySnId(args *model.GetPlayerDataBySnIdArg
 		}
 		return err
 	}
-	if ret.Pd.InviteCode == "" {
-		code, err = GetInviteCode(ret.Pd.Platform, ret.Pd.SnId)
-		ret.Pd.InviteCode = code
+	if ret.Pd.ICode == "" {
+		code, _ = GetInviteCode(ret.Pd.Platform, ret.Pd.SnId)
+		ret.Pd.ICode = code
+		ret.Pd.IScoreTs = time.Now()
+		cplayerdata.Update(bson.M{"snid": args.SnId}, bson.M{"$set": bson.M{"icode": code, "iscorets": ret.Pd.IScoreTs}})
 	}
+	if ret.Pd.VCardCost == 0 {
+		ret.Pd.VCardCost = GetItemCount(ret.Pd.Platform, ret.Pd.SnId, common.ItemIDVCard, 1)
+	}
+	if ret.Pd.MoneyTotal == 0 {
+		ret.Pd.MoneyTotal = GetMoneyTotal(ret.Pd.Platform, ret.Pd.SnId)
+	}
+	f(ret.Pd)
 	if args.CorrectData && ret.Pd != nil {
 		CorrectData(ret.Pd)
 	}
-
 	return nil
 }
 
@@ -458,6 +508,12 @@ func SavePlayerData(pd *model.PlayerData) (err error) {
 	}
 	if pd != nil {
 		model.RecalcuPlayerCheckSum(pd)
+		//todo 排除字段更新，有没有更新好的方法
+		pd.IScore, pd.INum, pd.IMoney, pd.IScoreTs, err = GetInviteData(pd.Platform, pd.SnId)
+		if err != nil {
+			logger.Logger.Errorf("model.SavePlayerData GetInviteData %v err:%v", pd.SnId, err)
+			return
+		}
 		_, err = cplayerdata.Upsert(bson.M{"_id": pd.Id}, pd)
 		if err != nil {
 			logger.Logger.Errorf("model.SavePlayerData %v err:%v", pd.SnId, err)
@@ -1494,59 +1550,192 @@ func (svc *PlayerDataSvc) GetPlayerInviteSnid(req *model.PlayerIsExistBySnIdArgs
 	}
 
 	type t struct {
-		InviteSnId int32
+		PSnId int32
 	}
 
 	res := &t{}
 
-	err := c.Find(bson.M{"snid": req.SnId}).Select(bson.M{"invitesnid": 1}).One(res)
-	if err != nil && errors.Is(err, mgo.ErrNotFound) {
+	err := c.Find(bson.M{"snid": req.SnId}).Select(bson.M{"psnid": 1}).One(res)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
 		return err
 	}
 
-	*resp = res.InviteSnId
+	*resp = res.PSnId
 
 	return nil
 }
 
-func (svc *PlayerDataSvc) GetInviteNum(req *model.PlayerIsExistBySnIdArgs, resp *int32) error {
-	n, err := GetInviteNum(req.Plt, req.SnId)
+func (svc *PlayerDataSvc) BindInviteSnId(args *model.BindArgs, ret *bool) error {
+	err := BindInviteSnId(args.Platform, args.SnId, args.PSnId, args.PCode)
 	if err != nil {
 		return err
 	}
-	*resp = n
+	*ret = true
 	return nil
 }
 
-func GetInviteNum(platform string, snId int32) (int32, error) {
-	c := PlayerDataCollection(platform)
-	if c == nil {
-		return 0, PlayerColError
-	}
-
-	n, err := c.Find(bson.M{"invitesnid": snId}).Count()
-	if err != nil {
-		return 0, err
-	}
-
-	return int32(n), nil
-}
-
-func BindInviteSnId(platform string, snId, inviteSnId int32, ts int64) error {
+func BindInviteSnId(platform string, snId, inviteSnId int32, code string) error {
 	c := PlayerDataCollection(platform)
 	if c == nil {
 		return PlayerColError
 	}
 
-	err := c.Update(bson.M{"snid": snId}, bson.M{"$set": bson.M{"invitesnid": inviteSnId}})
+	err := c.Update(bson.M{"snid": snId}, bson.M{"$set": bson.M{"psnid": inviteSnId, "pcode": code}})
 	if err != nil {
 		logger.Logger.Error("BindInviteSnId error ", err)
 		return err
 	}
+	err = c.Update(bson.M{"snid": inviteSnId}, bson.M{"$inc": bson.M{"inum": 1}})
+	if err != nil {
+		logger.Logger.Error("BindInviteSnId error ", err)
+		return err
+	}
+	return nil
+}
+
+func ClearInviteScore(platform string, snId int32, now time.Time) error {
+	c := PlayerDataCollection(platform)
+	if c == nil {
+		return PlayerColError
+	}
+
+	err := c.Update(bson.M{"snid": snId}, bson.M{"$set": bson.M{"iscore": 0, "iscorets": now}})
+	if err != nil {
+		logger.Logger.Error("ClearInviteScore error ", err)
+		return err
+	}
 
 	return nil
 }
 
+func AddInviteScore(client *newMongo.Client, sc newMongo.SessionContext, platform string, psnId, snid, level, tp int32, num, rate, money int64, now time.Time, addMoney bool) error {
+	logger.Logger.Tracef("AddInviteScore ==> platform %v, psnId %v, snid %v, level %v, tp %v, num %v, rate %v, money %v, now %v, addMoney %v",
+		platform, psnId, snid, level, tp, num, rate, money, now, addMoney)
+
+	inviteCfg, b := mongo.MgoSessionMgrSington.GetCfg(platform, InviteScoreDBName)
+	if !b {
+		return InviteScoreColError
+	}
+	inviteC := client.Database(inviteCfg.Database).Collection(InviteScoreCollName)
+	if inviteC == nil {
+		return InviteScoreColError
+	}
+	playerCfg, b := mongo.MgoSessionMgrSington.GetCfg(platform, PlayerDBName)
+	if !b {
+		return PlayerColError
+	}
+	playerC := client.Database(playerCfg.Database).Collection(PlayerCollName)
+	if playerC == nil {
+		return PlayerColError
+	}
+	rankCfg, b := mongo.MgoSessionMgrSington.GetCfg(platform, RankInviteDBName)
+	if !b {
+		return RankDataDBErr
+	}
+	rankC := client.Database(rankCfg.Database).Collection(RankInviteCollName)
+	if rankC == nil {
+		return RankDataDBErr
+	}
+
+	// 积分变更记录
+	_, err := inviteC.InsertOne(sc, &model.NInviteScore{
+		UpSnid:   psnId,
+		DownSnid: snid,
+		Level:    level,
+		Tp:       tp,
+		Rate:     rate,
+		Score:    num,
+		Money:    money,
+		Ts:       now.Unix(),
+	})
+	if err != nil {
+		logger.Logger.Error("AddInviteScore LogInviteScore error ", err)
+		return err
+	}
+
+	// 玩家积分和绑定数量
+	type m struct {
+		IScore int64
+		INum   int64
+	}
+	res := &m{}
+	err = playerC.FindOne(sc, newBson.M{"snid": psnId}).Decode(res)
+	if err != nil {
+		logger.Logger.Error("AddInviteScore find error ", err)
+		return err
+	}
+
+	// 修改玩家积分
+	myMoney := money
+	if !addMoney {
+		myMoney = 0
+	}
+
+	//addNum := int64(0)
+	//if level == 0 && tp == common.InviteScoreTypeBind {
+	//	addNum = 1
+	//}
+
+	_, err = playerC.UpdateOne(sc, newBson.M{"snid": psnId}, newBson.M{"$inc": bson.M{"iscore": num, "imoney": myMoney}, "$set": bson.M{"iscorets": now}})
+	if err != nil {
+		logger.Logger.Error("AddInviteScore error ", err)
+		return err
+	}
+
+	// 更新排行榜
+	data := model.RankInvite{
+		Platform: platform,
+		SnId:     psnId,
+		Num:      res.INum,
+		Score:    res.IScore + num,
+		Ts:       now.Unix(),
+		Week:     common.GetWeekStartTs(now.Unix()),
+	}
+	_, err = rankC.UpdateOne(sc, newBson.M{"snid": psnId, "week": data.Week}, newBson.M{"$set": data}, options.Update().SetUpsert(true))
+	if err != nil {
+		logger.Logger.Tracef("SaveRankInvite error:%v", err)
+		return err
+	}
+
+	return nil
+}
+
+func GetInviteData(platform string, snId int32) (iscore, inum, imoney int64, iscorets time.Time, err error) {
+	c := PlayerDataCollection(platform)
+	if c == nil {
+		err = PlayerColError
+		return
+	}
+	type M struct {
+		IScore, Imoney, Inum int64
+		IScoreTs             time.Time
+	}
+	res := &M{}
+	err = c.Find(bson.M{"snid": snId}).Select(bson.M{"iscore": 1, "inum": 1, "imoney": 1, "iscorets": 1}).One(res)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		return
+	}
+	res.IScoreTs = res.IScoreTs.Local()
+	return res.IScore, res.Inum, res.Imoney, res.IScoreTs, nil
+}
+
+func GetPSnId(platform string, snId int32) (psnId int32, err error) {
+	c := PlayerDataCollection(platform)
+	if c == nil {
+		err = PlayerColError
+		return
+	}
+	type M struct {
+		PSnId int32
+	}
+	res := &M{}
+	err = c.Find(bson.M{"snid": snId}).Select(bson.M{"psnid": 1}).One(res)
+	if err != nil && !errors.Is(err, mgo.ErrNotFound) {
+		return 0, err
+	}
+	return res.PSnId, nil
+}
+
 func CorrectData(pd *model.PlayerData) bool {
 	//var coinTotal int64
 	dirty := false

deploy.bat

@@ -0,0 +1,36 @@
+@echo off
+set work_path=%cd%
+git checkout develop
+
+call shell/gen_data.bat
+
+call shell/gen_go.bat
+
+call shell/update_public.bat
+
+git add .
+git commit -m "update develop"
+
+git checkout release
+
+git merge develop
+
+git add .
+git reset public
+git commit -m "update release"
+
+set CGO_ENABLED=0
+set GOOS=linux
+set GOARCH=amd64
+go env -w GO111MODULE=off
+call shell/build.bat
+
+rem copy
+cd %work_path%
+call shell/update_deploy.bat
+
+git checkout develop
+pause
+
+
+