#!/usr/bin/python
# -*- coding: GBK -*-
#
##@package E:/GameSVN/U3DGame/ProjectSServer/ServerPython/CoreServerGroup/GameServer/Script/Player/PlayerFriend.py
# @todo: 
#
# @author: Alee
# @date 2017-8-28 ÏÂÎç10:28:54
# @version 1.0
#
# @note:
#
#---------------------------------------------------------------------
#"""Version =  2017-8-28 21:00"""
#---------------------------------------------------------------------
import IPY_GameServer
import GameWorld
import ChConfig
import PlayerRequest
import PlayerControl
import ChPyNetSendPack
import NetPackCommon
import ShareDefine
import PyDataManager
import IpyGameDataPY
import random
import PlayerSocial
import copy
import PlayerViewCache
import PlayerTeam
import json

#---------------------------------------------------------------------


############################################################
#·â°ü

#===============================================================================
# //B3 01 Ìí¼ÓºÃÓÑ#tagCGAddFriend
# 
# struct    tagCGAddFriend
# {
#    tagHead        Head;
#    char        TagName[33];        //Íæ¼ÒÃû³Æ
#    DWORD        TagID;        //Íæ¼ÒID
# };
#===============================================================================
## Ìí¼ÓºÃÓÑ
def AddFriend(index, clientData, tick):
    #»ñÈ¡Íæ¼Ò
    playerManager = GameWorld.GetPlayerManager()
    curPlayer = playerManager.GetPlayerByIndex(index)
    curTagPlayerID = clientData.TagID

    limitLV = GetFuncLimitLV(ShareDefine.GameFuncID_Friend)
    if curPlayer.GetLV() < limitLV:
        PlayerControl.NotifyCode(curPlayer, 'LvErr')
        return
    
    if not CheckFriendCount(curPlayer, True, curPlayer.GetID()):
        #ºÃÓÑÒѾ­ÂúÁË
        GameWorld.DebugLog("ºÃÓÑÒѾ­ÂúÁË")
        return
    
    #»ñÈ¡Ä¿±êÍæ¼Ò
    tagPlayer = None
    tagLV = 0
    if clientData.TagID != 0:
        tagPlayer = playerManager.FindPlayerByID(curTagPlayerID)
    else:
        tagPlayer = playerManager.FindPlayerByName(clientData.TagName)
        #Ãû³Æ¼ÓºÃÓѲ»Ö§³ÖÀëÏß
        if tagPlayer == None:
            #XW_SJ_AimOffline Íæ¼ÒÒÑÏÂÏß
            PlayerControl.NotifyCode(curPlayer, 'Friend_OffLine')
            return
    
    if not tagPlayer:
        curCache = PlayerViewCache.ViewCacheMgr.FindCache(curTagPlayerID)
        if not curCache:
            #Íæ¼ÒµÄÊý¾ÝûÓлº´æ¹ý
            PlayerControl.NotifyCode(curPlayer, 'Friend_OffLine')
            return
        cacheDict = json.loads(curCache.GetPropData())
        tagLV = cacheDict["LV"]
    else:
        tagLV = tagPlayer.GetLV()
    
    if tagLV < limitLV:
        PlayerControl.NotifyCode(curPlayer, 'Friend_OtherLessLv')
        return
    
    curPlayerID = curPlayer.GetID()
    
    if curPlayerID == curTagPlayerID:
        #²»ÔÊÐíÌí¼Ó×Ô¼º
        GameWorld.DebugLog("²»ÔÊÐíÌí¼Ó×Ô¼º")
        return
    
    # ºÚÃûµ¥¼ì²é
    if PyDataManager.GetBlacklistManager().CheckBlacklistBoth(curPlayerID, curTagPlayerID, curPlayer):
        GameWorld.DebugLog("ºÚÃûµ¥¼ì²é")
        return
    
    curPlayerFriendStruct = GetFriendStruct(curPlayerID)
    
    tagFriend = curPlayerFriendStruct.Find(curTagPlayerID)
    
    if tagFriend != None:
        #XW_SJ_Repeat:¶Ô²»Æð,xxxÒÑÊÇÄúµÄºÃÓÑ,Ìí¼ÓºÃÓÑʧ°Ü!</n> 
        PlayerControl.NotifyCode(curPlayer, "Friend_YetFriend")
        return
    
    # Òì³£¼ì²é
    __CheckAddFriend(curPlayer, curTagPlayerID)
    
    #µ±Ç°Íæ¼ÒÌí¼ÓÇëÇó
    #curPlayer.AddRequest(curTagPlayerID, IPY_GameServer.reqFriend, tick, ChConfig.Def_EventClearTime)
    PlayerRequest.PYAddRequest(curPlayer, curTagPlayerID, IPY_GameServer.reqFriend)

    #Óë¿Í»§¶ËÔ¼¶¨Ãû×Öºó¼ÓÍæ¼ÒÖ°ÒµºÍµÈ¼¶£¬¿Í»§¶Ë×ÔÐвð¿ª
    #tagPlayer.Frm_AddFriendAsk(curPlayerID, '|'.join([curPlayer.GetName(), str(curPlayer.GetJob()), str(curPlayer.GetLV())]))

    if tagPlayer:
        askFriendPack = ChPyNetSendPack.tagGCFriendAskIfJoin()
        askFriendPack.AskID = curPlayerID
        askFriendPack.Name = curPlayer.GetName()
        askFriendPack.LV = curPlayer.GetLV()
        askFriendPack.RealmLV = curPlayer.GetOfficialRank()
        
        NetPackCommon.SendFakePack(tagPlayer, askFriendPack) 

    #XW_SJ_ApplyFriend ºÃÓÑÇëÇó·¢Ëͳɹ¦
    PlayerControl.NotifyCode(curPlayer, 'Friend_ApplyFriend')
    return


