mylib
/
GameServer
/
logic
/
LC_League.go

package logic

import (
	"time"

	csv "gitee.com/liuxuezhan/mylib/GameServer/CSV"
	"gitee.com/liuxuezhan/mylib/GameServer/JsonConfig"
	"gitee.com/liuxuezhan/mylib/GameServer/cache"
	"gitee.com/liuxuezhan/mylib/GameServer/observer"
	"gitee.com/liuxuezhan/mylib/GameServer/oss"
	"gitee.com/liuxuezhan/mylib/GameServer/rpcClient"
	proto "gitee.com/liuxuezhan/mylib/Protocol"
	"gitee.com/liuxuezhan/mylib/Utils/wlog"
	"gitee.com/liuxuezhan/mylib/common"
	"gitee.com/liuxuezhan/mylib/httputils"
	"gitee.com/liuxuezhan/mylib/wtime"
)

const (
	LEAGUERIGHT_DriveOut uint32 = iota
	LEAGUERIGHT_Transfer
	LEAGUERIGHT_PermissionUp
	LEAGUERIGHT_SetLang
	LEAGUERIGHT_ChangeLeagueName
	LEAGUERIGHT_ChangeDeclaration
	LEAGUERIGHT_Dissolution
	LEAGUERIGHT_ChangeRecruit
	LEAGUERIGHT_SetUpTechnology
	LEAGUERIGHT_StoreStock
	LEAGUERIGHT_OpenActivity
	LEAGUERIGHT_ChangeGrade
	LEAGUERIGHT_QuitLeague
	LEAGUERIGHT_ViewDistribution
	LEAGUERIGHT_LeagueMail
	LEAGUERIGHT_Online
	LEAGUERIGHT_ChangeRankName
	LEAGUERIGHT_ChangeFlag
	LEAGUERIGHT_WhetherApply
	LEAGUERIGHT_Invitation
	LEAGUERIGHT_OpenDepot
	LEAGUERIGHT_ModifyrRankName
	LEAGUERIGHT_DescardCity
	LEAGUERIGHT_ChangeNotice
	LEAGUERIGHT_DeleteMessage
	LEAGUERIGHT_LeagueCupTask
	LEAGUERIGHT_BuildingDemolition //联盟建筑拆除
	LEAGUERIGHT_BuildingPlacement  //联盟建筑放置
	LEAGUERIGHT_DisbandGarrison    //联盟驻防解散
	LEAGUERIGHT_MonsterAtkCity     //怪物攻城
)

var (
	leagueLastUpdateTime = wtime.GetTodayZeroClock()
)

func CheckRight(uid uint64, right uint32) (proto.LeagueResult, *cache.Info, *cache.GlobalLeagueEntry) {
	userData := cache.GetCharinfo(uid)
	if userData == nil || userData.GetLeagueID() == 0 {
		return proto.LeagueResult_LeagueIsNotMember, userData, nil
	}
	leaguaData := cache.Instance_GlobalAssetLeague.GetLeagueData(userData.GetLeagueID())
	if nil == leaguaData {
		return proto.LeagueResult_LeagueParamsError, userData, nil
	}
	memberLevel := cache.Instance_GlobalAssetLeague.GetMemberLevel(userData.GetLeagueID(), uid)
	if !CheckLeagueRight(uid, memberLevel, right) {
		return proto.LeagueResult_LeaguePermissionDeny, userData, leaguaData
	}
	return proto.LeagueResult_LeagueSuccess, userData, leaguaData
}

func CheckLeagueRight(uid uint64, leaguelevel int32, right uint32) bool {
	if leaguelevel == -1 {
		return false
	}
	csvConfig := csv.Mgr.CSV_LeagueRight.GetEntryPtr(int64(leaguelevel + 1))
	if csvConfig == nil {
		return false
	}
	switch right {
	case LEAGUERIGHT_DriveOut:
		if csvConfig.DriveOut == 1 {
			return true
		}
	case LEAGUERIGHT_Transfer:
		if csvConfig.Transfer == 1 {
			return true
		}
	case LEAGUERIGHT_PermissionUp:
		if csvConfig.PermissionUp == 1 {
			return true
		}
	case LEAGUERIGHT_SetLang:
		if csvConfig.SetLang == 1 {
			return true
		}
	case LEAGUERIGHT_ChangeLeagueName:
		if csvConfig.ChangeLeagueName == 1 {
			return true
		}
	case LEAGUERIGHT_ChangeDeclaration:
		if csvConfig.ChangeDeclaration == 1 {
			return true
		}
	case LEAGUERIGHT_Dissolution:
		if csvConfig.Dissolution == 1 {
			return true
		}
	case LEAGUERIGHT_ChangeRecruit:
		if csvConfig.ChangeRecruit == 1 {
			return true
		}
	case LEAGUERIGHT_SetUpTechnology:
		if csvConfig.SetUpTechnology == 1 {
			return true
		}
	case LEAGUERIGHT_StoreStock:
		if csvConfig.StoreStock == 1 {
			return true
		}
	case LEAGUERIGHT_OpenActivity:
		if csvConfig.OpenActivity == 1 {
			return true
		}
	case LEAGUERIGHT_ChangeGrade:
		if csvConfig.ChangeGrade == 1 {
			return true
		}
	case LEAGUERIGHT_QuitLeague:
		if csvConfig.QuitLeague == 1 {
			return true
		}
	case LEAGUERIGHT_ViewDistribution:
		if csvConfig.ViewDistribution == 1 {
			return true
		}
	case LEAGUERIGHT_LeagueMail:
		if csvConfig.LeagueMail == 1 {
			return true
		}
	case LEAGUERIGHT_Online:
		if csvConfig.Online == 1 {
			return true
		}
	case LEAGUERIGHT_ChangeRankName:
		if csvConfig.ChangeRankName == 1 {
			return true
		}
	case LEAGUERIGHT_ChangeFlag:
		if csvConfig.ChangeFlag == 1 {
			return true
		}
	case LEAGUERIGHT_WhetherApply:
		if csvConfig.WhetherApply == 1 {
			return true
		}
	case LEAGUERIGHT_Invitation:
		if csvConfig.Invitation == 1 {
			return true
		}
	case LEAGUERIGHT_OpenDepot:
		if csvConfig.OpenDepot == 1 {
			return true
		}
	case LEAGUERIGHT_ModifyrRankName:
		if csvConfig.ModifyrRankName == 1 {
			return true
		}
	case LEAGUERIGHT_DescardCity:
		if csvConfig.DescardCity == 1 {
			return true
		}
	case LEAGUERIGHT_ChangeNotice:
		if csvConfig.ChangeNotice == 1 {
			return true
		}
	case LEAGUERIGHT_DeleteMessage:
		if csvConfig.DeleteMessage == 1 {
			return true
		}
	case LEAGUERIGHT_LeagueCupTask:
		if csvConfig.DeleteCupsTask == 1 {
			return true
		}
	case LEAGUERIGHT_BuildingDemolition:
		if csvConfig.BuildingDemolition == 1 {
			return true
		}
	case LEAGUERIGHT_BuildingPlacement:
		if csvConfig.BuildingPlacement == 1 {
			return true
		}
	case LEAGUERIGHT_DisbandGarrison:
		if csvConfig.DisbandGarrison == 1 {
			return true
		}
	case LEAGUERIGHT_MonsterAtkCity:
		if csvConfig.CorsairInvade == 1 {
			return true
		}
	}

	return false
}
func GetSimpleInfoList(uid uint64, index int32) *proto.ST_League_Simple_Info_List {
	userData := cache.GetCharinfo(uid)
	if nil == userData {
		return nil
	}
	dbPblist := cache.Instance_GlobalAssetLeague.GetIndexData(userData, index)
	simpleList := &proto.ST_League_Simple_Info_List{}
	if dbPblist == nil {
		return simpleList
	}
	simpleList.SimpleInfoList = dbPblist
	return simpleList
}

func GetLeagueDetailData(id uint64, vid uint32) *proto.ST_League_Detail_Info {
	if cache.Instance_GlobalAssetLeague.GetLeagueVersion(id) == vid {
		return nil
	}

	leagueAsset := cache.Instance_GlobalAssetLeague.CopyLeagueAsset(id)
	if leagueAsset == nil {
		return nil
	}
	leagueAsset.SimpleInfo.MessageList = make([]*proto.ST_LeagueMessageEntry_PB, 0)
	leagueAsset.LeagueHelp.Reset()
	leagueAsset.LeagueStatus.Reset()
	leagueAsset.GiftList = make([]*proto.ST_LeagueGift_PB, 0)
	return leagueAsset
}

func GetLeagueHelpDetail(id uint64) *proto.ST_LeagueHelpDetail_PB {
	ret := &proto.ST_LeagueHelpDetail_PB{}
	leagueHelpAsset := cache.Instance_GlobalAssetLeague.CopyLeagueHelpAsset(id)
	if nil == leagueHelpAsset {
		return ret
	}
	for _, v := range leagueHelpAsset.GetLeagueHelpList() {
		ret.HelpList = append(ret.HelpList, v.GetSimple())
	}
	return ret
}

func AddLeagueGift(leagueid uint64, itemid uint32, buyer string, packName uint64) []*proto.ST_LeagueGift_PB {
	leagueAsset := cache.Instance_GlobalAssetLeague.GetLeagueData(leagueid)
	if leagueAsset == nil {
		return nil
	}

	itemMainType := csv.GetItemMainType(itemid)
	if itemMainType != uint32(proto.ItemMainType_IMT_LEAGUEGIFT) &&
		itemMainType != uint32(proto.ItemMainType_IMT_SPECIALGIFT) {
		return nil
	}

	giftid := leagueAsset.AddLeagueGift(itemid)
	cache.NotifyGiftToMembers(leagueid, giftid, itemid, true, buyer, packName)
	return leagueAsset.CopyGiftList()
}
func AddLeagueShopItem(lid, uid uint64, itemid, itemnum uint32) proto.RetActionType {
	ret, _, _ := CheckRight(uid, LEAGUERIGHT_StoreStock)
	if ret != proto.LeagueResult_LeagueSuccess {
		return proto.RetActionType_RAT_INPUT_ERROR
	}
	csvConfig := csv.Mgr.CSV_ItemList.GetEntryPtr(int64(itemid))
	if csvConfig == nil {
		return proto.RetActionType_RAT_INTERNAL_ERROR
	}
	needscore := uint64(csvConfig.LeagueScoreRequire) * uint64(itemnum)
	if cache.Instance_GlobalAssetLeague.GetLeagueScore(lid) < needscore {
		return proto.RetActionType_RAT_INPUT_ERROR
	}
	cache.Instance_GlobalAssetLeague.ReduceLeagueScore(lid, needscore)
	itemEntry := &proto.ST_ItemEntry_PB{
		ItemId:  proto.SetUint32(itemid),
		ItemNum: proto.SetUint32(itemnum),
	}
	cache.Instance_GlobalAssetLeague.AddLeagueShopItem(lid, itemEntry)
	record := &proto.ST_LeagueShopRecord_PB{
		Uid:  proto.SetUint64(uid),
		Time: proto.SetUint64(wtime.GetNow()),
		ItemData: &proto.ST_ItemEntry_PB{ItemId: proto.SetUint32(itemid),
			ItemNum: proto.SetUint32(itemnum),
		}}
	cache.GlobalLeagueBusinessHistoryAsset.AssetData_IncomeHistory.Add(lid, record)
	return proto.RetActionType_RAT_SUCCESS
}

