小猫戏法

src/server/conf/limitedTimeEvent/LimitedTimeEventCfg.go

@@ -22,6 +22,7 @@ const (
 	CFG_LIMITED_TIME_EVENT_BONUS         = "LimitedTimeEventBonus"
 	CFG_LIMITED_TIME_EVENT_MONEY         = "LimitedTimeEventMoney"
 	CFG_LIMITED_TIME_EVENT_LUCKY         = "LimitedTimeEventLucky"
+	CFG_LIMITED_TIME_EVENT_CAT_TRICK     = "LimitedTimeEventCatTrick"
 )
 
 func init() {
@@ -38,6 +39,7 @@ func init() {
 	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_CHEST_JACKPOT)
 	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_MONEY)
 	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_LUCKY)
+	gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_CAT_TRICK)
 }
 
 // 获取限时事件触发列表
@@ -332,3 +334,27 @@ func GetLuckyCatMaxEarning(Remain int) int {
 	}
 	return 0
 }
+
+func GetCatTrickType(Duartion int) int {
+	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_CAT_TRICK)
+	if err != nil {
+		log.Debug("GetCatTrick err:%v", err)
+		return 1
+	}
+	for _, v := range data {
+		D := gamedata.GetIntValue(v, "Duration")
+		if Duartion == D {
+			return gamedata.GetIntValue(v, "Type")
+		}
+	}
+	return gamedata.GetIntValue(data, "Type")
+}
+
+func GetCatTrickDiamond(Type int) (int, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_LIMITED_TIME_EVENT_CAT_TRICK, Type)
+	if err != nil {
+		log.Debug("GetCatTrickDiamond err:%v", err)
+		return 0, 0
+	}
+	return gamedata.GetIntValue(data, "Diamond"), gamedata.GetIntValue(data, "Energy")
+}

src/server/game/GameLogic.go

@@ -696,6 +696,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqSelectLimitEvent", ReqSelectLimitEvent)     //领取限时事件进度奖励
 	RegisterMsgProcessFunc("ReqGetGoldCard", ReqGetGoldCard)               //请求金卡交换信息
 	RegisterMsgProcessFunc("ReqLimitEventLuckyCat", ReqLimitEventLuckyCat) //幸运猫获取奖励
+	RegisterMsgProcessFunc("ReqCatTrickReward", ReqCatTrickReward)         //小猫戏法获取奖励
 
 	// #region 好友
 	RegisterMsgProcessFunc("ReqFriendList", ReqFriendList)           // 请求好友列表

src/server/game/PlayerChessMod.go

@@ -8,6 +8,7 @@ import (
 	mergeDataCfg "server/conf/mergeData"
 	orderCfg "server/conf/order"
 	"server/game/mod/item"
+	"server/game/mod/limitedTimeEvent"
 	"server/game/mod/quest"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
@@ -231,6 +232,12 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 	if Update {
 		player.PushClientRes(OrderMod.BackData())
 	}
+	// 限时事件 小猫戏法
+	LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
+	if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_TRICK) {
+		LimitedTimeEventMod.AddCatTrickEnergy(addChessCostEnergy)
+		player.PushClientRes(LimitedTimeEventMod.BackData())
+	}
 	player.QuestTriggerList(TriggerList)
 	EmitRetireTrigger1(player)
 	player.PushClientRes(ChessMod.BackData())

src/server/game/RegisterNetworkFunc.go

@@ -3941,3 +3941,38 @@ func ReqLang(player *Player, buf []byte) error {
 	})
 	return nil
 }