#---------------------------------------------------------------------
##»ñÈ¡Íæ¼Ò½á¹¹Ìå
# @param curPlayer Íæ¼ÒʵÀý
# @return IPY_Friend ʵÀý
# @remarks 
def GetFriendStruct(playerID):
    curFriends = PyDataManager.GetFriendManager().GetFriends(playerID)
    
    if curFriends != None:
        return curFriends
    
    return PyDataManager.GetFriendManager().AddFriends(playerID)

def IsFriend(playerID, tagPlayerID):
    ## ÅжÏË«·½ÊÇ·ñºÃÓÑ
    curFriends = PyDataManager.GetFriendManager().GetFriends(playerID)
    if not curFriends:
        return False
    return curFriends.Find(tagPlayerID) != None

#---------------------------------------------------------------------
##ºÃÓѼì²é
# @param curPlayer ÉêÇëºÃÓѵÄÍæ¼Ò
# @param tagPlayer ½ÓÊÜÉêÇëºÃÓѵÄÍæ¼Ò
# @return None
# @remarks 
def __CheckAddFriend(curPlayer, curTagPlayerID):
    curPlayerID = curPlayer.GetID()
    #»ñÈ¡ÉêÇëºÃÓÑÍæ¼ÒÐÅÏ¢ 
    curPlayerFriendStruct = GetFriendStruct(curPlayerID)
    curPlayerHasThisFriend = curPlayerFriendStruct.Find(curTagPlayerID)
    #»ñÈ¡½ÓÊÜÉêÇëºÃÓѵÄÍæ¼ÒÐÅÏ¢
    tagPlayerFriendStruct = GetFriendStruct(curTagPlayerID)
    tagPlayerHasThisFriend = tagPlayerFriendStruct.Find(curPlayerID)
    
    if curPlayerHasThisFriend != None and tagPlayerHasThisFriend != None:
        # ͬʱÊǶԷ½ºÃÓÑ
        return

    if curPlayerHasThisFriend == None and tagPlayerHasThisFriend == None:
        # ͬʱ¶¼²»ÊǶԷ½ºÃÓÑ
        return

    #״̬Ò쳣ɾ³ýË«·½µÄ¹Øϵ
    GameWorld.ErrLog('AddFriend, (%s, %s)ºÃÓÑÒì³£, ɾ³ýË«·½ºÃÓѹØϵ' % (curPlayerID, curTagPlayerID))

    # Ö»ÓÐijһ·½ÊÇÁíÒ»·½ºÃÓÑ
    if curPlayerHasThisFriend != None:
        curPlayerFriendStruct.DelFriend(curTagPlayerID)

    if tagPlayerHasThisFriend != None:
        tagPlayerFriendStruct.DelFriend(curPlayerID)
    
    return