func BuyLeagueShopItem(lid, uid uint64, itemid, itemnum uint32) proto.RetActionType {
	leagueAsset := cache.Instance_GlobalAssetLeague.GetLeagueData(lid)
	userData := cache.GetCharinfo(uid)
	if leagueAsset == nil || userData == nil {
		return proto.RetActionType_RAT_INPUT_ERROR
	}

	if !leagueAsset.HasMember(uid) {
		return proto.RetActionType_RAT_INPUT_ERROR
	}
	csvConfig := csv.Mgr.CSV_ItemList.GetEntryPtr(int64(itemid))
	if csvConfig == nil {
		return proto.RetActionType_RAT_INTERNAL_ERROR
	}
	if !leagueAsset.CheckItem(itemid, itemnum) {
		return proto.RetActionType_RAT_INPUT_ERROR
	}
	if csvConfig.WhetherLeagueShow == 0 {
		return proto.RetActionType_RAT_INPUT_ERROR
	}
	needdevote := uint64(csvConfig.LeagueContributionRequire) * uint64(itemnum)
	if needdevote == 0 {
		return proto.RetActionType_RAT_INPUT_ERROR
	}
	if userData.GetLeagueDevote() < uint32(needdevote) {
		return proto.RetActionType_RAT_INPUT_ERROR
	}
	userData.ReduceLeagueDevote(uint32(needdevote))
	cache.Instance_GlobalAssetLeague.ReduceLeagueShopItem(lid, itemid, itemnum)
	AddItem(userData, itemid, itemnum, oss.AddCashSrcTypeBuyLeagueShopItem)
	record := &proto.ST_LeagueShopRecord_PB{
		Uid:  proto.SetUint64(uid),
		Time: proto.SetUint64(wtime.GetNow()),
		ItemData: &proto.ST_ItemEntry_PB{ItemId: proto.SetUint32(itemid),
			ItemNum: proto.SetUint32(itemnum),
		}}
	cache.GlobalLeagueBusinessHistoryAsset.AssetData_OutcomeHistory.Add(lid, record)
	userData.SyncAchievementAdd(cache.Src2008, &cache.UInt64Tuple{uint64(3), uint64(itemnum)})

	return proto.RetActionType_RAT_SUCCESS
}

/**
@brief 联盟捐献
@param leagueId		联盟ID
@param userId		用户ID
@param technologyID	科技ID
@param devoteType	捐献类型
@param res			响应
*/
func LeagueDevote(leagueId, userId uint64, technologyID uint32, devoteType uint32, res *httputils.Respon) (proto.RetActionType, int32, int32) {
	leagueAsset := cache.Instance_GlobalAssetLeague.GetLeagueData(leagueId)
	userData := cache.GetCharinfo(userId)
	if leagueAsset == nil || userData == nil {
		return proto.RetActionType_RAT_INPUT_ERROR, 0, 0
	}
	csvConfig := csv.Mgr.CSV_LeagueTechnology.GetEntryPtr(int64(technologyID))
	if csvConfig == nil {
		return proto.RetActionType_RAT_INTERNAL_ERROR, 0, 0
	}
	if csvConfig.NextLevelID == 0 {
		return proto.RetActionType_RAT_LEVEL_MAX, 0, 0
	}
	leagueTechAsset := leagueAsset.CopyLeagueTechnology(technologyID)
	if leagueTechAsset == nil || leagueAsset.GetLeagueSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.RetActionType_RAT_INPUT_ERROR, 0, 0
	}

	var exp, score int32
	switch devoteType {
	case 1:
		//>>>单次捐献
		devoteCount, _ := userData.GetDevoteCount()
		if devoteCount >= csv.GetGameConfigValueUint32("Donation_Limit") {
			return proto.RetActionType_RAT_COUNT_MAX, 0, 0
		}
		devoteRequestList := common.ParseStringToVector4(csvConfig.ContributionRequire)
		if 1 != len(devoteRequestList) {
			return proto.RetActionType_RAT_INTERNAL_ERROR, 0, 0
		}
		if !userData.CheckVec4ResourceList(devoteRequestList, 1) { //>>>检查捐献资产是否满足
			return proto.RetActionType_RAT_CON_RESOURCE_ERROR, 0, 0
		}
		devoteIncomeList := common.ParseStringToVector4(csvConfig.ContributionIncome)
		if 2 != len(devoteIncomeList) {
			return proto.RetActionType_RAT_INTERNAL_ERROR, 0, 0
		}
		devoteIncome1 := devoteIncomeList[0]
		devoteIncome2 := devoteIncomeList[1]
		userData.ReduceVec4ResourceList(devoteRequestList, 1, oss.ReduceCashSrcTypeLeagueDevote)                                     //扣除捐献资产
		userData.AddDevoetCount(1)                                                                                                   //增加捐献次数
		techLevel, curExp := cache.Instance_GlobalAssetLeague.AddTechnologyExp(leagueId, technologyID, uint32(devoteIncome1.GetW())) //增加联盟经验值
		userData.AddLeagueDevote(uint32(devoteIncome2.GetW()))                                                                       //增加个人联盟贡献
		cache.Instance_GlobalAssetLeague.AddLeagueScore(leagueId, userId, uint64(devoteIncome2.GetW()))                              //添加联盟积分
		//>>>联盟捐献成就,累积获得100000点联盟贡献[6508801]
		userData.SyncAchievementAdd(cache.LJLMGXDEvent, uint64(devoteIncome2.GetW()))
		// 数据上报
		newOssLeagueDevote(userData, technologyID, uint32(techLevel), uint32(devoteRequestList[0].GetY()), uint32(devoteRequestList[0].GetW()),
			uint32(devoteIncome2.GetW()), uint32(devoteIncome2.GetW()), curExp)
		exp = devoteIncome1.GetW()
		score = devoteIncome2.GetW()
		userData.SyncAchievementAdd(cache.Src2008, &cache.UInt64Tuple{uint64(1), uint64(1)})

	case 2:
		//>>>金币捐献
		needCost := userData.GetDevoteCost(int64(technologyID))
		if !userData.CheckMoney(uint64(needCost)) {
			return proto.RetActionType_RAT_CON_RESOURCE_ERROR, 0, 0
		}
		userData.ReduceMoney(uint64(needCost), oss.ReduceCashSrcTypeLeagueDevote)
		diamondIncomeList := common.ParseStringToVector4(csvConfig.DiamondIncome)
		if 2 != len(diamondIncomeList) {
			return proto.RetActionType_RAT_INTERNAL_ERROR, 0, 0
		}
		diamondIncome1 := diamondIncomeList[0]
		diamondIncome2 := diamondIncomeList[1]
		userData.AddGoldDevoteCount()
		techLevel, curExp := cache.Instance_GlobalAssetLeague.AddTechnologyExp(leagueId, technologyID, uint32(diamondIncome1.GetW()))
		userData.AddLeagueDevote(uint32(diamondIncome2.GetW()))
		cache.Instance_GlobalAssetLeague.AddLeagueScore(leagueId, userId, uint64(diamondIncome2.GetW()))
		//>>>联盟捐献成就,累积获得100000点联盟贡献[6508801]
		userData.SyncAchievementAdd(cache.LJLMGXDEvent, uint64(diamondIncome2.GetW()))
		//>>>修改返回值
		// 数据上报
		newOssLeagueDevote(userData, technologyID, uint32(techLevel), 100, needCost, uint32(diamondIncome2.GetW()), uint32(diamondIncome2.GetW()), curExp)

		exp = diamondIncome1.GetW()
		score = diamondIncome2.GetW()
		userData.SyncAchievementAdd(cache.Src2008, &cache.UInt64Tuple{uint64(1), uint64(1)})
	default:
		return proto.RetActionType_RAT_INPUT_ERROR, 0, 0
	}

	if score > 0 {
		observer.ObserverSingleton.AsyncNotify(observer.ActivityTaskLeagueTechEvent, []interface{}{userData, uint32(1)})
		observer.ObserverSingleton.AsyncNotify(observer.LeagueDonateEvent, []interface{}{userData})
	}

	return proto.RetActionType_RAT_SUCCESS, exp, score
}

func FindLeagueByKey(key string, max int32) *proto.ST_League_Simple_Info_List {
	return cache.Instance_GlobalAssetLeague.FindByKey(key, max)
}
func ReceiveLeagueGift(uid uint64, giftid uint32) (proto.RetActionType, *proto.ST_LeagueGiftSpecial_PB, *proto.ST_Asset_ItemPack_PB) {
	var special *proto.ST_LeagueGiftSpecial_PB
	itemlist := &proto.ST_Asset_ItemPack_PB{
		ItemList: make([]*proto.ST_ItemEntry_PB, 0),
	}
	userData := cache.GetCharinfo(uid)
	if userData == nil {
		return proto.RetActionType_RAT_INPUT_ERROR, special, itemlist
	}
	gift := userData.GetLeagueGift(giftid)
	if gift == nil {
		return proto.RetActionType_RAT_INPUT_ERROR, special, itemlist
	}
	leagueid := userData.GetLeagueID()
	if leagueid == 0 {
		return proto.RetActionType_RAT_INPUT_ERROR, special, itemlist
	}
	itemID := gift.GetInitItemId()
	if itemID == 0 {
		return proto.RetActionType_RAT_INPUT_ERROR, special, itemlist
	}

	if gift.GetState() != 1 || wtime.GetNow() > gift.GetAddTime()+86400 {
		return proto.RetActionType_RAT_INPUT_ERROR, special, itemlist
	}

	itemConfig := csv.Mgr.CSV_ItemList.GetEntryPtr(int64(itemID))
	if itemConfig == nil {
		return proto.RetActionType_RAT_INTERNAL_ERROR, special, itemlist
	}
	if itemConfig.ItemMainType != int64(proto.ItemMainType_IMT_LEAGUEGIFT) &&
		itemConfig.ItemMainType != int64(proto.ItemMainType_IMT_SPECIALGIFT) {
		return proto.RetActionType_RAT_INPUT_ERROR, special, itemlist
	}
	itemFunction := common.ParseParameterStringToMap(itemConfig.ItemFunction)
	if itemConfig.ItemMainType == int64(proto.ItemMainType_IMT_LEAGUEGIFT) {
		exp := common.StringToUint64(itemFunction["exp"])
		key := common.StringToUint64(itemFunction["key"])
		cache.Instance_GlobalAssetLeague.AddSpecialGiftExp(leagueid, exp, key)
		//if -1 != itemID {
		//	AddLeagueGift(leagueid, uint32(itemID))
		//}
		special = cache.Instance_GlobalAssetLeague.CopySpecialGiftAsset(leagueid)
	} else if itemConfig.ItemMainType == int64(proto.ItemMainType_IMT_SPECIALGIFT) {
		//exp := common.StringToUint64(itemFunction["leagueexp"])
		//cache.Instance_GlobalAssetLeague.AddLeaguePackExp(leagueid, exp)
		special = cache.Instance_GlobalAssetLeague.CopySpecialGiftAsset(leagueid)
	}
	its := createItemByVector4(itemFunction["item"])
	//if csv.GetGameConfigValueUint32("LowQualityScore") < uint32(userData.GetLeagueGiftScore()) {
	//	its = createItemByVector4(itemFunction["item1"])
	//}
	newOssLeagueGift(userData, 1, cache.Instance_GlobalAssetLeague.GetLeagueGiftLevel(leagueid), uint32(itemID), leagueid)
	for _, v := range its {
		AddItem(userData, v.GetItemId(), v.GetItemNum(), oss.AddCashSrcTypeReceiveLeagueGift)
		item := &proto.ST_ItemEntry_PB{
			ItemId:  proto.SetUint32(v.GetItemId()),
			ItemNum: proto.SetUint32(v.GetItemNum()),
		}
		itemlist.ItemList = append(itemlist.ItemList, item)
		userData.UpdateLeagueGiftState(giftid, 2, item)

	}
	//userData.AddLeagueGiftScore(common.StringToUint64(itemFunction["QualityScore"]))
	userData.SyncAchievementAdd(cache.Src2008, &cache.UInt64Tuple{uint64(2), uint64(1)})
	if nil != special {
		cache.Instance_GlobalAssetLeague.SyncLeagueAsset(leagueid, proto.SyncType_LeagueSpecialGift, special)
	}
	observer.ObserverSingleton.AsyncNotify(observer.GetLeagueGiftEvent, []interface{}{userData, uint32(1)})
	return proto.RetActionType_RAT_SUCCESS, special, itemlist
}