+
+func ReqCatTrickReward(player *Player, buf []byte) error {
+	req := &msg.ReqCatTrickReward{}
+	proto.Unmarshal(buf, req)
+	LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
+	if !LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_TRICK) {
+		player.SendErrClienRes(&msg.ResCatTrickReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "cat trick event not exist",
+		})
+		return fmt.Errorf("cat trick event not exist")
+	}
+	Items, err := LimitedTimeEventMod.GetCatTrickReward()
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatTrickReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_CatTrickReward.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatTrickReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	player.PushClientRes(LimitedTimeEventMod.BackData())
+	player.PushClientRes(&msg.ResCatTrickReward{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}

src/server/game/mod/limitedTimeEvent/LimitedTimeEvent.go

@@ -24,6 +24,7 @@ const (
 	EVENT_TYPE_CAT_CYCLONE   = 11 // 猫咪飓风
 	EVENT_TYPE_MONEY_CAT     = 12 // 招财猫
 	EVENT_TYPE_LUCKY_CAT     = 13 // 幸运猫
+	EVENT_TYPE_CAT_TRICK     = 14 // 猫咪戏法
 )
 
 const (
@@ -61,6 +62,16 @@ type LuckyCat struct {
 	Earnings int
 }
 
+type CatTrick struct {
+	List   []CatTrickInfo
+	Energy int
+}
+
+type CatTrickInfo struct {
+	Id   int
+	Type int
+}
+
 func (l *LimitedTimeEventMod) InitData(Lv int) {
 	if l.EventList == nil {
 		l.EventList = make(map[int]*LTEInfo)
@@ -139,6 +150,7 @@ func (l *LimitedTimeEventMod) Trigger(Lv int) (int, []int, []int) {
 func (l *LimitedTimeEventMod) AddEvent(EventId, Duration int) int64 {
 	if v, ok := l.EventList[EventId]; ok {
 		v.Remian += int64(Duration)
+		addEventInfo(v, EventId)
 	} else {
 		Event := &LTEInfo{
 			Remian: int64(Duration),
@@ -358,6 +370,35 @@ func (l *LimitedTimeEventMod) LuckyCat(ChessId int) error {
 	return nil
 }
 
+func (l *LimitedTimeEventMod) AddCatTrickEnergy(Energy int) {
+	if l.EventList[EVENT_TYPE_CAT_TRICK] == nil {
+		return
+	}
+	d := l.EventList[EVENT_TYPE_CAT_TRICK].D.(*CatTrick)
+	d.Energy += Energy
+}
+
+func (l *LimitedTimeEventMod) GetCatTrickReward() ([]*item.Item, error) {
+	if l.EventList[EVENT_TYPE_CAT_TRICK] == nil {
+		return nil, fmt.Errorf("CatTrick event not exist")
+	}
+	d := l.EventList[EVENT_TYPE_CAT_TRICK].D.(*CatTrick)
+	if len(d.List) == 0 {
+		return nil, fmt.Errorf("CatTrick list is empty")
+	}
+	info := d.List[0]
+	Diamon, Energy := limitedTimeEventCfg.GetCatTrickDiamond(info.Type)
+	d.Energy -= Diamon * Energy
+	if len(d.List) == 1 {
+		delete(l.EventList, EVENT_TYPE_CAT_TRICK)
+	} else {
+		d.List = d.List[1:]
+	}
+	return []*item.Item{
+		{Id: item.ITEM_DIAMOND_ID, Num: -Diamon},
+	}, nil
+}
+
 // 获取超级订单奖励
 func initEventInfo(E *LTEInfo, EventType int) {
 	switch EventType {
@@ -376,13 +417,34 @@ func initEventInfo(E *LTEInfo, EventType int) {
 		E.D = &LuckyCat{
 			Earnings: 0,
 		}
+	case EVENT_TYPE_CAT_TRICK:
+		Type := limitedTimeEventCfg.GetCatTrickType(int(E.Remian))
+		E.D = &CatTrick{
+			List: []CatTrickInfo{
+				{
+					Id:   1,
+					Type: Type,
+				},
+			},
+		}
+	}
+}
+
+func addEventInfo(E *LTEInfo, EventType int) {
+	switch EventType {
+	case EVENT_TYPE_CAT_TRICK:
+		d := E.D.(*CatTrick)
+		d.List = append(d.List, CatTrickInfo{
+			Id:   len(d.List) + 1,
+			Type: limitedTimeEventCfg.GetCatTrickType(int(E.Remian)),
+		})
 	}
 }
 
 func getLimitEventMsg(t int, e *LTEInfo) *msg.LimitEvent {
 	Cd := 0
 	Mul := 0.0
-
+	Param := make(map[string]int32, 0)
 	switch t {
 	case EVENT_TYPE_FAST_PRODUCE:
 		NextPlay := GoUtil.Int64(e.Info["NextPlay"])
@@ -391,6 +453,12 @@ func getLimitEventMsg(t int, e *LTEInfo) *msg.LimitEvent {
 		d := e.D.(*MoneyCat)
 		Cd = int(d.EndTime)
 		Mul = d.Mul
+	case EVENT_TYPE_CAT_TRICK:
+		d := e.D.(*CatTrick)
+		Energy := d.Energy
+		Param[msg.LimitEventParam_CAT_TRICK_ENERGY.String()] = int32(Energy)
+		info := d.List[0]
+		Param[msg.LimitEventParam_CAT_TRICK_TYPE.String()] = int32(info.Type)
 	}
 	return &msg.LimitEvent{
 		EndTime:   int32(e.StartT + e.Remian),