#===============================================================================
# //B3 02 ɾ³ýºÃÓÑ#tagCGDeleteFriend
# 
# struct    tagCGDeleteFriend
# {
#    tagHead        Head;
#    DWORD        FriendID;
# };
#===============================================================================
## ɾ³ýºÃÓÑ
def DeleteFriend(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    
    playerID = curPlayer.GetPlayerID()
    curFriends = PyDataManager.GetFriendManager().GetFriends(playerID)
    if curFriends == None:
        GameWorld.Log('DeleteFriend -> ·â°üÒì³£ ->ûÓкÃÓÑ',playerID)
        return
    
    friendID = clientData.FriendID
    curFriend = curFriends.Find(friendID)
    if curFriend == None:
        GameWorld.Log('DeleteFriend -> ·â°üÒì³£ ->ûÓÐÕâ¸öÍæ¼Ò', playerID)
        return
    
    #ÀëÏߺÃÓÑͬʱɾ³ý¼Ç¼
    PyDataManager.GetFriendManager().DelFriendBoth(playerID, friendID)
    
    #XW_SJ_DeleteFriend ½â³ýºÃÓѳɹ¦
    PlayerControl.NotifyCode(curPlayer, 'Friend_DeleteFriend')
    
    tagPlayer = GameWorld.GetPlayerManager().FindPlayerByID(friendID)
    if tagPlayer != None:
        PlayerControl.NotifyCode(tagPlayer, 'Friend_DeleteFriend2', [curPlayer.GetName()])
    PlayerTeam.OnTeamMemFriendChange(curPlayer, friendID, False)
    return


## ¼ì²âºÃÓÑÊýÊÇ·ñ´ïµ½ÉÏÏÞ
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @return ²¼¶ûÖµ
#  @remarks º¯ÊýÏêϸ˵Ã÷.
def CheckFriendCount(curPlayer, isNotify, playerID):
    
    curFriends = PyDataManager.GetFriendManager().GetFriends(playerID)
    if curFriends == None:
        return True
        
    if curFriends.GetCount() >= IpyGameDataPY.GetFuncCfg("FriendMaxCnt"):
        # ºÃÓÑÒÑÂú
        if isNotify:
            PlayerControl.NotifyCode(curPlayer, "Friend_FullList")
        return False
    
    return True

#===============================================================================
# //B3 03 ÊÇ·ñÔÊÐí¼ÓÈëºÃÓѵĻØÓ¦#tagCGJoinFriendAnswer
# 
# struct    tagCGJoinFriendAnswer
# {
#    tagHead        Head;
#    DWORD        TagID;
#    BYTE        Answer;        //0: ¾Ü¾ø 1: ½ÓÊÜ
# };
#===============================================================================
## ÊÇ·ñÔÊÐí¼ÓÈëºÃÓѵĻØÓ¦
def JoinFriendAnswer(index, clientData, tick):
    playerManager = GameWorld.GetPlayerManager()
    curPlayer = playerManager.GetPlayerByIndex(index)
    
    srcPlayerID = clientData.TagID  # ÇëÇóÕßµÄID
    srcPlayer = playerManager.FindPlayerByID(srcPlayerID)
    if srcPlayer == None:
        # Íæ¼ÒÒÑÏÂÏß
        curCache = PlayerViewCache.ViewCacheMgr.FindCache(srcPlayerID)
        if not curCache:
            #Íæ¼ÒµÄÊý¾ÝûÓлº´æ¹ý
            #PlayerControl.NotifyCode(curPlayer, 'Friend_OffLine')
            return
    
    playerID = curPlayer.GetPlayerID()
    
    if playerID == srcPlayerID:
        GameWorld.Log('JoinFriendAnswer -> ·â°üÒì³£ ->²»ÄܼÓÈë×Ô¼ºÎªºÃÓÑ', playerID)
        return
    
    if not PlayerRequest.PYCheckRequest(srcPlayerID, curPlayer, IPY_GameServer.reqFriend):
        GameWorld.Log("JoinFriendAnswer -> ·â°üÒì³£ ->Íæ¼ÒûÓÐÕâ¸öÇëÇó", playerID)
        return
    
    if not clientData.Answer: 
        if srcPlayer:
            #XW_SJ_RefuseApply  XXX¾Ü¾ø°ÑÄã¼ÓΪºÃÓÑ
            PlayerControl.NotifyCode(srcPlayer, 'Friend_RejectFriend', [curPlayer.GetName()])
        return
    
    # ºÚÃûµ¥¼ì²é
    if PyDataManager.GetBlacklistManager().CheckBlacklistBoth(playerID, srcPlayerID, curPlayer):
        return
    
    #×Ô¼ºµÄºÃÓÑÂúÔ±
    if not CheckFriendCount(curPlayer, True, curPlayer.GetID()):
        
        GameWorld.DebugLog("#×Ô¼ºµÄºÃÓÑÂúÔ±")
        return
    
    #¶Ô·½µÄºÃÓÑÂúÔ±
    if not CheckFriendCount(None, False, srcPlayerID):
        PlayerControl.NotifyCode(curPlayer, "Friend_OtherFullList")
        return
    
    curFriends = PyDataManager.GetFriendManager().GetFriends(playerID)
    if curFriends == None:
        curFriends = PyDataManager.GetFriendManager().AddFriends(playerID)
        
    tagFriend = curFriends.Find(playerID)
    if tagFriend != None:
        #Õâ¸öºÃÓÑÒѾ­ÔÚ×Ô¼ºµÄºÃÓÑÁбíÖÐ
        GameWorld.Log('JoinFriendAnswer -> ·â°üÒì³£ ->Õâ¸öºÃÓÑÒѾ­ÔÚ×Ô¼ºµÄºÃÓÑÁбíÖÐ', playerID)
        return
        
    PyDataManager.GetFriendManager().AddFriendBoth(playerID, srcPlayerID)
    
    #XW_SJ_AppendFriend xxx³ÉΪÁËÄúµÄºÃÓÑ
    ##·¢ËÍÌí¼ÓºÃÓѳɹ¦µ½µØͼ·þÎñÆ÷ 
    # ´Ë´¦Í¨ÖªÖ»ÊÇ´¥·¢Í¬Ò»¸öºÃÓÑÌí¼Óɾ³ý¿É´¥·¢¶à´Î£¬ MapServer_SyncFriendInfoΪ¾ßÌåµÄºÃÓÑÊýÁ¿£¬¸ù¾Ý²ß»®ÐèÇóÖÆ×÷
    #curPlayer.MapServer_QueryPlayerResult(0, 0, 'AddFriendSucceed', "", 0)
    if srcPlayer:   
        PlayerControl.NotifyCode(curPlayer, 'Friend_MakeFriend', [srcPlayer.GetName()])  
        PlayerControl.NotifyCode(srcPlayer, 'Friend_MakeFriend', [curPlayer.GetName()])
        #srcPlayer.MapServer_QueryPlayerResult(0, 0, 'AddFriendSucceed', "", 0)
    else:
        cacheDict = json.loads(curCache.GetPropData())
        PlayerControl.NotifyCode(curPlayer, 'Friend_MakeFriend', [cacheDict['Name']])  
        # ¼Ç¼µÈ¶Ô·½ÉÏÏß֪ͨµØͼ£¬ÈÎÎñµÈ»áÓõ½´¥·¢Âß¼­£¬Í¨ÓüǼ´ÎÊý¼´¿É£¬ MapServer_SyncFriendInfoΪ¾ßÌåµÄºÃÓÑÊýÁ¿£¬¸ù¾Ý²ß»®ÐèÇóÖÆ×÷
        pass
    PlayerTeam.OnTeamMemFriendChange(curPlayer, srcPlayerID, True)
    return



#//06 02 Ìí¼ÓµÐÈË#tagGAddEnemy
#tagGAddEnemy       *   GettagGAddEnemy();
#
#class   IPY_GAddEnemy
#{
#public:
#
#    int      GetEnemyID();
#
#    char *      GetEnemyName();
#};
## Ìí¼ÓµÐÈË 
#  @param index Íæ¼ÒË÷Òý
#  @param tick µ±Ç°Ê±¼ä
#  @return None
#  @remarks º¯ÊýÏêϸ˵Ã÷.
def MapServer_AddEnemy(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    pack = IPY_GameServer.IPY_GAddEnemy()
    tagID = pack.GetEnemyID()
    playerID = curPlayer.GetPlayerID()
    
    friends = PyDataManager.GetFriendManager().GetFriends(playerID)
    if friends and friends.Find(tagID):
        #ºÃÓѲ»¼ÓÈë³ðÈË
        return

    enemies = PyDataManager.GetEnemyManager().GetEnemies(playerID)
    if enemies and enemies.GetCount() > IpyGameDataPY.GetFuncCfg("EnemiesMaxCnt"):
        return

    # ÐèÒª¸üÐÂ×îÐÂÊý¾ÝÕâÀï²»¹ýÂËÊÇ·ñÒѾ­ÊdzðÈË
    PyDataManager.GetEnemyManager().AddEnemy(playerID, tagID)
    
    return

#===============================================================================
# //B3 04 ¼ÓÈëºÚÃûµ¥ #tagCGAddBlackList
# 
# struct    tagCGAddBlackList
# {
#    tagHead        Head;
#    DWORD        TagID;        //Íæ¼ÒID
# };
#===============================================================================
def AddBlackList(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    tagID = clientData.TagID
    
    # ·ÇÉ罻ȦÄÚÍæ¼Ò²»ÄܼÓÈëºÚÃûµ¥
    #===========================================================================
    # if not PyDataManager.GetPersonalSocialManager().GetSocialPlayer(tagID):
    #    #¼Ù·â°ü»òÕßÒì³£
    #    GameWorld.DebugLog("#¼Ù·â°ü»òÕßÒì³£")
    #    return
    #===========================================================================
    
    tagPlayer = GameWorld.GetPlayerManager().FindPlayerByID(tagID)
    if not tagPlayer:
        curCache = PlayerViewCache.ViewCacheMgr.FindCache(tagID)
        if not curCache:
            return
        cacheDict = json.loads(curCache.GetPropData())
        playerName = cacheDict['Name']
    else:
        playerName = tagPlayer.GetName()
        
    players = PyDataManager.GetBlacklistManager().GetBlacklist(curPlayer.GetID())
    if players != None:

        if players.GetCount() >= IpyGameDataPY.GetFuncCfg("BlacklistMaxCnt"):
            PlayerControl.NotifyCode(curPlayer, 'BlacklistFull')
            return False
    
    PyDataManager.GetBlacklistManager().JoinBlacklist(curPlayer.GetPlayerID(), tagID)
    
    PlayerControl.NotifyCode(curPlayer, 'AddBlackList', [playerName])
    
    return


#===============================================================================
# //B3 05 ÒƳýºÚÃûµ¥ #tagCGDelBlackList
# 
# struct    tagCGDelBlackList
# {
#    tagHead        Head;
#    DWORD        TagID;
# };
#===============================================================================
def DelBlackList(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    PyDataManager.GetBlacklistManager().DelBlacklist(curPlayer.GetPlayerID(), clientData.TagID)
    PlayerControl.NotifyCode(curPlayer, 'DelBlackSuccess')
    #GameWorld.DebugLog("pack DelBlackList  %s "%clientData.TagID)
    return

############################################################
## µÇ½ºó֪ͨºÃÓÑ
def __OnPlayerLoginFriend(curPlayer, tick):
    #Íæ¼ÒµÇ¼
    curFriends = PyDataManager.GetFriendManager().GetFriends(curPlayer.GetID())
    if curFriends == None:
        return
    
    curFriends.Sync_SocialsInfo(curPlayer)
    #Ìí¼ÓÀëÏß¼ÓºÃÓÑ£¬ÉÏÏß֪ͨmapserver
    curFriends.MapServer_SyncFriendInfo(curPlayer)
    
    #֪ͨºÃÓÑÇëÇóÐÅÏ¢
    PlayerRequest.Sync_LoginRequest(curPlayer)
    return

## µÇ½ºó֪ͨ³ðÈË
def __OnPlayerLoginEnemy(curPlayer, tick):
    #֪ͨ³ðÈËÐÅÏ¢
    players = PyDataManager.GetEnemyManager().GetEnemies(curPlayer.GetID())
    if players == None:
        return
    
    players.Sync_SocialsInfo(curPlayer)
    return

# ×î½üÁªÏµÈË
def __OnPlayerLoginContacts(curPlayer, tick):
    players = PyDataManager.GetContactsManager().GetContacts(curPlayer.GetID())
    if players == None:
        return
    
    players.Sync_SocialsInfo(curPlayer)
    return

#ºÚÃûµ¥
def __OnPlayerLoginBlacklist(curPlayer, tick):
    players = PyDataManager.GetBlacklistManager().GetBlacklist(curPlayer.GetID())
    if players == None:
        return
    
    players.Sync_SocialsInfo(curPlayer)
    return

## Íæ¼ÒµÇ½
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @param tick µ±Ç°Ê±¼ä
#  @return None
#  @remarks º¯ÊýÏêϸ˵Ã÷.
def OnPlayerLogin(curPlayer, tick):
    socialPlayer = PyDataManager.GetPersonalSocialManager().GetSocialPlayer(curPlayer.GetID())
    if socialPlayer:
        socialPlayer.playerInfo.OnlineType = ChConfig.Def_Online
    __OnPlayerLoginFriend(curPlayer, tick)
    __OnPlayerLoginEnemy(curPlayer, tick)
    __OnPlayerLoginContacts(curPlayer, tick)
    __OnPlayerLoginBlacklist(curPlayer, tick)
    
    # Ïòµ±Ç°Íæ¼Ò֪ͨÏà¹ØÁªµÄËùÓÐÍæ¼ÒÐÅÏ¢
    PlayerSocial.Sync_AllSocialsInfo(curPlayer)
    
    # ÏòÏà¹ØÁªµÄËùÓÐÍæ¼Ò֪ͨµ±Ç°Íæ¼ÒÐÅÏ¢
    PlayerSocial.Notify_All(curPlayer.GetID(), ChConfig.Def_CDBPlayerRefresh_Online, ChConfig.Def_Online)
    return



## Íæ¼ÒÏÂÏß
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @param tick µ±Ç°Ê±¼ä
#  @return None
#  @remarks º¯ÊýÏêϸ˵Ã÷.
def OnPlayerDisconnect(curPlayer, tick):
    if PlayerControl.GetIsTJG(curPlayer):
        return
    
    socialPlayer = PyDataManager.GetPersonalSocialManager().GetSocialPlayer(curPlayer.GetID())
    if socialPlayer == None:
        return
    socialPlayer.playerInfo.OnlineType = ChConfig.Def_Offline

    PlayerSocial.Notify_All(curPlayer.GetID(), ChConfig.Def_CDBPlayerRefresh_Online, ChConfig.Def_Offline)
    return



#// A9 A3 ²é¿´ÍƼöºÃÓÑ #tagCGQueryRecommendFriends
#
#struct    tagCGQueryRecommendFriends
#{
#    tagHead        Head;
#};
## ÍƼöºÃÓÑ
def Client_RecommendFriends(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    
    #recommendDict = [(5000, [0, 30]), (8000,[31, 50]), (9500,[51, 70]), (10000,[71, 800])]
    recommendFriend = copy.deepcopy(IpyGameDataPY.GetFuncEvalCfg("recommendFriend"))
    needCnt = IpyGameDataPY.GetFuncCfg("SerchFriendCnt")
    
    playerLV = curPlayer.GetLV()
    curPlayerID = curPlayer.GetPlayerID()
    curPlayerFriendStruct = GetFriendStruct(curPlayerID)
    
    limitLV = GetFuncLimitLV(ShareDefine.GameFuncID_Friend)
    if playerLV < limitLV:
        return
    #¹¹½¨²éѯÁбí
    allPlayerID = set()
    playerManager = GameWorld.GetPlayerManager()
    for i in range(0, playerManager.GetActivePlayerCount()):
        findPlayer = playerManager.GetActivePlayerAt(i)
        if findPlayer == None or not findPlayer.GetInitOK():
            continue
        curTagPlayerID = findPlayer.GetPlayerID()
        if curPlayerID == curTagPlayerID:
            #²»ÔÊÐíÌí¼Ó×Ô¼º
            continue
        
        # ÍƼöºÃÓÑÈ¥³ýÍÑ»ú¹ÒÍæ¼Ò
        if PlayerControl.GetIsTJG(findPlayer):
            continue
        
        #ÒÑÊǺÃÓÑ
        tagFriend = curPlayerFriendStruct.Find(curTagPlayerID)
        if tagFriend != None:
            continue
        
        #ÔÚºÚÃûµ¥ÖÐ
        if PyDataManager.GetBlacklistManager().CheckBlacklistBoth(curPlayerID, curTagPlayerID):
            GameWorld.DebugLog("ºÚÃûµ¥¼ì²é")
            continue
        
        # ÒÑÔÚÇëÇóÁбíÖÐ
        if PlayerRequest.IsRequesting(curPlayerID, curTagPlayerID, IPY_GameServer.reqFriend):
            continue
        
        #°´µÈ¼¶Çø¼ä·Ö×é
        findLV = findPlayer.GetLV()
        if findLV < limitLV:
            # ÏÞÖƵȼ¶
            continue
        
        for recommend in recommendFriend:
            minLV = recommend[1][0]
            maxLV = recommend[1][1]
            # ²»ÔÚÖ¸¶¨Çø¼äÄÚ
            if not ((playerLV - maxLV) <= findLV <= (playerLV - minLV) and \
            (playerLV + minLV) <= findLV <= (playerLV + maxLV)):
                continue
            
            if len(recommend) == 2:
                recommend[1].append([])
            recommend[1][2].append(curTagPlayerID)
        
        # ×îÖÕɸѡÓÃ
        allPlayerID.add(curTagPlayerID)
        
    GameWorld.DebugLog("recommendFriend %s"%(recommendFriend,))    
    

    
    # °´È¨ÖزéÕÒÍæ¼Ò
    playeIDs = []
    for i in xrange(needCnt*2):
        lvlimit = GameWorld.GetResultByRandomList(recommendFriend)
        if len(lvlimit) == 2:
            # ûÓÐÍæ¼Ò
            continue
        
        playerID = random.choice(lvlimit[2])
        if playerID in playeIDs:
            continue
        
        if len(playeIDs) == needCnt:
            break
    
    #ÐÞÕý²»×ã
    fixCnt = needCnt - len(playeIDs)
    if fixCnt > 0:
        fixList = list(allPlayerID - set(playeIDs))
        playeIDs.extend(random.sample(fixList, min(fixCnt, len(fixList))))
    
    sendPack = ChPyNetSendPack.tagGCRecommendFriendsInfo()
    sendPack.Cnt = len(playeIDs)
    sendPack.FriendsList = []
    for playerID in playeIDs:
        tagPlayer = playerManager.FindPlayerByID(playerID)
        if not tagPlayer:
            continue
        rceFriendsData = ChPyNetSendPack.tagRecommendFriendsData()
        rceFriendsData.ID = playerID
        rceFriendsData.Name = tagPlayer.GetName()
        rceFriendsData.LV = tagPlayer.GetLV()
        rceFriendsData.Job = tagPlayer.GetJob()
        rceFriendsData.RealmLV = tagPlayer.GetOfficialRank()
        sendPack.FriendsList.append(rceFriendsData)
        
    #GameWorld.DebugLog("Client_RecommendFriends:%s"%sendPack.FriendsList)
    NetPackCommon.SendFakePack(curPlayer, sendPack) 
    return


#===============================================================================
# // A9 A4 ²éÕÒÍæ¼Ò #tagCGFuzzySearchPlayer
# 
# struct    tagCGFuzzySearchPlayer
# {
#    tagHead        Head;
#    char        Name[33];
# };
#===============================================================================

def FuzzySearchPlayer(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    findName = clientData.Name
    limitLV = GetFuncLimitLV(ShareDefine.GameFuncID_Friend)
    if curPlayer.GetLV() < limitLV:
        return
    
    players = []
    curPlayerFriendStruct = GetFriendStruct(curPlayer.GetPlayerID())
    playerManager = GameWorld.GetPlayerManager()
    for i in range(0, playerManager.GetActivePlayerCount()):
        findPlayer = playerManager.GetActivePlayerAt(i)
        if findPlayer == None or not findPlayer.GetInitOK():
            continue
        
        curTagPlayerID = findPlayer.GetPlayerID()
        if curPlayer.GetPlayerID() == curTagPlayerID:
            #²»ÔÊÐíÌí¼Ó×Ô¼º
            continue
        
        #ÒÑÊǺÃÓÑ
        tagFriend = curPlayerFriendStruct.Find(curTagPlayerID)
        if tagFriend != None:
            continue
        
        if findPlayer.GetLV() < limitLV:
            # ÏÞÖƵȼ¶
            continue
        
        if findName in findPlayer.GetName():
            players.append(findPlayer)
    
    
    sendPack = ChPyNetSendPack.tagGCRecommendFriendsInfo()
    sendPack.Cnt = len(players)
    sendPack.FriendsList = []
    for tagPlayer in players:
        rceFriendsData = ChPyNetSendPack.tagRecommendFriendsData()
        rceFriendsData.ID = tagPlayer.GetID()
        rceFriendsData.Name = tagPlayer.GetName()
        rceFriendsData.LV = tagPlayer.GetLV()
        rceFriendsData.Job = tagPlayer.GetJob()
        sendPack.FriendsList.append(rceFriendsData)
        
    
    NetPackCommon.SendFakePack(curPlayer, sendPack) 
    return



## »ñÈ¡¹¦ÄÜÏÞÖƵȼ¶(µÈ¼¶Ìõ¼þΪȫ¾Ö)
def GetFuncLimitLV(funcID):
    ipyData = IpyGameDataPY.GetIpyGameData("FuncOpenLV", funcID)
    if not ipyData:
        return 0
    
    return ipyData.GetLimitLV()