func ReceiveLeagueKeyGift(uid uint64) (proto.RetActionType, *proto.ST_Asset_ItemPack_PB) {
	itemlist := &proto.ST_Asset_ItemPack_PB{
		ItemList: make([]*proto.ST_ItemEntry_PB, 0),
	}
	userData := cache.GetCharinfo(uid)
	if userData == nil {
		wlog.Error("ReceiveLeagueKeyGift userData nil, uid:", uid)
		return proto.RetActionType_RAT_INPUT_ERROR, itemlist
	}
	leagueid := userData.GetLeagueID()
	if leagueid == 0 {
		wlog.Error("ReceiveLeagueKeyGift leagueid == 0, uid:", uid)
		return proto.RetActionType_RAT_INPUT_ERROR, itemlist
	}

	boxInfo := userData.GetLeagueKeyBox()
	endTime := boxInfo.GetEndTime()
	if boxInfo == nil || endTime == 0 || endTime < wtime.GetNow() {
		wlog.Error("ReceiveLeagueKeyGift key box out of date:", uid)
		return proto.RetActionType_RAT_INPUT_ERROR, itemlist
	}

	itemConfig := csv.Mgr.CSV_ItemList.GetEntryPtr(int64(boxInfo.GetItemId()))
	if itemConfig == nil {
		wlog.Error("ReceiveLeagueKeyGift itemConfig nil, itemid:", boxInfo.GetItemId())
		return proto.RetActionType_RAT_INTERNAL_ERROR, itemlist
	}

	itemFunction := common.ParseParameterStringToMap(itemConfig.ItemFunction)
	its := createItemByVector4(itemFunction["item"])
	for _, v := range its {
		AddItem(userData, v.GetItemId(), v.GetItemNum(), oss.AddCashSrcTypeReceiveLeagueGift)
		item := &proto.ST_ItemEntry_PB{
			ItemId:  proto.SetUint32(v.GetItemId()),
			ItemNum: proto.SetUint32(v.GetItemNum()),
		}
		itemlist.ItemList = append(itemlist.ItemList, item)

	}
	userData.SetLeagueKeyBox(0, 0)

	//observer.ObserverSingleton.AsyncNotify(observer.GetLeagueGiftEvent, []interface{}{userData, uint32(1)})
	return proto.RetActionType_RAT_SUCCESS, itemlist
}

func ReceiveAllLeagueGift(uid uint64) (proto.RetActionType, *proto.ST_LeagueGiftSpecial_PB, *proto.ST_Asset_ItemPack_PB) {
	var special *proto.ST_LeagueGiftSpecial_PB
	itemlist := &proto.ST_Asset_ItemPack_PB{
		ItemList: make([]*proto.ST_ItemEntry_PB, 0),
	}
	userData := cache.GetCharinfo(uid)
	if userData == nil {
		return proto.RetActionType_RAT_INPUT_ERROR, special, itemlist
	}
	leagueid := userData.GetLeagueID()
	if leagueid == 0 {
		return proto.RetActionType_RAT_INPUT_ERROR, special, itemlist
	}
	giftCnt := 0
	score := uint64(0)
	for _, gift := range userData.CopyLeagyueGiftData() {
		if gift.GetState() != 1 || gift.GetBuyer() != "" {
			continue
		}

		if wtime.GetNow() > gift.GetAddTime()+86400 {
			continue
		}

		itemID := gift.GetInitItemId()
		if itemID == 0 {
			continue
		}

		itemConfig := csv.Mgr.CSV_ItemList.GetEntryPtr(int64(itemID))
		if itemConfig == nil {
			continue
		}

		if itemConfig.ItemMainType != int64(proto.ItemMainType_IMT_LEAGUEGIFT) &&
			itemConfig.ItemMainType != int64(proto.ItemMainType_IMT_SPECIALGIFT) {
			continue
		}

		itemFunction := common.ParseParameterStringToMap(itemConfig.ItemFunction)
		if itemConfig.ItemMainType == int64(proto.ItemMainType_IMT_LEAGUEGIFT) {
			exp := common.StringToUint64(itemFunction["exp"])
			key := common.StringToUint64(itemFunction["key"])
			cache.Instance_GlobalAssetLeague.AddSpecialGiftExp(leagueid, exp, key)
			//if -1 != itemID {
			//	AddLeagueGift(leagueid, uint32(itemID))
			//}
			special = cache.Instance_GlobalAssetLeague.CopySpecialGiftAsset(leagueid)
		}

		if itemConfig.ItemMainType == int64(proto.ItemMainType_IMT_SPECIALGIFT) {
			//exp := common.StringToUint64(itemFunction["leagueexp"])
			//cache.Instance_GlobalAssetLeague.AddLeaguePackExp(leagueid, exp)
			special = cache.Instance_GlobalAssetLeague.CopySpecialGiftAsset(leagueid)
		}
		its := createItemByVector4(itemFunction["item"])
		//if csv.GetGameConfigValueUint32("LowQualityScore") < uint32(userData.GetLeagueGiftScore()) {
		//	its = createItemByVector4(itemFunction["item1"])
		//}
		for _, v := range its {
			AddItem(userData, v.GetItemId(), v.GetItemNum(), oss.AddCashSrcTypeReceiveLeagueGift)
			item := &proto.ST_ItemEntry_PB{
				ItemId:  proto.SetUint32(v.GetItemId()),
				ItemNum: proto.SetUint32(v.GetItemNum()),
			}

			itemlist.ItemList = append(itemlist.ItemList, item)
			userData.UpdateLeagueGiftState(gift.GetLeagueGiftID(), 2, item)
			//score += common.StringToUint64(itemFunction["QualityScore"])
		}
		newOssLeagueGift(userData, 1, cache.Instance_GlobalAssetLeague.GetLeagueGiftLevel(leagueid), uint32(itemID), leagueid)
		userData.SyncAchievementAdd(cache.Src2008, &cache.UInt64Tuple{uint64(2), uint64(1)})
		giftCnt += 1
	}
	observer.ObserverSingleton.AsyncNotify(observer.GetLeagueGiftEvent, []interface{}{userData, uint32(giftCnt)})

	userData.AddLeagueGiftScore(score)
	if nil != special {
		cache.Instance_GlobalAssetLeague.SyncLeagueAsset(leagueid, proto.SyncType_LeagueSpecialGift, special)
	}
	return proto.RetActionType_RAT_SUCCESS, special, itemlist
}

func DeleteLeagueGift(uid uint64, giftId uint32) proto.RetActionType {
	userData := cache.GetCharinfo(uid)
	if userData == nil {
		return proto.RetActionType_RAT_INPUT_ERROR
	}

	userData.DeleteLeagueGift(giftId)

	return proto.RetActionType_RAT_SUCCESS
}

func notifymassidtomember(lid, massid uint64, isadd bool) {
	for _, v := range cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(lid) {
		tmpuser := cache.GetCharinfo(v)
		if tmpuser != nil {
			if isadd {
				tmpuser.AddMassID(massid)
			} else {
				if tmpuser.DeleteMassID(massid) {
					recallArmyRefund(tmpuser, uint32(proto.ActionType_AT_WORLDMAP_MASS), massid)
				}
			}
		}
	}
}
func notifyHelpToMembers(lid, uid uint64, actionid uint32, isadd bool) {
	for _, v := range cache.Instance_GlobalAssetLeague.UnsafeGetLeagueMemberIds(lid) {
		tmpuser := cache.GetCharinfo(v)
		if tmpuser != nil {
			if tmpuser.GetUid() == uid {
				continue
			}
			if isadd {
				tmpuser.AddLeagueHelp(uid, actionid)
			} else {
				tmpuser.DeleteLeagueHelp(uid, actionid)
			}

		}
	}
}

func notifyEarlyWarningMailToMembers(wdata *cache.WorldDataEntry, dataEntry *proto.ST_GlobalActionEntry_PB, lid uint64, mailType uint32, sender uint64, targetId int32, title, content *proto.ST_Tips_PB) {
	for _, v := range cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(lid) {
		tmpuser := cache.GetCharinfo(v)
		if tmpuser != nil {
			spyDetail := createSpyDetail(tmpuser.GetUid(), dataEntry.GetUid(), wdata, dataEntry, false)
			tmpuser.AddLanguageIDMailAsset(mailType,
				sender, targetId, int32(proto.MailSourceType_MST_Default), title, content, spyDetail, "")
		}
	}
}

func sendLanguageIDMailToMembers(lid uint64, mailType uint32, title, content *proto.ST_Tips_PB) {
	for _, v := range cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(lid) {
		tmpuser := cache.GetCharinfo(v)
		if tmpuser != nil {
			tmpuser.AddLanguageIDMailAsset(mailType, 0, -1, int32(proto.MailSourceType_MST_League),
				title, content, "", "")
		}
	}
}

func sendRewardLanguageIDMailToMembers(lid uint64, mailType uint32, title, content *proto.ST_Tips_PB, rewardStr string, rewardSource int32) {
	for _, v := range cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(lid) {
		tmpuser := cache.GetCharinfo(v)
		if tmpuser != nil {
			tmpuser.SendConfMailAsset(uint32(proto.MailSourceType_MST_League), mailType, title, content, rewardStr, rewardSource)
		}
	}
}
func notifyMassInfoToMember(lid, uid uint64, languageid uint32, para ...interface{}) {
	for _, v := range cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(lid) {
		tmpuser := cache.GetCharinfo(v)
		if tmpuser != nil {
			if tmpuser.GetUid() == uid {
				continue
			}
			tmpuser.AddTips(languageid, para...)
		}
	}
}
func notifyLeagueDataToMembers(lid uint64) {
	for _, member := range cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(lid) {
		charInfo := cache.GetCharinfo(member)
		if charInfo != nil {
			charInfo.SetLeagueInfo(lid)
		}
	}
}
func notifyMassInfoToMassMember(lid, gactionid uint64, languageid uint32, para ...interface{}) {
	leagueData := cache.Instance_GlobalAssetLeague.GetLeagueData(lid)
	if leagueData == nil {
		return
	}
	actionData := cache.Instance_GlobalAssetGlobalAction.GetGlobalActionAsset(gactionid)
	if actionData == nil {
		return
	}
	if actionData.Actiondata.GetActiontype() != uint32(proto.ActionType_AT_WORLDMAP_MASS) {
		return
	}
	userData := cache.GetCharinfo(actionData.Actiondata.GetUid())
	if userData != nil {
		userData.AddTips(languageid, para...)
	}
	for _, v := range actionData.Actiondata.GetChildrenID() {
		tmpActionData := cache.Instance_GlobalAssetGlobalAction.GetGlobalActionAsset(v)
		if tmpActionData == nil {
			continue
		}
		tmpUserData := cache.GetCharinfo(tmpActionData.Actiondata.GetUid())
		if tmpUserData != nil {
			tmpUserData.AddTips(languageid, para...)
		}
	}
}

func cleanLeagueHelp(lid uint64) {
	list := cache.Instance_GlobalAssetLeague.ClearLeagueHelp(lid)
	for _, v := range list {
		notifyHelpToMembers(lid, v.Simple.Basic.GetUid(), v.Simple.Basic.GetActionID(), false)
	}
}

