ecs/servers/game/logic/player_item.go

package logic

import (
	"ecs/proto"
	"ecs/proto/pb"
	"ecs/servers/game/data"
)

type PlayerItem struct {
	Id  uint32 `bson:"id" key:"1"`
	Num uint32 `bson:"num"`
}

func (this *PlayerItem) BuildMsgItem() *pb.Item {
	return &pb.Item{ItemId: this.Id, ItemNum: this.Num}
}

func (this *Player) addItemDirect(itemTable *data.Item, itemNum uint32, logType LogType) *pb.ItemChange {
	var changeType = pb.ChangeType_Changed
	var item = this.Item[uint32(itemTable.Id)]

	if item == nil {
		item = &PlayerItem{Id: uint32(itemTable.Id), Num: itemNum}
		this.Item[item.Id] = item

		changeType = pb.ChangeType_Add
	} else {
		item.Num += itemNum
	}

	this.SaveModel(item)

	//this.CheckTask(proto.TaskSection1CollectSpecificItem, itemTable.Id, int(itemNum))

	//if logType > 0 {
	//	this.manager.eventManager.PlayerItemObtain(this, logType, uint32(itemTable.Id), itemNum)
	//}

	return &pb.ItemChange{ChangeType: changeType, Item: item.BuildMsgItem()}
}

func (this *Player) addItem(itemTable *data.Item, itemNum uint32, logType LogType) (itemChange *pb.ItemChange, ok bool) {
	switch pb.ItemType(itemTable.Type) {
	case pb.ItemType_ItemProp:
		itemChange = this.addItemDirect(itemTable, itemNum, logType)
	case pb.ItemType_ItemMoney:
		ok = this.AddMoney(pb.MoneyType(itemTable.SubType), itemNum, logType)
	case pb.ItemType_ItemHero:
		if pb.HeroType(itemTable.SubType) == pb.HeroType_HeroPiece {
			itemChange = this.addItemDirect(itemTable, itemNum, logType)
		} else {
			ok = this.AddHero(uint32(itemTable.Value))
		}
	case pb.ItemType_ItemEquip:
		if pb.EquipType(itemTable.SubType) == pb.EquipType_EquipPiece {
			itemChange = this.addItemDirect(itemTable, itemNum, logType)
		} else {
			this.AddEquips(uint32(itemTable.Id), itemNum, logType)
		}
	case pb.ItemType_ItemTreasure:
		if pb.TreasureType(itemTable.SubType) == pb.TreasureType_TreasurePiece {
			itemChange = this.addItemDirect(itemTable, itemNum, logType)
		} else {
			this.AddTreasures(uint32(itemTable.Id), itemNum, logType)
		}
	case pb.ItemType_ItemArtifact:
	case pb.ItemType_ItemSack:
	case pb.ItemType_ItemOrnament:
	case pb.ItemType_ItemFateChart:
	case pb.ItemType_ItemGem:
	case pb.ItemType_ItemArtifactGem:
	case pb.ItemType_ItemAwakenProp:
	case pb.ItemType_ItemGeneral:
	case pb.ItemType_ItemTetris:
	}
	return
}

func (this *Player) useItem(itemTable *data.Item, itemNum uint32, logType LogType) bool {
	switch pb.ItemType(itemTable.Type) {
	case pb.ItemType_ItemMoney:
		this.AddMoney(pb.MoneyType(itemTable.SubType), uint32(itemTable.Value)*itemNum, logType)
	case pb.ItemType_ItemProp:
	default:
		return false
	}
	return true
}

func (this *Player) AddItem(itemId, itemNum uint32, logType LogType) bool {
	var itemTable = this.manager.tables.Item.Find1(int(itemId))
	if itemTable == nil {
		this.manager.logger.Error("Find item table failed, itemId: ", itemId)
		return false
	}

	if itemTable.UseDirect {
		return this.useItem(itemTable, itemNum, logType)
	}

	itemChange, ok := this.addItem(itemTable, itemNum, logType)
	if itemChange != nil {
		_ = this.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemChange), &pb.ItemChangeListAck{ChangeList: []*pb.ItemChange{itemChange}})
	}
	return ok
}

