ecs/servers/game/handler/player_item.go

package handler

import (
	"ecs/proto"
	"ecs/proto/pb"
	"ecs/servers/game/logic"
	"github.com/oylshe1314/framework/net"
)

func (this *PlayerHandler) ItemUse(player *logic.Player, msg *net.Message) {
	var req = new(pb.ItemUseReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.ItemId == 0 || req.ItemNum == 0 {
		this.logger.Errorf("Parameter error, req.ItemId: %d, req.ItemNum: %d", req.ItemId, req.ItemNum)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	var item = player.Item[req.ItemId]
	if item == nil {
		_ = player.TipNotice(proto.TipItemNotFound)
		return
	}
}

func (this *PlayerHandler) ItemSale(player *logic.Player, msg *net.Message) {
	var req = new(pb.ItemSaleReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if len(req.ItemList) == 0 {
		this.logger.Error("Parameter error, len(req.ItemList) == 0")
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	var itemMap map[uint32]uint32
	var reduceMap map[uint32]uint32
	for _, item := range req.ItemList {
		if item.ItemId == 0 || item.ItemNum == 0 {
			this.logger.Error("Parameter error, item.ItemId == 0 || item.ItemNum == 0")
			_ = player.TipNotice(proto.TipDataTablesError)
			return
		}

		var itemTable = this.tables.Item.Find1(int(item.ItemId))
		if itemTable == nil {
			this.logger.Error("Parameter error, item table was not found, item.Id: ", item.ItemId)
			_ = player.TipNotice(proto.TipDataTablesError)
			return
		}

		if !itemTable.SaleAllow {
			this.logger.Error("Parameter error, item can not sale, item.Id: ", item.ItemId)
			_ = player.TipNotice(proto.TipItemCanNotSale)
			return
		}

		if itemTable.SaleItemId == 0 || itemTable.SaleItemNum == 0 {
			this.logger.Error("Data table error, itemTable.SaleItemId == 0 || itemTable.SaleItemNum == 0, item.Id: ", item.ItemId)
			_ = player.TipNotice(proto.TipDataTablesError)
			return
		}

		ok, tip := player.CheckItem(item.ItemId, item.ItemNum)
		if !ok {
			_ = player.TipNotice(tip)
			return
		}

		reduceMap[item.ItemId] = item.ItemNum
		itemMap[uint32(itemTable.SaleItemId)] = uint32(itemTable.SaleItemNum) * item.ItemNum
	}

	player.ReduceItems(reduceMap, logic.LogTypeItemConsumeBySale)
	player.AddItems(itemMap, logic.LogTypeItemObtainBySale)
}

func (this *PlayerHandler) EquipUpgrade(player *logic.Player, msg *net.Message) {
	var req = new(pb.EquipUpgradeReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.EquipUid == 0 {
		this.logger.Error("Parameter error, req.EquipUid == 0")
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	var equip = player.Equip[req.EquipUid]
	if equip == nil {
		this.logger.Error("Parameter error, equip was not found, req.EquipUid: ", req.EquipUid)
		_ = player.TipNotice(proto.TipEquipNotFound)
		return
	}

	var equipTable = this.tables.Equip.Get(int(equip.Id))
	if equipTable == nil {
		this.logger.Error("Parameter or data error, table 'Equip' was not found, equip.Id: ", equip.Id)
		_ = player.TipNotice(proto.TipDataTablesError)
		return
	}

	if equip.Level >= uint32(equipTable.Levels) {
		_ = player.TipNotice(proto.TipLevelAlreadyMax)
		return
	}

	if player.CheckFunctionOpen(pb.ModId_ModuleItem, pb.FuncType_FuncEquipUpgrade, int(equip.Level+1)) {
		_ = player.TipNotice(proto.TipLevelAlreadyMax)
		return
	}

	var levelTable = this.tables.EquipLevel.Find3(int(equip.Id), int(equip.Level))
	if levelTable == nil {
		_ = player.TipNotice(proto.TipDataTablesError)
		return
	}

	for i := range levelTable.ConsumeItems {
		if ok, tip := player.CheckItem(uint32(levelTable.ConsumeItems[i]), uint32(levelTable.ConsumeNums[i])); !ok {
			_ = player.TipNotice(tip)
			return
		}
	}

	var nextLevelTable = this.tables.EquipLevel.Find3(int(equip.Id), int(equip.Level+1))
	if nextLevelTable == nil {
		_ = player.TipNotice(proto.TipDataTablesError)
		return
	}

	var preLevel = equip.Level
	equip.Level = uint32(nextLevelTable.Level)
	for i := range levelTable.ConsumeItems {
		player.ReduceItem(uint32(levelTable.ConsumeItems[i]), uint32(levelTable.ConsumeNums[i]), logic.LogTypeItemConsumeByEquipUpgrade)
	}

	player.SaveModel(equip)

	_ = player.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemEquipChange), pb.EquipChangeListAck{
		ChangeList: []*pb.EquipChange{{Equip: equip.BuildMsgEquip(), ChangeType: pb.ChangeType_Add}},
	})

	player.SendUpgradeMaster(pb.UpgradeMasterType_MasterEquipUpgrade, preLevel, equip.Level, equip.HeroUid)
	return
}

func (this *PlayerHandler) EquipRefine(player *logic.Player, msg *net.Message) {
	var req = new(pb.EquipRefineReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.EquipUid == 0 {
		this.logger.Error("Parameter error, req.EquipUid == 0")
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	switch req.Type {
	case 1:
		if req.Value != 1 {
			this.logger.Error("Parameter error, req.Value != 1")
			_ = player.TipNotice(proto.TipParameterError)
			return
		}
	case 2:
		if req.Value == 0 {
			this.logger.Error("Parameter error, req.Value == 0")
			_ = player.TipNotice(proto.TipParameterError)
			return
		}
	default:
		this.logger.Error("Parameter error, req.Type: ", req.Type)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	var equip = player.Equip[req.EquipUid]
	if equip == nil {
		this.logger.Error("Parameter error, equip was not found, req.EquipUid: ", req.EquipUid)
		_ = player.TipNotice(proto.TipEquipNotFound)
		return
	}

	var equipTable = this.tables.Equip.Get(int(equip.Id))
	if equipTable == nil {
		this.logger.Error("Parameter or data error, table 'Equip' was not found, equip.Id: ", equip.Id)
		_ = player.TipNotice(proto.TipDataTablesError)
		return
	}

	if equip.RefineLevel >= uint32(equipTable.RefineLevels) {
		_ = player.TipNotice(proto.TipLevelAlreadyMax)
		return
	}

	if player.CheckFunctionOpen(pb.ModId_ModuleItem, pb.FuncType_FuncEquipUpgrade, int(equip.RefineLevel+1)) {
		_ = player.TipNotice(proto.TipLevelAlreadyMax)
		return
	}

	var refineTable = this.tables.EquipRefine.Find3(int(equip.Id), int(equip.Level))
	if refineTable == nil {
		this.logger.Error("Parameter or data error, table 'EquipRefine' was not found, equip.Id: ", equip.Id)
		_ = player.TipNotice(proto.TipDataTablesError)
		return
	}

	var preLevel = equip.Level
	switch req.Type {
	case 1:
		var itemTables = this.tables.Item.Find2(int(pb.ItemType_ItemProp), int(pb.PropType_EquipRefineExp))
		if len(itemTables) == 0 {
			this.logger.Error("Data error, the item list is empty, type: %d, subType: %d", pb.ItemType_ItemProp, pb.PropType_EquipRefineExp)
			_ = player.TipNotice(proto.TipDataTablesError)
			return
		}

		var exp = equip.RefineExp
		var level = equip.RefineLevel
		var consumeItems = map[uint32]uint32{}
		for _, itemTable := range itemTables {
			var item = player.Item[uint32(itemTable.Id)]
			if item == nil {
				continue
			}

			var needExp = uint32(refineTable.NeedExp) - exp
			var needNum = needExp / uint32(itemTable.Value)
			if needExp%uint32(itemTable.Value) > 0 {
				needNum += 1
			}

			if needNum <= item.Num {
				consumeItems[item.Id] = needNum
				exp = uint32(itemTable.Value)*needNum - exp
				level += 1
				break
			} else {
				consumeItems[item.Id] = item.Num
				exp += uint32(itemTable.Value) * item.Num
			}
		}

		equip.RefineExp = exp
		equip.RefineLevel = level

		player.ReduceItems(consumeItems, logic.LogTypeItemConsumeByEquipRefine)
	case 2:
		var itemTable = this.tables.Item.Find1(int(req.Value))
		if itemTable == nil {
			this.logger.Error("Parameter or data error, table 'Item' was not found, itemId: ", req.Value)
			_ = player.TipNotice(proto.TipDataTablesError)
			return
		}

		if ok, tip := player.CheckItem(req.Value, 1); !ok {
			_ = player.TipNotice(tip)
			return
		}

		equip.RefineExp += uint32(itemTable.Value)
		if equip.RefineExp >= uint32(refineTable.NeedExp) {
			equip.RefineLevel += 1
			equip.RefineExp -= uint32(refineTable.NeedExp)
		}

		player.ReduceItem(req.Value, 1, logic.LogTypeItemConsumeByEquipRefine)
	}

	player.SaveModel(equip)

	_ = player.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemEquipChange), &pb.EquipChangeListAck{
		ChangeList: []*pb.EquipChange{{ChangeType: pb.ChangeType_Changed, Equip: equip.BuildMsgEquip()}},
	})

	if equip.RefineLevel != preLevel {
		player.SendUpgradeMaster(pb.UpgradeMasterType_MasterEquipRefine, preLevel, equip.RefineLevel, equip.HeroUid)
	}
}

func (this *PlayerHandler) TreasureUpgrade(player *logic.Player, msg *net.Message) {
	var req = new(pb.TreasureUpgradeReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.TreasureUid == 0 {
		this.logger.Error("Parameter error, req.TreasureUid == 0")
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	switch req.Type {
	case 1:
		if req.Value != 1 {
			this.logger.Error("Parameter error, req.Value != 1")
			_ = player.TipNotice(proto.TipParameterError)
			return
		}
	case 2:
		if req.Value == 0 {
			this.logger.Error("Parameter error, req.Value == 0")
			_ = player.TipNotice(proto.TipParameterError)
			return
		}
	default:
		this.logger.Error("Parameter error, req.Type: ", req.Type)
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	var treasure = player.Treasure[req.TreasureUid]
	if treasure == nil {
		this.logger.Error("Parameter error, treasure was not found, req.TreasureUid: ", req.TreasureUid)
		_ = player.TipNotice(proto.TipTreasureNotFound)
		return
	}

	var treasureTable = this.tables.Treasure.Get(int(treasure.Id))
	if treasureTable == nil {
		this.logger.Error("Parameter or data error, table 'Treasure' was not found, treasure.Id: ", treasure.Id)
		_ = player.TipNotice(proto.TipDataTablesError)
		return
	}

	if treasure.Level >= uint32(treasureTable.Levels) {
		_ = player.TipNotice(proto.TipLevelAlreadyMax)
		return
	}

	if player.CheckFunctionOpen(pb.ModId_ModuleItem, pb.FuncType_FuncTreasureUpgrade, int(treasure.Level+1)) {
		_ = player.TipNotice(proto.TipLevelAlreadyMax)
		return
	}

	var levelTable = this.tables.TreasureLevel.Find3(int(treasure.Id), int(treasure.Level))
	if levelTable == nil {
		this.logger.Error("Parameter or data error, table 'TreasureLevel' was not found, treasure.Id: ", treasure.Id)
		_ = player.TipNotice(proto.TipDataTablesError)
		return
	}

	var preLevel = treasure.Level
	switch req.Type {
	case 1:
		var itemTables = this.tables.Item.Find2(int(pb.ItemType_ItemProp), int(pb.PropType_TreasureExp))
		if len(itemTables) == 0 {
			this.logger.Error("Data error, the item list is empty, type: %d, subType: %d", pb.ItemType_ItemProp, pb.PropType_TreasureExp)
			_ = player.TipNotice(proto.TipDataTablesError)
			return
		}

		var exp = treasure.Exp
		var level = treasure.Level
		var consumeItems = map[uint32]uint32{}
		for _, itemTable := range itemTables {
			var item = player.Item[uint32(itemTable.Id)]
			if item == nil {
				continue
			}

			var needExp = uint32(levelTable.NeedExp) - exp
			var needNum = needExp / uint32(itemTable.Value)
			if needExp%uint32(itemTable.Value) > 0 {
				needNum += 1
			}

			if needNum <= item.Num {
				consumeItems[item.Id] = needNum
				exp = uint32(itemTable.Value)*needNum - exp
				level += 1
				break
			} else {
				consumeItems[item.Id] = item.Num
				exp += uint32(itemTable.Value) * item.Num
			}
		}

		treasure.Exp = exp
		treasure.Level = level

		player.ReduceItems(consumeItems, logic.LogTypeItemConsumeByTreasureUpgrade)
	case 2:
		var itemTable = this.tables.Item.Find1(int(req.Value))
		if itemTable == nil {
			this.logger.Error("Parameter or data error, table 'Item' was not found, itemId: ", req.Value)
			_ = player.TipNotice(proto.TipDataTablesError)
			return
		}

		if ok, tip := player.CheckItem(req.Value, 1); !ok {
			_ = player.TipNotice(tip)
			return
		}

		treasure.Exp += uint32(itemTable.Value)
		if treasure.Exp >= uint32(levelTable.NeedExp) {
			treasure.Level += 1
			treasure.Exp -= uint32(levelTable.NeedExp)
		}

		player.ReduceItem(req.Value, 1, logic.LogTypeItemConsumeByTreasureUpgrade)
	}

	player.SaveModel(treasure)

	_ = player.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemTreasureChange), &pb.TreasureChangeListAck{
		ChangeList: []*pb.TreasureChange{{ChangeType: pb.ChangeType_Changed, Treasure: treasure.BuildMsgTreasure()}},
	})

	if treasure.Level != preLevel {
		player.SendUpgradeMaster(pb.UpgradeMasterType_MasterTreasureUpgrade, preLevel, treasure.Level, treasure.HeroUid)
	}
}

func (this *PlayerHandler) TreasureRefine(player *logic.Player, msg *net.Message) {
	var req = new(pb.TreasureRefineReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.TipMessageError)
		return
	}

	if req.TreasureUid == 0 {
		this.logger.Error("Parameter error, req.TreasureUid == 0")
		_ = player.TipNotice(proto.TipParameterError)
		return
	}

	var equip = player.Treasure[req.TreasureUid]
	if equip == nil {
		this.logger.Error("Parameter error, equip was not found, req.TreasureUid: ", req.TreasureUid)
		_ = player.TipNotice(proto.TipTreasureNotFound)
		return
	}

	var equipTable = this.tables.Treasure.Get(int(equip.Id))
	if equipTable == nil {
		this.logger.Error("Parameter or data error, table 'Treasure' was not found, equip.Id: ", equip.Id)
		_ = player.TipNotice(proto.TipDataTablesError)
		return
	}

	if equip.Level >= uint32(equipTable.Levels) {
		_ = player.TipNotice(proto.TipLevelAlreadyMax)
		return
	}

	if player.CheckFunctionOpen(pb.ModId_ModuleItem, pb.FuncType_FuncTreasureUpgrade, int(equip.Level+1)) {
		_ = player.TipNotice(proto.TipLevelAlreadyMax)
		return
	}

	var levelTable = this.tables.TreasureRefine.Find3(int(equip.Id), int(equip.Level))
	if levelTable == nil {
		_ = player.TipNotice(proto.TipDataTablesError)
		return
	}

	for i := range levelTable.ConsumeItems {
		if ok, tip := player.CheckItem(uint32(levelTable.ConsumeItems[i]), uint32(levelTable.ConsumeNums[i])); !ok {
			_ = player.TipNotice(tip)
			return
		}
	}

	var nextLevelTable = this.tables.TreasureLevel.Find3(int(equip.Id), int(equip.Level+1))
	if nextLevelTable == nil {
		_ = player.TipNotice(proto.TipDataTablesError)
		return
	}

	var preLevel = equip.Level
	equip.Level = uint32(nextLevelTable.Level)
	for i := range levelTable.ConsumeItems {
		player.ReduceItem(uint32(levelTable.ConsumeItems[i]), uint32(levelTable.ConsumeNums[i]), logic.LogTypeItemConsumeByTreasureUpgrade)
	}

	player.SaveModel(equip)

	_ = player.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemTreasureChange), pb.TreasureChangeListAck{
		ChangeList: []*pb.TreasureChange{{Treasure: equip.BuildMsgTreasure(), ChangeType: pb.ChangeType_Add}},
	})

	player.SendUpgradeMaster(pb.UpgradeMasterType_MasterTreasureRefine, preLevel, equip.Level, equip.HeroUid)
	return
}