func GO_UpdateLeagueAsset() {
	for {
		time.Sleep(time.Duration(60) * time.Second)
		autoDismissList := make([]uint64, 0)
		cache.Instance_GlobalAssetLeague.Range(func(key, value interface{}) bool {
			lid := common.ConverToUint64(key)
			leagueData := cache.ConverToGlobalLeagueEntry(value)
			if leagueData == nil {
				return true
			}
			for _, v1 := range leagueData.CopyGiftList() {
				if wtime.GetNow() > v1.GetAddTime()+86400 {
					cache.NotifyGiftToMembers(lid, v1.GetGiftID(), v1.GiftData.GetItemId(), false, "", 0)
					leagueData.DeleteGift(v1.GetGiftID())
				}
			}

			if leagueData.CheckTimeOutLeagueBox() {
				for _, v := range cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(lid) {
					tmpData := cache.GetCharinfo(v)
					if nil != tmpData {
						tmpData.WithLeagueBoxAsset(false, func(asset *proto.ST_Asset_LeagueBox_PB) bool {
							asset.Refresh = proto.SetBool(true)
							tmpData.DirtyAll()
							return true
						})
					}
				}
			}

			processLeagueBattle(leagueData)
			autoDismissTime := leagueData.GetAutoDismissTime()
			if autoDismissTime != 0 && autoDismissTime <= wtime.GetNow() {
				autoDismissList = append(autoDismissList, lid)
			}

			return true
		})

		for _, v := range autoDismissList {
			processAutoDismissLeague(v)
		}

		// 数据上报
		today := wtime.GetTodayZeroClock()
		if today > leagueLastUpdateTime {
			cache.Instance_GlobalAssetLeague.Range(func(key, value interface{}) bool {
				lid := common.ConverToUint64(key)
				leagueData := cache.Instance_GlobalAssetLeague.CopyLeagueAsset(lid)
				//leagueData := cache.ConverToGlobalLeagueEntry(value)
				newOssLeagueDaily(leagueData, today)
				leagueLastUpdateTime = today
				return true
			})
		}
	}
}

func processAutoDismissLeague(lid uint64) {
	ownerId := cache.Instance_GlobalAssetLeague.GetOwnerUid(lid)
	memberList := cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(lid)
	for _, v := range memberList {
		if v != ownerId {
			userData := cache.GetCharinfo(v)
			if userData != nil && lc_removeUserFromLeague(0, v, lid, false) == proto.LeagueResult_LeagueSuccess {
				title := common.CreateTips(10000327)
				content := common.CreateTips(10000328, csv.GetGameConfigValueUint32("AllianceDissolveNum")+1)
				userData.AddLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, int32(v), int32(proto.MailSourceType_MST_Other),
					title, content, "", "")
			}
		}
	}

	ownerData := cache.GetCharinfo(ownerId)
	if nil != ownerData && ExitLeague(ownerId) == proto.LeagueResult_LeagueSuccess {
		title := common.CreateTips(10000327)
		content := common.CreateTips(10000328, csv.GetGameConfigValueUint32("AllianceDissolveNum")+1)
		ownerData.AddLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, int32(ownerId), int32(proto.MailSourceType_MST_Other),
			title, content, "", "")
	}
}

//改变玩家大地图行为及其所拥有的地图块里的公会ID
func processGlobalActionAndwDataJoinLeague(userData *cache.Info) {
	leagueID := userData.GetLeagueID()
	userData.SafeForeachGlobalAction(func(entry *cache.GlobalActionEntry) bool {
		if nil != entry {
			actionData := entry.Actiondata
			actionData.LeagueID = proto.SetUint64(leagueID)
			entry.Dirty()
			wdata := cache.Instance_GlobalAssetWorldData.GetWorldData(actionData.GetWorldDataID())
			if wdata != nil && wdata.GetWorldDataOwner() == userData.GetUid() {
				//修改已拥有的地块里存储的leagueID
				wdata.UpdateOwner(leagueID, actionData.GetUid())
			}
		}
		return true
	})
	//主城所在地
	wDataAsset := cache.Instance_GlobalAssetWorldData.GetWorldDataByTileId(userData.GetLocation())
	if nil != wDataAsset {
		wDataAsset.GetWorldData().SimpleEntry.LeagueId = proto.SetUint64(userData.GetLeagueID())
		wDataAsset.Dirty()
	}

}

func processGlobalActionExitLeague(userData *cache.Info) {
	userData.SafeForeachGlobalAction(func(entry *cache.GlobalActionEntry) bool {
		if nil != entry {
			actionData := entry.Actiondata
			wdata := cache.Instance_GlobalAssetWorldData.GetWorldData(actionData.GetWorldDataID())
			if wdata != nil {
				switch actionData.GetActiontype() {
				case uint32(proto.ActionType_AT_WORLDMAP_COLLECT):
					if actionData.GetStage() == uint32(proto.MapStageType_MST_WORKING) && len(wdata.GetGActionList()) > 1 {
						recallArmy(actionData.GetActionid(), false)
					}
				case uint32(proto.ActionType_AT_WORLDMAP_TRANSPORT):
					if actionData.GetStage() == uint32(proto.MapStageType_MST_MARCH) {
						title := common.CreateTips(90000063)
						content := common.CreateTips(90000186)
						userData.AddLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, -1, int32(proto.MailSourceType_MST_Other),
							title, content, "", "")
					}
					fallthrough
				case uint32(proto.ActionType_AT_WORLDMAP_MASS):
					fallthrough
				case uint32(proto.ActionType_AT_WORLDMAP_JOINMASS):
					processMiracleWarBack(wdata, actionData.GetActionid())
					recallArmy(actionData.GetActionid(), false)
				case uint32(proto.ActionType_AT_WORLDMAP_GARRISON):
					if actionData.GetStage() == uint32(proto.MapStageType_MST_WORKING) {
						processMiracleWarBack(wdata, actionData.GetActionid())
						recallArmy(actionData.GetActionid(), false)
						tmpUser := cache.GetCharinfo(actionData.GetUid())
						if tmpUser != nil {
							title := common.CreateTips(90000065)
							content := common.CreateTips(90000182)
							tmpUser.AddLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, -1, int32(proto.MailSourceType_MST_Other),
								title, content, "", "")
						}
					}
				case uint32(proto.ActionType_AT_WORLDMAP_BESTATIONED):
					if wdata.GetWorldDataOwner() == userData.GetUid() {
						wdata.UpdateOwner(0, userData.GetUid())
					}
				case uint32(proto.ActionType_AT_WORLDMAP_IN), uint32(proto.ActionType_AT_WORLDMAP_OUT):
					recallArmy(actionData.GetActionid(), false)
				}
			}
			actionData.LeagueID = proto.SetUint64(0)
			entry.Dirty()
		}
		return true
	})
	for _, v := range userData.CopyGarrisonList() {
		actionAsset := cache.Instance_GlobalAssetGlobalAction.GetGlobalActionAsset(v)
		if actionAsset == nil {
			continue
		}
		actionData := actionAsset.Actiondata
		recallArmy(actionData.GetActionid(), false)
		tmpUser := cache.GetCharinfo(actionData.GetUid())
		if tmpUser != nil {
			title := common.CreateTips(90000065)
			content := common.CreateTips(90000182)
			tmpUser.AddLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, -1, int32(proto.MailSourceType_MST_Other),
				title, content, "", "")
		}
	}
}

func SetFlag(uid uint64, color, background, icon uint32) proto.LeagueResult {
	ret, userData, leagueAsset := CheckRight(uid, LEAGUERIGHT_ChangeFlag)
	if ret != proto.LeagueResult_LeagueSuccess {
		return ret
	}
	str := csv.GetGameConfigValueString("MODIFY_FLAG_COST")
	cost := common.ParseStringToVector4(str)
	if !userData.CheckVec4ResourceList(cost, 1) {
		return proto.LeagueResult_LeagueParamsError
	}
	userData.ReduceVec4ResourceList(cost, 1, oss.ReduceCashSrcTypeSetLeague)
	leagueAsset.SetFlag(color, background, icon)
	return proto.LeagueResult_LeagueSuccess
}

func SetMemberTitle(uid uint64, titles []*proto.ST_LeagueMemberTitleName_PB) proto.LeagueResult {
	ret, _, leagueAsset := CheckRight(uid, LEAGUERIGHT_ChangeRankName)
	if ret != proto.LeagueResult_LeagueSuccess {
		return ret
	}

	for _, v := range titles {
		if len(v.GetTitleName()) == 0 {
			continue
		}
		leagueAsset.SetMemberTitle(v.GetMemberLevel(), v.GetTitleName())
	}

	return proto.LeagueResult_LeagueSuccess
}

func IgnoreLeagueApply(uid, targetUid uint64) proto.LeagueResult {
	targetUserData := cache.GetCharinfo(targetUid)
	if nil == targetUserData {
		return proto.LeagueResult_LeagueParamsError
	}
	ret, userData, _ := CheckRight(uid, LEAGUERIGHT_WhetherApply)
	if ret != proto.LeagueResult_LeagueSuccess {
		return ret
	}
	cache.Instance_GlobalAssetLeague.DeleteRequestJoin(targetUid, userData.GetLeagueID())
	targetUserData.RemoveLeagueApply(userData.GetLeagueID()) //从申请列表中删除联盟id，可再次申请
	processOssLeagueMemberManage(userData.GetLeagueID(), uid, targetUid, "refuse")

	// 给目标玩家发拒绝邮件
	title := common.CreateTips(90000003)
	content := common.CreateTips(71810, userData.GetUserName(), cache.Instance_GlobalAssetLeague.GetLeagueName(userData.GetLeagueID()))
	targetUserData.AddLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, int32(targetUid), int32(proto.MailSourceType_MST_League), title, content, "", "")

	return proto.LeagueResult_LeagueSuccess
}
func IgnoreAllLeagueApply(uid uint64) proto.LeagueResult {
	ret, userData, _ := CheckRight(uid, LEAGUERIGHT_WhetherApply)
	if ret != proto.LeagueResult_LeagueSuccess {
		return ret
	}

	uids := cache.Instance_GlobalAssetLeague.CopyRequestJoinList(userData.GetLeagueID())
	for _, v := range uids {
		targetUserData := cache.GetCharinfo(v)
		if targetUserData != nil {
			targetUserData.RemoveLeagueApply(userData.GetLeagueID())
		}
		processOssLeagueMemberManage(userData.GetLeagueID(), uid, v, "refuse")
	}

	cache.Instance_GlobalAssetLeague.DeleteAllRequestJoin(userData.GetLeagueID())
	return proto.LeagueResult_LeagueSuccess
}
func AcceptLeagueApply(uid, targetuid uint64) proto.LeagueResult {
	targetUserData := cache.GetCharinfo(targetuid)
	if targetUserData == nil {
		return proto.LeagueResult_LeagueParamsError
	}

	if targetUserData.GetSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}

	ret, userData, _ := CheckRight(uid, LEAGUERIGHT_WhetherApply)
	if ret != proto.LeagueResult_LeagueSuccess {
		return ret
	}

	if targetUserData.GetLeagueID() != 0 {
		if targetUserData.GetLeagueID() == userData.GetLeagueID() {
			userData.AddTips(11000314, targetUserData.GetUserName())
		} else {
			userData.AddTips(11000257)
		}
		cache.Instance_GlobalAssetLeague.DeleteRequestJoin(targetuid, userData.GetLeagueID())
		return proto.LeagueResult_LeagueParamsError
	}

	if wtime.GetNow() < targetUserData.GetJoinLeagueCDTime() {
		userData.AddTips(11000412)
		return proto.LeagueResult_LeagueParamsError
	}

	if ret = lc_joinLeague(targetUserData, userData.GetLeagueID()); ret == proto.LeagueResult_LeagueSuccess {
		userData.AddTips(11000314, targetUserData.GetUserName())
		cache.Instance_GlobalAssetLeague.DeleteRequestJoin(targetuid, userData.GetLeagueID())
		// 数据上报
		processOssLeagueMemberManage(userData.GetLeagueID(), userData.GetUid(), targetUserData.GetUid(), "accept")
	}

	return ret
}
func SetMemTitle(uid, targetuid, title uint64) proto.LeagueResult {
	targetUserData := cache.GetCharinfo(targetuid)
	if targetUserData == nil {
		return proto.LeagueResult_LeagueParamsError
	}

	ret, userData, _ := CheckRight(uid, LEAGUERIGHT_Transfer)
	if ret != proto.LeagueResult_LeagueSuccess {
		return ret
	}

	if targetUserData.GetLeagueID() != 0 {
		if targetUserData.GetLeagueID() == userData.GetLeagueID() {
			ret = cache.Instance_GlobalAssetLeague.SetMemTitle(userData.GetLeagueID(), targetuid, title)

		}

	}

	if ret == proto.LeagueResult_LeagueSuccess {
		tmpPtr := csv.Mgr.CSV_Leagueposition.GetEntryPtr(int64(title))
		if nil != tmpPtr {
			title := common.CreateTips(uint32(tmpPtr.Mail))
			content := common.CreateTips(uint32(tmpPtr.Mail))
			targetUserData.AddLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, -1, int32(proto.MailSourceType_MST_League), title, content, "", "")
		}
	}

	return ret
}
func SetLeague(uid uint64, leaguename, outSlogan, shortname string, language, needreview uint32, max, min uint64) proto.LeagueResult {
	var (
		ret         proto.LeagueResult
		userData    *cache.Info
		leagueAsset *cache.GlobalLeagueEntry
		o_name      string
		o_short     string
	)
	userData = cache.GetCharinfo(uid)
	if userData == nil {
		return proto.LeagueResult_LeagueParamsError
	}

	simpleInfo := cache.Instance_GlobalAssetLeague.CopyLeagueSimpleInfo(userData.GetLeagueID())
	if nil == simpleInfo {
		return proto.LeagueResult_LeagueParamsError
	}
	changeName := false
	canSet := false

	ret, _, leagueAsset = CheckRight(uid, LEAGUERIGHT_ChangeLeagueName)
	if leagueAsset == nil || leagueAsset.GetLeagueSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}
	if ret == proto.LeagueResult_LeagueSuccess && (simpleInfo.GetName() != leaguename || simpleInfo.GetShortName() != shortname) {
		str := csv.GetGameConfigValueString("MODIFY_LEAGUE_COST")
		cost := common.ParseStringToVector4(str)
		if !userData.CheckVec4ResourceList(cost, 1) {
			return proto.LeagueResult_LeagueParamsError
		}
		userData.ReduceVec4ResourceList(cost, 1, oss.ReduceCashSrcTypeSetLeague)
		o_name = simpleInfo.GetName()
		o_short = simpleInfo.GetShortName()
		simpleInfo.Name = proto.SetString(leaguename)
		simpleInfo.ShortName = proto.SetString(shortname)
		changeName = true
		canSet = true
	}
	ret, _, leagueAsset = CheckRight(uid, LEAGUERIGHT_ChangeNotice)
	if ret == proto.LeagueResult_LeagueSuccess && simpleInfo.GetOutSlogan() != outSlogan {
		simpleInfo.OutSlogan = proto.SetString(outSlogan)
		canSet = true
	}
	ret, _, leagueAsset = CheckRight(uid, LEAGUERIGHT_SetLang)
	if ret == proto.LeagueResult_LeagueSuccess && simpleInfo.GetLeagueLanguage() != language {
		simpleInfo.LeagueLanguage = proto.SetUint32(language)
		canSet = true
	}
	need := simpleInfo.GetNeedReview()
	if needreview == 1 {
		need = true
	} else {
		need = false
	}
	ret, _, leagueAsset = CheckRight(uid, LEAGUERIGHT_ChangeRecruit)
	if ret == proto.LeagueResult_LeagueSuccess && (need != simpleInfo.GetNeedReview() || max != simpleInfo.GetMainCityLevel() || min != simpleInfo.GetMinPower()) {
		simpleInfo.NeedReview = proto.SetBool(need)
		simpleInfo.MainCityLevel = proto.SetUint64(max)
		simpleInfo.MinPower = proto.SetUint64(min)
		canSet = true
	}

	if canSet && leagueAsset != nil {
		leagueAsset.SetLeague(simpleInfo.GetName(), simpleInfo.GetOutSlogan(),
			simpleInfo.GetShortName(), simpleInfo.GetLeagueLanguage(), simpleInfo.GetNeedReview(), simpleInfo.GetMainCityLevel(), simpleInfo.GetMinPower())
	}

	if changeName {
		cache.Instance_GlobalAssetLeague.UpdateLeagueNameMap(userData.GetLeagueID(), leaguename, shortname, o_name, o_short)
		rpcClient.ChangeLeagueName(o_name, o_short, leaguename, shortname)
		notifyLeagueDataToMembers(userData.GetLeagueID())
	}

	return proto.LeagueResult_LeagueSuccess
}