func (this *Player) AddItems(itemMap map[uint32]uint32, logType LogType) {
	var changeList []*pb.ItemChange
	for itemId, itemNum := range itemMap {
		var itemTable = this.manager.tables.Item.Get(int(itemId))
		if itemTable == nil {
			this.manager.logger.Error("Find item table failed, itemId: ", itemId)
			continue
		}

		if itemTable.UseDirect {
			this.useItem(itemTable, itemNum, logType)
		} else {
			itemChange, _ := this.addItem(itemTable, itemNum, logType)
			if itemChange != nil {
				changeList = append(changeList, itemChange)
			}
		}
	}

	if len(changeList) > 0 {
		_ = this.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemChange), &pb.ItemChangeListAck{ChangeList: changeList})
	}
}

func (this *Player) checkItem(itemId, itemNum uint32) bool {
	var item = this.Item[itemId]
	return item != nil && item.Num >= itemNum
}

func (this *Player) CheckItem(itemId, itemNum uint32) (bool, proto.TipError) {
	if itemId == 0 || itemNum == 0 {
		return false, nil
	}

	var itemTable = this.manager.tables.Item.Get(int(itemId))
	if itemTable == nil {
		return false, proto.TipDataTablesError
	}

	switch pb.ItemType(itemTable.Type) {
	case pb.ItemType_ItemMoney:
		return this.CheckMoney(pb.MoneyType(itemTable.SubType), itemNum)
	case pb.ItemType_ItemProp:
		if this.checkItem(itemId, itemNum) {
			return true, nil
		}
		return false, proto.TipItemNotEnough
	case pb.ItemType_ItemEquip:
	case pb.ItemType_ItemTreasure:
	case pb.ItemType_ItemArtifact:
	case pb.ItemType_ItemSack:
	case pb.ItemType_ItemOrnament:
	case pb.ItemType_ItemFateChart:
	case pb.ItemType_ItemGem:
	case pb.ItemType_ItemArtifactGem:
	case pb.ItemType_ItemAwakenProp:
	case pb.ItemType_ItemGeneral:
	case pb.ItemType_ItemTetris:
	default:
		return false, proto.TipUnknownItemType
	}
	return false, proto.TipUnknownItemType
}

func (this *Player) reduceItem(itemId, itemNum uint32, logType LogType) {
	var item = this.Item[itemId]
	if item == nil || item.Num < itemNum {
		this.manager.logger.Error("Reduce item out of range, does not check before deducting?")
		return
	}

	item.Num -= itemNum

	var changeType pb.ChangeType
	if item.Num == 0 {
		delete(this.Item, item.Id)
		this.WipeModel(item)
		changeType = pb.ChangeType_Delete
	} else {
		this.SaveModel(item)
		changeType = pb.ChangeType_Changed
	}

	_ = this.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemChange), &pb.ItemChangeListAck{ChangeList: []*pb.ItemChange{{Item: item.BuildMsgItem(), ChangeType: changeType}}})

	//if logType > 0 {
	//	this.manager.eventManager.PlayerItemConsume(this, logType, itemId, itemNum)
	//}
}

func (this *Player) ReduceItem(itemId, itemNum uint32, logType LogType) {
	if itemId == 0 || itemNum == 0 {
		return
	}

	var itemTable = this.manager.tables.Item.Get(int(itemId))
	if itemTable == nil {
		return
	}

	switch pb.ItemType(itemTable.Type) {
	case pb.ItemType_ItemMoney:
		this.ReduceMoney(pb.MoneyType(itemTable.SubType), itemNum, logType)
	case pb.ItemType_ItemProp:
		this.reduceItem(itemId, itemNum, logType)
	case pb.ItemType_ItemEquip:
	case pb.ItemType_ItemTreasure:
	case pb.ItemType_ItemArtifact:
	case pb.ItemType_ItemSack:
	case pb.ItemType_ItemOrnament:
	case pb.ItemType_ItemFateChart:
	case pb.ItemType_ItemGem:
	case pb.ItemType_ItemArtifactGem:
	case pb.ItemType_ItemAwakenProp:
	case pb.ItemType_ItemGeneral:
	case pb.ItemType_ItemTetris:
	}
}

func (this *Player) BuildMsgItemListAck() *pb.ItemListAck {
	var list []*pb.Item
	for _, item := range this.Item {
		if item.Id > 0 {
			list = append(list, item.BuildMsgItem())
		}
	}
	return &pb.ItemListAck{ItemList: list}
}