func SetLegueSlogan(uid uint64, slogan string) proto.LeagueResult {
	var (
		ret         proto.LeagueResult
		userData    *cache.Info
		leagueAsset *cache.GlobalLeagueEntry
	)
	ret, userData, leagueAsset = CheckRight(uid, LEAGUERIGHT_ChangeDeclaration)
	if leagueAsset != nil && leagueAsset.GetLeagueSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}
	if ret == proto.LeagueResult_LeagueSuccess {
		leagueAsset.SetLeagueSlogan(slogan)
	}
	observer.ObserverSingleton.AsyncNotify(observer.LeagueSetSlogan, []interface{}{userData.GetLeagueID(), slogan})
	return proto.LeagueResult_LeagueSuccess
}

func lc_joinLeague(userdata *cache.Info, lid uint64) proto.LeagueResult {
	lAsset := cache.Instance_GlobalAssetLeague.GetLeagueData(lid)
	if lAsset == nil || lAsset.GetLeagueSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueIsNotExist
	}

	capacity := cache.Instance_GlobalAssetLeague.GetMemberCapacity(lid) //>>>联盟成员上限
	if capacity <= 0 {
		return proto.LeagueResult_LeagueIsNotExist
	}
	if capacity <= uint32(cache.Instance_GlobalAssetLeague.GetLeagueMemberCount(lid)) {
		return proto.LeagueResult_LeaqueIsFull
	}
	memberPb := &proto.ST_League_Member_Info{
		Id:                   proto.SetUint64(userdata.GetUid()),
		Level:                proto.SetInt32(int32(proto.LeagueMemberLevel_LeagueMemberLevel0)),
		LastRefreshTimestamp: proto.SetUint64(0),
		Power:                proto.SetUint64(userdata.GetPower()),
		KillNum:              proto.SetUint64(userdata.GetKillUnitNum()),
	}

	retVal := cache.Instance_GlobalAssetLeague.AddMember(lid, memberPb, capacity)
	if !retVal {
		return proto.LeagueResult_LeaqueIsFull
	}

	if !userdata.GetLeagueJoinedState() {
		leaguereward := csv.GetGameConfigValueUint32("Leaguereward")
		userdata.AddMoney(uint64(leaguereward), oss.AddCashSrcTypeJoinLeague)
	}

	title := common.CreateTips(90000080)
	content := common.CreateTips(90000081, cache.Instance_GlobalAssetLeague.GetLeagueName(lid))
	if userdata.IsJoinedLeague() == false {
		itemList := common.ParseStringToVector4(csv.GetGameConfigValueString("Welcome_Union_Mail_Reward"))
		rewList := &proto.ST_MailRewardList_PB{}
		for _, item := range itemList {
			rewList.Reward = append(rewList.Reward, item)
		}
		rewardStr := proto.Marshal(rewList)
		userdata.AddRewardLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, -1, int32(proto.MailSourceType_MST_League), oss.MRS_JoinLeague, title, content, "", "", string(rewardStr))
	} else {
		userdata.AddRewardLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, -1, int32(proto.MailSourceType_MST_League), oss.MRS_JoinLeague, title, content, "", "", "")
	}

	userdata.SetLeagueInfo(lid)
	userdata.SetLeagueJoinTime(wtime.GetNow())
	userdata.ReadLeagueBattleLog()
	wdataID := userdata.GetWorldDataId()
	wdata := cache.Instance_GlobalAssetWorldData.GetWorldData(wdataID)
	if wdata != nil {
		wdata.UpdateOwner(lid, userdata.GetUid())
	}
	processGlobalActionAndwDataJoinLeague(userdata)
	status := &proto.ST_LeagueStatusEntry_PB{
		Type:     proto.SetUint32(uint32(proto.LeagueStausType_LST_PLAYER_JOIN)),
		Time:     proto.SetUint64(wtime.GetNow()),
		PlayerID: proto.SetUint64(userdata.GetUid()),
		OldLevel: proto.SetUint32(0),
	}
	cache.Instance_GlobalAssetLeague.AddLeagueStatus(lid, status)
	userdata.ClearLeagueApply()
	// 数据上报
	processOssLeagueMemberManage(lid, userdata.GetUid(), 0, "join")
	TrySetLeagueTaskRefreshTimestamp(userdata.GetUid())

	processTechnologyJoinLeague(userdata)
	userdata.AddFirstTutorialTimes(uint32(proto.FirstTutorialType_FTT_JOIN_LEAGUE))

	observer.ObserverSingleton.AsyncNotify(observer.UserJoinLeagueEvent, []interface{}{userdata, lid})

	loginProcessTransferBattle(userdata)

	return proto.LeagueResult_LeagueSuccess
}

func processTechnologyJoinLeague(userData *cache.Info) {
	if userData == nil {
		return
	}

	for _, v := range cache.Instance_GlobalAssetLeague.GetLeagueTechnologyIds(userData.GetLeagueID()) {
		conf := csv.Mgr.CSV_LeagueTechnology.GetEntryPtr(int64(v))
		if conf != nil {
			cache.SetAttribute(userData, conf.Function, uint32(proto.AttributeSource_League)) //ok
		}
	}

	ReCountLeagueMemberCityBuff(userData.GetLeagueID())
}

func JoinLeague(uid, leagueid uint64) proto.LeagueResult {
	userdata := cache.GetCharinfo(uid)
	if userdata == nil {
		return proto.LeagueResult_LeagueParamsError
	}

	if userdata.GetSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}

	if userdata.GetLeagueID() != 0 {
		userdata.AddTips(11000173, cache.Instance_GlobalAssetLeague.GetLeagueName(userdata.GetLeagueID()))
		return proto.LeagueResult_LeagueJoined
	}

	if userdata.GetJoinLeagueCDTime() > wtime.GetNow() {
		userdata.AddTips(11000410, common.TimeFormatString(userdata.GetJoinLeagueCDTime()-wtime.GetNow()))
		return proto.LeagueResult_LeagueParamsError
	}

	leagueAsset := cache.Instance_GlobalAssetLeague.GetLeagueData(leagueid)
	if leagueAsset == nil {
		return proto.LeagueResult_LeagueIsNotExist
	}

	if leagueAsset.GetLeagueSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}

	if leagueAsset.HasMember(uid) {
		return proto.LeagueResult_LeagueJoined
	}

	simpleInfo := cache.Instance_GlobalAssetLeague.CopyLeagueSimpleInfo(leagueid)

	power := userdata.GetPower()
	if simpleInfo.GetMinPower() != 0 && power < simpleInfo.GetMinPower() {
		return proto.LeagueResult_LeagueParamsError
	}
	if simpleInfo.GetMainCityLevel() != 0 && uint64(userdata.GetMainCityLevel()) < simpleInfo.GetMainCityLevel() {
		return proto.LeagueResult_LeagueParamsError
	}
	tm := wlog.CountApi(" ", 0)

	if simpleInfo.GetNeedReview() {
		if cache.Instance_GlobalAssetLeague.AddRequestJoin(leagueid, uid) {
			userdata.AddLeagueApply(leagueid)
			processOssLeagueMemberManage(leagueid, uid, 0, "aplly")

			title := common.CreateTips(90000176)
			content := common.CreateTips(90000086, cache.Instance_GlobalAssetLeague.GetLeagueName(userdata.GetLeagueID()))
			userdata.AddLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, -1, int32(proto.MailSourceType_MST_League), title, content, "", "")
		}
	} else {
		if ret := lc_joinLeague(userdata, leagueid); proto.LeagueResult_LeagueSuccess != ret {
			return ret
		}
	}
	userdata.SetBufdid()
	tm = wlog.CountApi("JoinLeague3", tm)

	//>>>通知联盟战力更新
	return proto.LeagueResult_LeagueSuccess
}

func processOssLeagueMemberManage(lid, uid, toUid uint64, Type string) {
	newOssLeagueManage(uid, lid, Type, toUid)
}

func CreateLeague(ownerID uint64, name string, shortName string, slogan string,
	needreview uint32, maxpower, minpower uint64) proto.LeagueResult {
	userdata := cache.GetCharinfo(ownerID)
	if userdata == nil {
		return proto.LeagueResult_LeagueParamsError
	}

	if userdata.GetSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}

	if userdata.GetLeagueID() != 0 {
		userdata.AddTips(11000173, userdata.GetLeagueName())
		return proto.LeagueResult_LeagueParamsError
	}

	if userdata.GetJoinLeagueCDTime() > wtime.GetNow() {
		userdata.AddTips(11000411, common.TimeFormatString(userdata.GetJoinLeagueCDTime()-wtime.GetNow()))
		return proto.LeagueResult_LeagueParamsError
	}

	str := csv.GetGameConfigValueString("CREATEALLIANCE_COST")
	cost := common.ParseStringToVector4(str)
	if !userdata.CheckVec4ResourceList(cost, 1) {
		return proto.LeagueResult_LeagueParamsError
	}
	result := cache.Instance_GlobalAssetLeague.CreateLeague(userdata, name, shortName, slogan, needreview, maxpower, minpower)
	if result == proto.LeagueResult_LeagueSuccess {

		userdata.ReduceVec4ResourceList(cost, 1, oss.ReduceCashSrcTypeCreateLeague)
		leagueid := userdata.GetLeagueID()
		wdata := cache.Instance_GlobalAssetWorldData.GetWorldData(userdata.GetWorldDataId())
		if wdata != nil {
			wdata.UpdateOwner(leagueid, userdata.GetUid())
		}
		status := &proto.ST_LeagueStatusEntry_PB{
			Type:     proto.SetUint32(uint32(proto.LeagueStausType_LST_CREATE_LEAGUE)),
			Time:     proto.SetUint64(wtime.GetNow()),
			PlayerID: proto.SetUint64(ownerID),
		}
		cache.Instance_GlobalAssetLeague.AddLeagueStatus(leagueid, status)
		//>>>用户创建联盟
		observer.ObserverSingleton.AsyncNotify(observer.UserCreateLeagueEvent, []interface{}{userdata})
		rpcClient.ChangeLeagueName("", "", name, shortName)

		TrySetLeagueTaskRefreshTimestamp(ownerID)

		userdata.AddFirstTutorialTimes(uint32(proto.FirstTutorialType_FTT_CREATE_LEAGUE))
		userdata.ReadLeagueBattleLog()
	}
	return result
}

func lc_LeaguepermissionUp(uid, targetid, lid uint64, leagueMemberLevel int32) (int32, proto.LeagueResult) {
	if int32(proto.LeagueMemberLevel_LeagueMemberLevel4) < leagueMemberLevel {
		return 0, proto.LeagueResult_LeagueParamsError
	}
	ret, userData, _ := CheckRight(uid, LEAGUERIGHT_PermissionUp)
	if ret != proto.LeagueResult_LeagueSuccess {
		return 0, ret
	}
	if targetData := cache.GetCharinfo(targetid); targetData == nil {
		return 0, proto.LeagueResult_LeagueParamsError
	}

	level := cache.Instance_GlobalAssetLeague.GetMemberLevel(userData.GetLeagueID(), uid)
	if level <= leagueMemberLevel {
		return 0, proto.LeagueResult_LeaguePermissionDeny
	}

	oldLevel := cache.Instance_GlobalAssetLeague.GetMemberLevel(userData.GetLeagueID(), targetid)
	ret = cache.Instance_GlobalAssetLeague.SetMemberLevel(lid, targetid, leagueMemberLevel)
	if ret != proto.LeagueResult_LeagueSuccess {
		return 0, ret
	}
	status := &proto.ST_LeagueStatusEntry_PB{
		Type:        proto.SetUint32(uint32(proto.LeagueStausType_LST_PLAYER_LEVEL_CHANGED)),
		Time:        proto.SetUint64(wtime.GetNow()),
		PlayerID:    proto.SetUint64(targetid),
		OldLevel:    proto.SetUint32(uint32(leagueMemberLevel)),
		ManagerName: proto.SetString(userData.GetUserName()),
		ManagerID:   proto.SetUint64(uid),
	}

	cache.Instance_GlobalAssetLeague.AddLeagueStatus(lid, status)
	notifyLeagueDataToMembers(userData.GetLeagueID())

	processOssLeagueMemberManage(lid, uid, targetid, "changelevel")

	var nameID uint32
	if tmpPtr := csv.Mgr.CSV_LeagueRight.GetEntryPtr(int64(leagueMemberLevel + 1)); tmpPtr != nil {
		nameID = common.StringToUint32(tmpPtr.Name)
	}
	targetUserData := cache.GetCharinfo(targetid)
	if oldLevel < leagueMemberLevel {
		targetUserData.AddTips(11000199, userData.GetUserName(), nameID)
		observer.ObserverSingleton.AsyncNotify(observer.LeaguePermissionUp, []interface{}{targetUserData, leagueMemberLevel})
	} else {
		targetUserData.AddTips(11000200, userData.GetUserName(), nameID)
		observer.ObserverSingleton.AsyncNotify(observer.LeaguePermissionDown, []interface{}{targetUserData, leagueMemberLevel})
	}

	return oldLevel, ret
}
func ExitLeague(uid uint64) proto.LeagueResult {
	ret, userData, leagueData := CheckRight(uid, LEAGUERIGHT_QuitLeague)
	if ret != proto.LeagueResult_LeagueSuccess {
		return ret
	}

	lid := userData.GetLeagueID()

	fDel := func() {
		num := len(cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(userData.GetLeagueID()))
		GetMacMgrInstance().PlayerQuitLeague(lid, uid, uint32(num))
	}

	if userData.GetSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}

	if userData.IsLeagueLeader() {
		if len(cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(userData.GetLeagueID())) > 1 {
			return proto.LeagueResult_LeagueParamsError
		} else {
			if cache.Instance_GlobalWarCityAsset.UserHasWarCityData(uid) {
				return proto.LeagueResult_LeagueIsWarCity
			}
			lName := cache.Instance_GlobalAssetLeague.GetLeagueName(userData.GetLeagueID())
			sName := cache.Instance_GlobalAssetLeague.GetLeagueShortName(userData.GetLeagueID())
			// 数据上报
			processCityOwnerDeleteLeague(leagueData)
			processMiracleWarDeleteLeague(userData.GetLeagueID())

			for _, did := range cache.Instance_GlobalAssetLeague.GetLeagueBuilding(userData.GetLeagueID()) {
				DelLeagueBuilding2(did)
			}
			go cache.Chat_Netease("https://api.netease.im/nimserver/team/remove.action",
				"tname=myteam&owner=league"+common.ConvertToString(lid/100)+"&tid="+cache.Instance_GlobalAssetLeague.GetChatChannelId(leagueData.GetLeagueIDUnSafe()))
			cache.Instance_GlobalAssetLeague.DeleteLeague(userData.GetLeagueID())
			processGlobalActionExitLeague(userData)
			processTechnologyExitLeague(userData)
			processLeagueHelpExitLeague(userData)
			processLeagueBoxExitLeague(userData)
			userData.ResetLeagueInfo()
			userData.ResetLeagueExtraInfo()
			loginProcessTransferBattle(userData)
			rpcClient.DeleteLeagueName(lName, sName)
		}
	} else {
		fDel()
		return lc_removeUserFromLeague(0, uid, userData.GetLeagueID(), false)
	}
	fDel()
	return proto.LeagueResult_LeagueSuccess
}
func processCityOwnerDeleteLeague(leagueData *cache.GlobalLeagueEntry) {
	for _, v := range leagueData.GetCityIds() {
		wdata := cache.GetCityWorldData(v)
		if wdata == nil {
			continue
		}
		wdata.UpdateOwner(0, 0)
	}
}
func processTechnologyExitLeague(userData *cache.Info) {
	if nil == userData {
		return
	}
	userData.ResetAttributeByType(proto.AttributeSource_League) //ok
	userData.ResetAttributeByType(proto.AttributeSource_City)
}

func processLeagueHelpExitLeague(userData *cache.Info) {
	withLeagueAndLocalActionLockForeach(userData, false, func(entry *proto.ST_LocalActionEntry_PB) bool {
		if entry.GetIsHelped() {
			cache.Instance_GlobalAssetLeague.UnsafeDeleteLeagueHelp(userData.GetLeagueID(), userData.GetUid(), entry.GetActionid())
			notifyHelpToMembers(userData.GetLeagueID(), userData.GetUid(), entry.GetActionid(), false)
		}
		return true
	})
}
func processMiracleWarDeleteLeague(lid uint64) {
	cache.Instance_GlobalMiracleWarAsset.WithMiracleWarAsset(false, 7305001, func(asset *proto.ST_MiracleWar_PB) bool {
		miracleWarStage := asset.GetStage()
		if miracleWarStage == int32(proto.MiracleWarStage_MWS_FightStage) ||
			miracleWarStage == int32(proto.MiracleWarStage_MWS_UnOpenStage) ||
			miracleWarStage == int32(proto.MiracleWarStage_MWS_WaitStage) ||
			miracleWarStage == int32(proto.MiracleWarStage_MWS_PrepareStage) {
			return false
		}

		if asset.GetOwnerLeagueID() == lid && asset.GetOwnerUid() == 0 {
			return unsafeSetArchon(asset)
		}

		return false
	})
}

func lc_removeUserFromLeague(uid, targetid, lid uint64, iskick bool) proto.LeagueResult {
	targetUserData := cache.GetCharinfo(targetid)
	if targetUserData == nil {
		return proto.LeagueResult_LeagueParamsError
	}

	userData := cache.GetCharinfo(uid)
	if iskick {
		if userData == nil {
			return proto.LeagueResult_LeagueParamsError
		}
	}
	if cache.Instance_GlobalWarCityAsset.UserHasWarCityData(targetid) {
		return proto.LeagueResult_LeagueIsWarCity
	}

	var success bool = false

	if cache.Instance_GlobalAssetLeague.DeleteMember(lid, targetid) {
		cache.Instance_GlobalAssetLeague.DeleteLeaueDovoteRank(lid, targetid)
		wdata := cache.Instance_GlobalAssetWorldData.GetWorldData(targetUserData.GetWorldDataId())
		if wdata != nil {
			wdata.UpdateOwner(0, targetUserData.GetUid())
		}
		processGlobalActionExitLeague(targetUserData)
		processTechnologyExitLeague(targetUserData)
		processLeagueHelpExitLeague(targetUserData)
		processLeagueBoxExitLeague(targetUserData)
		targetUserData.ResetLeagueInfo()
		targetUserData.ResetLeagueExtraInfo()
		loginProcessTransferBattle(targetUserData)
		for _, did := range cache.Instance_GlobalAssetLeague.GetLeagueBuilding(lid) {
			d := cache.Instance_GlobalAssetWorldData.GetWorldData(did)
			if d != nil {
				csvConfig := d.GetWorldEntryConfig()
				if csvConfig != nil && csvConfig.EntryType == int64(proto.WorldEntryType_WET_LEAGUE_Cashhouse) {
					res := d.GetWorldData().SimpleEntry.GetRes()
					if res != nil {
						for _, v := range res.List {
							if targetid == v.GetUid() {
								targetUserData.AddCashAsset(v.GetResource(), oss.ReduceWORLDMAP_IN)
								v.Resource = common.NewCashAsset()
							}
						}
						d.Dirty()
					}
				}
			}
		}

		success = true
	}

	if success {
		var statusType uint32
		if iskick {
			targetUserData.AddTips(11000201, userData.GetUserName())
			statusType = uint32(proto.LeagueStausType_LST_PLAYER_KICK_OUT)
		} else {
			statusType = uint32(proto.LeagueStausType_LST_PLAYER_QUIT)
		}
		status := &proto.ST_LeagueStatusEntry_PB{
			Type:     proto.SetUint32(statusType),
			Time:     proto.SetUint64(wtime.GetNow()),
			PlayerID: proto.SetUint64(targetid),
			OldLevel: proto.SetUint32(0),
		}
		if iskick {
			status.ManagerID = proto.SetUint64(uid)
			status.ManagerName = proto.SetString(userData.GetUserName())

			title := common.CreateTips(90000082)
			content := common.CreateTips(90000083, userData.GetUserName(), cache.Instance_GlobalAssetLeague.GetLeagueName(lid))
			targetUserData.AddLanguageIDMailAsset(uint32(proto.MailType_MT_SYSTEM), 0, -1, int32(proto.MailSourceType_MST_League), title, content, "", "")
		}
		cache.Instance_GlobalAssetLeague.AddLeagueStatus(lid, status)

		observer.ObserverSingleton.AsyncNotify(observer.ExitLeagueEvent, []interface{}{targetUserData, lid})

		// 数据上报
		processOssLeagueMemberManage(lid, targetid, 0, "exit")
		return proto.LeagueResult_LeagueSuccess
	}
	return proto.LeagueResult_LeagueIsNotMember
}

func lc_LeagueKickOut(uid, targetid, lid uint64) proto.LeagueResult {
	ret, _, lAsset := CheckRight(uid, LEAGUERIGHT_DriveOut)
	if ret != proto.LeagueResult_LeagueSuccess {
		return ret
	}
	if lAsset == nil || lAsset.GetLeagueSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}
	ret = lc_removeUserFromLeague(uid, targetid, lid, true)
	if ret == proto.LeagueResult_LeagueSuccess {
		processOssLeagueMemberManage(lid, uid, targetid, "kickout")
	}
	return ret
}
func lc_Abdicate(uid, targetID, leagueid uint64) proto.LeagueResult {
	ret, userData, leagueAsset := CheckRight(uid, LEAGUERIGHT_Transfer)
	if ret != proto.LeagueResult_LeagueSuccess {
		return ret
	}

	tbAsset := cache.Instance_GlobalTransferBattle.GetTransferBattleInfo()
	if tbAsset != nil && tbAsset.GetStage() == uint32(proto.ActivityStage_AS_ProcessingStage) {
		return proto.LeagueResult_LeagueTransferBattle
	}

	if leagueAsset == nil || leagueAsset.GetLeagueSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}

	var (
		abdicate bool = false
		//o_level  uint32
	)
	targetUserData := cache.GetCharinfo(targetID)
	if targetUserData == nil {
		return proto.LeagueResult_LeagueParamsError
	}

	for _, v := range cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(leagueid) {
		if v == targetID {
			leagueAsset.SetOwnerUid(targetID)
			leagueAsset.SetOwnerName(targetUserData.GetUserName())
			//o_level = uint32(cache.Instance_GlobalAssetLeague.GetMemberLevel(leagueid, v))
			cache.Instance_GlobalAssetLeague.SetMemberLevel(leagueid, uid, int32(proto.LeagueMemberLevel_LeagueMemberLevel0))
			cache.Instance_GlobalAssetLeague.SetMemberLevel(leagueid, v, int32(proto.LeagueMemberLevel_LeagueMemberLevel5))
			abdicate = true
			break
		}
	}
	if abdicate {
		status := &proto.ST_LeagueStatusEntry_PB{
			Type:        proto.SetUint32(uint32(proto.LeagueStausType_LST_PLAYER_LEVEL_CHANGED)),
			Time:        proto.SetUint64(wtime.GetNow()),
			PlayerID:    proto.SetUint64(targetID),
			OldLevel:    proto.SetUint32(uint32(proto.LeagueMemberLevel_LeagueMemberLevel5)),
			ManagerName: proto.SetString(userData.GetUserName()),
			ManagerID:   proto.SetUint64(userData.GetUid()),
		}
		cache.Instance_GlobalAssetLeague.AddLeagueStatus(leagueid, status)
		userData.SetLeagueInfo(leagueid)
		targetUserData.SetLeagueInfo(leagueid)

		title := common.CreateTips(90000084)
		content := common.CreateTips(90000085, userData.GetUserName(), targetUserData.GetUserName(), userData.GetUserName())
		sendLanguageIDMailToMembers(userData.GetLeagueID(), uint32(proto.MailType_MT_SYSTEM), title, content)

	}
	return proto.LeagueResult_LeagueSuccess
}

// 罢免
func lc_recallLeagueOwner(uid, targetID, leagueId uint64) proto.LeagueResult {
	targetUserData := cache.GetCharinfo(targetID)
	userData := cache.GetCharinfo(uid)
	if targetUserData == nil || userData == nil {
		return proto.LeagueResult_LeagueParamsError
	}

	tbAsset := cache.Instance_GlobalTransferBattle.GetTransferBattleInfo()
	if tbAsset != nil && tbAsset.GetStage() == uint32(proto.ActivityStage_AS_ProcessingStage) {
		return proto.LeagueResult_LeagueTransferBattle
	}

	leagueAsset := cache.Instance_GlobalAssetLeague.GetLeagueData(leagueId)
	if nil == leagueAsset || leagueAsset.GetLeagueSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}

	if cache.Instance_GlobalAssetLeague.GetOwnerUid(leagueId) != targetID {
		return proto.LeagueResult_LeagueParamsError
	}

	if userData.GetLeagueID() != targetUserData.GetLeagueID() {
		return proto.LeagueResult_LeagueParamsError
	}

	lastRefreshTime := cache.Instance_GlobalAssetLeague.GetMemberLastRefreshTimestamp(leagueId, targetID)
	if lastRefreshTime == 0 || wtime.GetNow() < lastRefreshTime+uint64(csv.GetGameConfigValueUint32("LeaderOfflineDays")*86400) {
		//userData.AddTips(10000333, csv.GetGameConfigValueUint32("LeaderOfflineDays"))
		return proto.LeagueResult_LeagueParamsError
	}

	if !userData.CheckMoney(uint64(csv.GetGameConfigValueUint32("RemoveLeadercost"))) {
		return proto.LeagueResult_LeagueParamsError
	}

	recall := false
	for _, v := range cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(leagueId) {
		if v == uid {
			leagueAsset.SetOwnerUid(uid)
			leagueAsset.SetOwnerName(userData.GetUserName())
			//o_level = uint32(cache.Instance_GlobalAssetLeague.GetMemberLevel(leagueId, v))
			cache.Instance_GlobalAssetLeague.SetMemberLevel(leagueId, targetID, int32(proto.LeagueMemberLevel_LeagueMemberLevel0))
			cache.Instance_GlobalAssetLeague.SetMemberLevel(leagueId, v, int32(proto.LeagueMemberLevel_LeagueMemberLevel5))
			recall = true
			break
		}
	}

	if recall {
		userData.SetLeagueInfo(leagueId)
		targetUserData.SetLeagueInfo(leagueId)
		userData.ReduceMoney(uint64(csv.GetGameConfigValueUint32("RemoveLeadercost")), oss.ReduceCashSrcTypeRecallLeagueOnwer)

		title := common.CreateTips(10000331)
		content := common.CreateTips(10000334, targetUserData.GetUserName(), csv.GetGameConfigValueUint32("LeaderOfflineDays"), userData.GetUserName())
		sendLanguageIDMailToMembers(userData.GetLeagueID(), uint32(proto.MailType_MT_SYSTEM), title, content)

		status := &proto.ST_LeagueStatusEntry_PB{
			Type:        proto.SetUint32(uint32(proto.LeagueStausType_LST_OWNER_RECALL)),
			Time:        proto.SetUint64(wtime.GetNow()),
			PlayerID:    proto.SetUint64(targetID),
			OldLevel:    proto.SetUint32(uint32(proto.LeagueMemberLevel_LeagueMemberLevel0)),
			ManagerName: proto.SetString(userData.GetUserName()),
			ManagerID:   proto.SetUint64(uid),
		}
		cache.Instance_GlobalAssetLeague.AddLeagueStatus(leagueId, status)

		///数据上报
		processOssLeagueMemberManage(leagueId, uid, targetID, "dismiss_leader")
	}

	return proto.LeagueResult_LeagueSuccess
}

func LeaguePermission(uid, targetId, leagueId uint64, operator, leagueMemberLevel int32, res *httputils.Respon) proto.LeagueResult {
	var result proto.LeagueResult
	switch proto.LeaguePermissionOperator(operator) {
	case proto.LeaguePermissionOperator_PromissionUp:
		{
			oldLevel, ret := lc_LeaguepermissionUp(uid, targetId, leagueId, leagueMemberLevel)
			res.Add("oldlevel", oldLevel)
			res.Add("newlevel", leagueMemberLevel)
			result = ret
		}
	case proto.LeaguePermissionOperator_Abdicate:
		result = lc_Abdicate(uid, targetId, leagueId)
	case proto.LeaguePermissionOperator_KickOut:
		result = lc_LeagueKickOut(uid, targetId, leagueId)
	case proto.LeaguePermissionOperator_RecallLeagueOnwer:
		result = lc_recallLeagueOwner(uid, targetId, leagueId)
	default:
		result = proto.LeagueResult_LeagueParamsError
	}
	return result
}
func InvitationUsersJoinLeague(uid uint64, targetUidList *proto.ST_Uint64List_PB) (*proto.ST_Int64List_PB, *proto.ST_Int64List_PB) {
	retKey := &proto.ST_Int64List_PB{}
	retValue := &proto.ST_Int64List_PB{}
	for _, id := range targetUidList.List {
		result := InvitationJoinLeague(uid, id)
		if proto.LeagueResult_LeagueSuccess != result {
			retKey.List = append(retKey.List, int64(id))
			retValue.List = append(retValue.List, int64(result))
		}
	}
	return retKey, retValue
}
func InvitationJoinLeague(uid, targetuid uint64) proto.LeagueResult {
	targetUserData := cache.GetCharinfo(targetuid)
	if targetUserData == nil {
		return proto.LeagueResult_LeagueParamsError
	}
	ret, userData, leagueAsset := CheckRight(uid, LEAGUERIGHT_Invitation)
	if ret != proto.LeagueResult_LeagueSuccess {
		return ret
	}
	if leagueAsset == nil || leagueAsset.GetLeagueSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}
	if targetUserData.GetLeagueID() != 0 {
		return proto.LeagueResult_LeagueJoined
	}
	leagueid := userData.GetLeagueID()
	if leagueAsset.HasMember(targetuid) {
		return proto.LeagueResult_LeagueParamsError
	}
	simpleInfo := cache.Instance_GlobalAssetLeague.CopyLeagueSimpleInfo(leagueid)

	//盟主邀请目标，无需检测入盟条件
	memberLevel := cache.Instance_GlobalAssetLeague.GetMemberLevel(userData.GetLeagueID(), uid)
	if memberLevel != 5 {
		power := targetUserData.GetPower()
		if simpleInfo.GetMinPower() != 0 && power < simpleInfo.GetMinPower() {
			return proto.LeagueResult_LeagueIsNotMember
		}
		if simpleInfo.GetMainCityLevel() != 0 && uint64(targetUserData.GetMainCityLevel()) < simpleInfo.GetMainCityLevel() {
			return proto.LeagueResult_LeagueIsNotMember
		}
	}

	pb := &proto.ST_InvitationLeague_Info{
		LeagueID:   proto.SetUint64(leagueid),
		LeagueName: proto.SetString(simpleInfo.GetName()),
		InviterUID: proto.SetUint64(uid),
	}
	//Tips提示
	targetUserData.AddLeagueInvatation(pb)
	//发送邀请邮件
	title := common.CreateTips(90000071)
	content := common.CreateTips(90000072, simpleInfo.GetName())
	mailPB := &proto.ST_LeagueInvitationJoinMail_PB{LeagueId: proto.SetUint64(leagueid), AcceptedOrRejected: proto.SetUint32(0)}
	detail := string(proto.Marshal(mailPB))
	targetUserData.AddLanguageIDMailAsset(uint32(proto.MailType_MT_LEAGUE_INVITATION), uid, 0, int32(proto.MailSourceType_MST_Default), title, content, detail, "")
	processOssLeagueMemberManage(userData.GetLeagueID(), uid, targetuid, "invite")
	return proto.LeagueResult_LeagueSuccess
}

func SystemRecommendLeague(userData *cache.Info) {
	if nil == userData {
		return
	}

	if userData.GetLeagueID() != 0 {
		return
	}

	mainCityLevel := userData.GetMainCityLevel()
	if mainCityLevel < 6 {
		return
	}

	userLanguage := userData.GetLanguage()
	tmpIds := cache.Instance_GlobalAssetLeague.GetSystemRecommendListByLanguageID(userLanguage)
	count := len(tmpIds)
	if count > 0 {
		userData.SetRecommendLeague(tmpIds[int(common.GetRandomNum(int32(count)))])
	}
}

func AcceptLeagueInvitation(uid, leagueid uint64) proto.LeagueResult {
	userData := cache.GetCharinfo(uid)
	if userData == nil {
		return proto.LeagueResult_LeagueParamsError
	}
	if userData.GetSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError
	}
	if userData.GetLeagueID() != 0 {
		return proto.LeagueResult_LeagueParamsError
	}
	if cache.Instance_GlobalAssetLeague.GetLeagueData(leagueid) == nil {
		return proto.LeagueResult_LeagueParamsError
	}

	if userData.GetJoinLeagueCDTime() > wtime.GetNow() {
		userData.AddTips(11000410, common.TimeFormatString(userData.GetJoinLeagueCDTime()-wtime.GetNow()))
		return proto.LeagueResult_LeagueParamsError
	}

	return lc_joinLeague(userData, leagueid)
}

func RecommendUser(uid uint64) (proto.LeagueResult, *proto.ST_RecommendUserAsset_PB) {
	recommend := &proto.ST_RecommendUserAsset_PB{}
	userData := cache.GetCharinfo(uid)
	if userData == nil {
		return proto.LeagueResult_LeagueParamsError, recommend
	}
	if userData.GetLeagueID() == 0 {
		return proto.LeagueResult_LeagueParamsError, recommend
	}
	leagueId := userData.GetLeagueID()
	leagueData := cache.Instance_GlobalAssetLeague.GetLeagueData(leagueId)
	if leagueData == nil || leagueData.GetLeagueSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		return proto.LeagueResult_LeagueParamsError, recommend
	}
	var num uint32 = 0
	for _, v := range cache.UserIDPowerRankingList.GetRankingList() {
		tmpUserData := cache.GetCharinfo(v.Key)
		if tmpUserData == nil {
			continue
		}
		if tmpUserData.GetLeagueID() != 0 {
			continue
		}
		if tmpUserData.GetLanguage() != userData.GetLanguage() {
			continue
		}
		//过滤掉已在联盟中的成员
		if leagueData.HasMember(v.Key) {
			continue
		}
		recommend.UserList = append(recommend.UserList, v.Key)
		num++
		if num > 50 {
			break
		}
	}
	return proto.LeagueResult_LeagueSuccess, recommend
}

func CheckLeague(name, shortname string) uint32 {
	if name != "" {
		if !cache.Instance_GlobalAssetLeague.CheckNameNotExist(name) {
			return 2
		}
		return 1
	}
	if shortname != "" {
		if !cache.Instance_GlobalAssetLeague.CheckAbbrevitionNotExist(shortname) {
			return 4
		}
		return 3
	}
	return 0
}
func notifyLeagueMessageToMemebers(lid uint64) {
	leagueSimple := cache.Instance_GlobalAssetLeague.CopyLeagueSimpleInfo(lid)
	if leagueSimple == nil {
		return
	}
	messageLen := len(leagueSimple.GetMessageList())
	for _, v := range cache.Instance_GlobalAssetLeague.GetLeagueMemberIds(lid) {
		tmpUserData := cache.GetCharinfo(v)
		if tmpUserData == nil {
			continue
		}
		var num uint32 = 0
		lastTime := tmpUserData.GetLastTimeLeagueMessage()
		for i := messageLen - 1; i >= 0; i-- {
			if i < 0 {
				break
			}
			tmpData := leagueSimple.MessageList[i]
			if tmpData.GetSendTime() > lastTime {
				num++
			} else {
				break
			}
		}
		tmpUserData.SetUnreadMessageCount(num)
	}
}
func LeagueMessage(uid, leagueid uint64, message string) proto.LeagueResult {
	userData := cache.GetCharinfo(uid)
	if userData == nil {
		return proto.LeagueResult_LeagueParamsError
	}
	leagueAsset := cache.Instance_GlobalAssetLeague.GetLeagueData(leagueid)
	if leagueAsset == nil {
		return proto.LeagueResult_LeagueIsNotExist
	}
	msg := &proto.ST_LeagueMessageEntry_PB{
		SenderUID: proto.SetUint64(uid),
		SendTime:  proto.SetUint64(wtime.GetNow()),
		Message:   proto.SetString(message),
	}
	leagueAsset.AddLeagueMessage(msg)
	notifyLeagueMessageToMemebers(leagueid)
	newOssChat(userData, 5, 0, "", message)
	return proto.LeagueResult_LeagueSuccess
}

/**
@brief 获取联盟简单信息列表
*/
func GetLeagueSimpleInfoList(idList []uint64) (*proto.ST_League_Simple_Info_List, proto.LeagueResult) {
	simpleInfoList := &proto.ST_League_Simple_Info_List{}
	for _, id := range idList {
		if v := cache.Instance_GlobalAssetLeague.CopyLeagueSimpleInfo(id); v != nil {
			v.MessageList = make([]*proto.ST_LeagueMessageEntry_PB, 0)
			simpleInfoList.SimpleInfoList = append(simpleInfoList.SimpleInfoList, v)
		}
	}
	return simpleInfoList, proto.LeagueResult_LeagueSuccess
}

func checkResource(cash *proto.ST_CashAsset_PB) (uint32, uint64) {
	if cash.GetCash1() > 0 {
		return 1, cash.GetCash1()
	} else if cash.GetCash2() > 0 {
		return 2, cash.GetCash2()
	} else if cash.GetCash3() > 0 {
		return 3, cash.GetCash3()
	} else if cash.GetCash4() > 0 {
		return 4, cash.GetCash4()
	} else if cash.GetCash5() > 0 {
		return 5, cash.GetCash5()
	} else {
		return 100, cash.GetCash100()
	}
}

func GetLeagueBusinessHistory(uid uint64, hType, hStart, hLimit uint32, res *httputils.Respon) {
	if 0 == uid || 0 == hType || 0 == hLimit {
		res.Add("status", proto.RetActionType_RAT_INPUT_ERROR)
		return
	}
	userData := cache.GetCharinfo(uid)
	if nil == userData || 0 == userData.GetLeagueID() || (1 != hType && 2 != hType) {
		res.Add("status", proto.RetActionType_RAT_INPUT_ERROR)
		return
	}
	var list *proto.ST_LeagueShopRecordList_PB = nil
	if 1 == hType {
		list = cache.GlobalLeagueBusinessHistoryAsset.AssetData_IncomeHistory.Get(userData.GetLeagueID(), hStart, hLimit)
	} else if 2 == hType {
		list = cache.GlobalLeagueBusinessHistoryAsset.AssetData_OutcomeHistory.Get(userData.GetLeagueID(), hStart, hLimit)
	}
	if nil == list {
		res.Add("status", proto.RetActionType_RAT_INPUT_ERROR)
		return
	}
	res.Add("record", list)
	res.Add("status", proto.RetActionType_RAT_SUCCESS)
}

/**
@brief 接受或拒绝联盟邀请
*/
func AcceptOrRejectLeagueInvitation(uid, mailId uint64, acceptOrReject uint32, res *httputils.Respon) {
	ret := proto.RetActionType_RAT_SUCCESS
	defer func() { res.Add("status", ret) }()

	userData := cache.GetCharinfo(uid)
	if nil == userData || 0 != userData.GetLeagueID() {
		ret = proto.RetActionType_RAT_INPUT_ERROR
		return
	}

	if userData.GetSid() != JsonConfig.GlobalConfig.Basic.ServerID {
		ret = proto.RetActionType_RAT_INPUT_ERROR
		return
	}

	leagueId := uint64(0)
	userData.GetMailData(mailId, func(asset *proto.ST_MailData_PB) {
		if nil == asset || nil == asset.Basic ||
			asset.Basic.GetMailtype() != uint32(proto.MailType_MT_LEAGUE_INVITATION) ||
			nil == asset.LeagueInvitationJoinMail {
			ret = proto.RetActionType_RAT_INPUT_ERROR
			return
		}
		leagueId = asset.GetLeagueInvitationJoinMail().GetLeagueId()
	})

	if 0 == acceptOrReject {
		if !userData.IsLeagueRejected(leagueId) {
			userData.RejectLeague(leagueId)
		}
	} else {
		if userData.GetJoinLeagueCDTime() > wtime.GetNow() {
			userData.AddTips(11000410, common.TimeFormatString(userData.GetJoinLeagueCDTime()-wtime.GetNow()))
			ret = proto.RetActionType_RAT_INPUT_ERROR
			return
		}

		if proto.LeagueResult_LeagueSuccess != lc_joinLeague(userData, leagueId) {
			ret = proto.RetActionType_RAT_INTERNAL_ERROR
			return
		}
	}

	if proto.RetActionType_RAT_SUCCESS == ret {
		userData.AcceptOrRejectInvitationMail(mailId, 0 != acceptOrReject)
	}
}

func ReadLeagueMessage(uid uint64) {
	userDate := cache.GetCharinfo(uid)
	if nil == userDate || userDate.GetLeagueID() == 0 {
		return
	}
	userDate.SetUnreadMessageCount(0)
	userDate.SetReadLeagueMessage()
}

func DeleteLeagueMessage(uid, senderUid, msgTime uint64) proto.RetActionType {
	ret, _, leagueAsset := CheckRight(uid, LEAGUERIGHT_DeleteMessage)
	if ret != proto.LeagueResult_LeagueSuccess {
		return proto.RetActionType_RAT_INPUT_ERROR
	}

	if !leagueAsset.DeleteLeagueMessage(senderUid, msgTime) {
		return proto.RetActionType_RAT_INPUT_ERROR
	}

	return proto.RetActionType_RAT_SUCCESS
}

func SetRecommendLeagueTech(uid uint64, oldTechId, newTechId uint32) proto.RetActionType {
	userData := cache.GetCharinfo(uid)
	if nil == userData {
		return proto.RetActionType_RAT_INPUT_ERROR
	}

	lid := userData.GetLeagueID()
	if lid == 0 || cache.Instance_GlobalAssetLeague.GetOwnerUid(lid) != uid {
		return proto.RetActionType_RAT_INPUT_ERROR
	}

	if !cache.Instance_GlobalAssetLeague.SetRecommendLeagueTech(lid, oldTechId, newTechId) {
		return proto.RetActionType_RAT_INPUT_ERROR
	}

	return proto.RetActionType_RAT_SUCCESS
}

func GetLeagueDevoteRank(uid uint64) (proto.RetActionType, *proto.ST_LeagueDonationRank_PB) {
	userData := cache.GetCharinfo(uid)
	if userData == nil || userData.GetLeagueID() == 0 {
		return proto.RetActionType_RAT_INPUT_ERROR, nil
	}

	leagueData := cache.Instance_GlobalAssetLeague.CopyLeagueAsset(userData.GetLeagueID())
	if leagueData == nil {
		return proto.RetActionType_RAT_INPUT_ERROR, nil
	}

	return proto.RetActionType_RAT_SUCCESS, leagueData.DevoteRank
}

func GetLeagueBattleLog(uid uint64, startid, count uint32) (proto.RetActionType, *proto.ST_LeagueBattle_Log) {
	userData := cache.GetCharinfo(uid)
	if nil == userData || userData.GetLeagueID() == 0 {
		return proto.RetActionType_RAT_INTERNAL_ERROR, nil
	}

	battleLog := &proto.ST_LeagueBattle_Log{}
	logs, _ := cache.InstanceGlobalAssetLeagueBattleLog.GetLeagueBattleLogList(userData.GetLeagueID(), int32(startid), int32(count))
	battleLog.Logs = logs
	return proto.RetActionType_RAT_SUCCESS, battleLog
}

func ReadLeagueBattleLog(uid uint64) {
	userData := cache.GetCharinfo(uid)
	if nil == userData {
		return
	}

	userData.ReadLeagueBattleLog()
}