You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1529 lines
59 KiB
1529 lines
59 KiB
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
|
|
using Sog;
|
|
using ProtoCSStruct;
|
|
|
|
namespace Friend
|
|
{
|
|
class FriendOp
|
|
{
|
|
|
|
#region 通过玩家保存的 对应的数组索引 获取数据
|
|
/// <summary>
|
|
/// 通过数组下标index获取selfuid用户里面的指定FriendStranger
|
|
/// </summary>
|
|
/// <param name="selfUid"></param>
|
|
/// <param name="index"></param>
|
|
/// <returns>ref DBFriendStrangerOneStruct</returns>
|
|
public static unsafe ref DBFriendStrangerOneStruct GetFriendStrangerByIndex(ref FriendCacheInfoStruct infoStruct, int index)
|
|
{
|
|
if (index >= infoStruct.FriendOpData.StrangerCount || index < 0)
|
|
{
|
|
return ref FriendInfoCache.m_cacheStructFriendStranger.GetByIndex(0);
|
|
}
|
|
long posIndex = infoStruct.FriendOpData.StrangerList[index];
|
|
return ref FriendInfoCache.m_cacheStructFriendStranger.GetByIndex(posIndex);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 通关玩家UID 和 数组下标 获取指定其中一个好友
|
|
/// </summary>
|
|
/// <param name="selfUid"></param>
|
|
/// <param name="index"></param>
|
|
/// <returns></returns>
|
|
public static unsafe ref DBFriendOneStruct GetFriendOneByIndex(ref FriendCacheInfoStruct infoStruct, int index)
|
|
{
|
|
if (index >= infoStruct.FriendList.iCount || index < 0)
|
|
{
|
|
return ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(0);
|
|
}
|
|
long posIndex = infoStruct.FriendList.DBFriendOneID[index];
|
|
return ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(posIndex);
|
|
}
|
|
/// <summary>
|
|
/// 通过数组下标index获取selfuid用户里面的指定chat
|
|
/// </summary>
|
|
/// <param name="selfUid"></param>
|
|
/// <param name="index"></param>
|
|
/// <returns>ref DBFriendChatOneStruct</returns>
|
|
|
|
public static unsafe ref DBFriendChatOneStruct GetFriendChatByIndex(ref FriendCacheInfoStruct infoStruct, int index)
|
|
{
|
|
if (index >= infoStruct.FriendOpData.ChatCount || index < 0)
|
|
{
|
|
return ref FriendInfoCache.m_cacheStructFriendChat.GetByIndex(0);
|
|
}
|
|
long posIndex = infoStruct.FriendOpData.ChatList[index];
|
|
return ref FriendInfoCache.m_cacheStructFriendChat.GetByIndex(posIndex);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 通过数组下标index获取selfuid用户里面的指定Op
|
|
/// </summary>
|
|
/// <param name="selfUid"></param>
|
|
/// <param name="index"></param>
|
|
/// <returns>ref DBFriendOpDataStruct</returns>
|
|
|
|
public static unsafe ref DBFriendOneOpStruct GetFriendOpByIndex(ref FriendCacheInfoStruct infoStruct, int index)
|
|
{
|
|
if (index >= infoStruct.FriendOpData.OpCount || index < 0)
|
|
{
|
|
return ref FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(0);
|
|
}
|
|
long posIndex = infoStruct.FriendOpData.OpList[index];
|
|
return ref FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(posIndex);
|
|
}
|
|
#endregion
|
|
|
|
#region 通过玩家UID获取 指定数据
|
|
/// <summary>
|
|
/// 通过玩家UID获取Friendinfo
|
|
/// </summary>
|
|
/// <param name="selfUid"></param>
|
|
/// <returns></returns>
|
|
public static unsafe ref FriendCacheInfoStruct GetFriendInfoByUid(long selfUid)
|
|
{
|
|
FriendInfoCache.m_selfIDMap.TryGetValue(selfUid, out long posIndex);
|
|
return ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(posIndex);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取我的好友中,指定UID的好友
|
|
/// </summary>
|
|
/// <param name="selfUid"></param>
|
|
/// <param name="Uid"></param>
|
|
/// <returns></returns>
|
|
public static unsafe ref DBFriendOneStruct GetFriendOneByUid(long selfUid, long Uid)
|
|
{
|
|
ref FriendCacheInfoStruct selfInfoStruct = ref FriendOp.GetFriendInfoByUid(selfUid);
|
|
if (selfInfoStruct.IsNull())
|
|
{
|
|
return ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(0);
|
|
}
|
|
|
|
for (int i = 0; i < selfInfoStruct.FriendList.iCount; i++)
|
|
{
|
|
ref var oneStruct = ref GetFriendOneByIndex(ref selfInfoStruct, i);
|
|
if (oneStruct.oneFriend.Uid == Uid)
|
|
{
|
|
return ref oneStruct;
|
|
}
|
|
}
|
|
|
|
return ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(0);
|
|
}
|
|
|
|
|
|
public static unsafe ref DBFriendStrangerOneStruct GetStrangerByUid(long selfUid, long StrangerUid)
|
|
{
|
|
ref FriendCacheInfoStruct info =ref GetFriendInfoByUid(selfUid);
|
|
if (info.IsNull())
|
|
{
|
|
return ref FriendInfoCache.m_cacheStructFriendStranger.GetByIndex(0);
|
|
}
|
|
|
|
for (int i = 0; i < info.FriendOpData.StrangerCount; i++)
|
|
{
|
|
ref DBFriendStrangerOneStruct one =ref GetFriendStrangerByIndex(ref info, i);
|
|
if (one.IsNull())
|
|
{
|
|
continue;
|
|
}
|
|
ref var friendone = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(one.DBFriendOneID);
|
|
if (friendone.oneFriend.Uid == StrangerUid)
|
|
{
|
|
return ref one;
|
|
}
|
|
}
|
|
return ref FriendInfoCache.m_cacheStructFriendStranger.GetByIndex(0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 找到其中一个操作,比如其他玩家邀请加我为好友
|
|
/// </summary>
|
|
/// <param name="selfUid"></param>
|
|
/// <param name="opUid"></param>
|
|
/// <returns></returns>
|
|
public static unsafe ref DBFriendOneOpStruct GetFriendOpByUid(long selfUid, long opUid, int opType)
|
|
{
|
|
ref FriendCacheInfoStruct info = ref GetFriendInfoByUid(selfUid);
|
|
for (int i = 0; i < info.FriendOpData.OpCount; i++)
|
|
{
|
|
ref DBFriendOneOpStruct one =ref GetFriendOpByIndex(ref info, i);
|
|
if (one.IsNull())
|
|
{
|
|
continue;
|
|
}
|
|
ref var friendone = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(one.DBFriendOneID);
|
|
if (friendone.oneFriend.Uid == opUid && one.OpType == opType)
|
|
{
|
|
return ref one;
|
|
}
|
|
}
|
|
return ref FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(0);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 删除玩家的好友相关信息
|
|
/// <summary>
|
|
/// 删除一个好友通过好友UID
|
|
/// </summary>
|
|
/// <param name="infoStruct"></param>
|
|
/// <param name="Uid"></param>
|
|
public static unsafe void DoDeleteFriendList(ref FriendCacheInfoStruct infoStruct, long Uid)
|
|
{
|
|
if (infoStruct.IsNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
int arrayIndex = -1;
|
|
for (int i = 0; i < infoStruct.FriendList.iCount; i++)
|
|
{
|
|
ref var oneStruct = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(infoStruct.FriendList.DBFriendOneID[i]);
|
|
if (oneStruct.oneFriend.Uid == Uid)
|
|
{
|
|
arrayIndex = i;
|
|
DoFreeFriendOneByIndex(infoStruct.FriendList.DBFriendOneID[i]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (arrayIndex >= 0)
|
|
{
|
|
//1:首先把最后一个的关联缓存索引赋值给删除的这个(好友前端排序就好了,所以这里的顺序不重要)
|
|
infoStruct.FriendList.DBFriendOneID[arrayIndex] =
|
|
infoStruct.FriendList.DBFriendOneID[infoStruct.FriendList.iCount - 1];
|
|
//2:然后将最后一个置0
|
|
infoStruct.FriendList.DBFriendOneID[infoStruct.FriendList.iCount - 1] = 0;
|
|
//3:好友数量 --
|
|
infoStruct.FriendList.iCount--;
|
|
|
|
infoStruct.SetNeedSave(true);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 通过索引删除一个好友操作
|
|
/// </summary>
|
|
/// <param name="infoStruct"></param>
|
|
/// <param name="index"></param>
|
|
public static unsafe void DoDeleteFriendOP(ref FriendCacheInfoStruct infoStruct, long posIndex)
|
|
{
|
|
ref DBFriendOneOpStruct opStruct = ref FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(posIndex);
|
|
if (opStruct.IsNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
int arrayIndex = -1;
|
|
for (int i = 0; i < infoStruct.FriendOpData.OpCount; i++)
|
|
{
|
|
if (infoStruct.FriendOpData.OpList[i] == posIndex)
|
|
{
|
|
arrayIndex = i;
|
|
DoFreeFriendOPByIndex(posIndex);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (arrayIndex >= 0)
|
|
{
|
|
//1:首先把最后一个的关联缓存索引赋值给删除的这个(好友前端排序就好了,所以这里的顺序不重要)
|
|
infoStruct.FriendOpData.OpList[arrayIndex] = infoStruct.FriendOpData.OpList[infoStruct.FriendOpData.OpCount - 1];
|
|
//2:然后将最后一个置0
|
|
infoStruct.FriendOpData.OpList[infoStruct.FriendOpData.OpCount - 1] = 0;
|
|
//3:数量 --
|
|
infoStruct.FriendOpData.OpCount--;
|
|
|
|
infoStruct.SetNeedSave(true);
|
|
}
|
|
}
|
|
|
|
|
|
public static unsafe void DoDeleteFriendOp(ref FriendCacheInfoStruct selfInfo, long opUid, int opType)
|
|
{
|
|
int arrayIndex = -1;
|
|
for (int i = 0; i < selfInfo.FriendOpData.OpCount; i++)
|
|
{
|
|
ref DBFriendOneOpStruct friendOpStruct = ref FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(selfInfo.FriendOpData.OpList[i]);
|
|
ref var oneFriend = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(friendOpStruct.DBFriendOneID);
|
|
if (!oneFriend.IsNull() && oneFriend.oneFriend.Uid == opUid && friendOpStruct.OpType == opType)
|
|
{
|
|
arrayIndex = i;
|
|
DoFreeFriendOPByIndex(friendOpStruct.GetObjectID());
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (arrayIndex >= 0)
|
|
{
|
|
selfInfo.FriendOpData.OpList[arrayIndex] = selfInfo.FriendOpData.OpList[selfInfo.FriendOpData.OpCount - 1];
|
|
selfInfo.FriendOpData.OpList[selfInfo.FriendOpData.OpCount - 1] = 0;
|
|
selfInfo.FriendOpData.OpCount--;
|
|
|
|
selfInfo.SetNeedSave(true);
|
|
}
|
|
}
|
|
|
|
|
|
public static unsafe void DoDeleteFriendOpByType(ref FriendCacheInfoStruct selfInfo, int opType)
|
|
{
|
|
for (int i = selfInfo.FriendOpData.OpCount - 1; i >= 0; i--)
|
|
{
|
|
long posIndex = selfInfo.FriendOpData.OpList[i];
|
|
ref DBFriendOneOpStruct oneOp = ref FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(posIndex);
|
|
if (oneOp.IsNull())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (oneOp.OpType == opType)
|
|
{
|
|
DoFreeFriendOPByIndex(posIndex);
|
|
|
|
selfInfo.FriendOpData.OpList[i] = selfInfo.FriendOpData.OpList[selfInfo.FriendOpData.OpCount - 1];
|
|
selfInfo.FriendOpData.OpList[selfInfo.FriendOpData.OpCount - 1] = 0;
|
|
selfInfo.FriendOpData.OpCount--;
|
|
|
|
selfInfo.SetNeedSave(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 通过数组下标删除(说明:聊天这个顺序好像有作用,聊天消息满了从第一个开始删除的,这个之后改下看看)
|
|
/// </summary>
|
|
/// <param name="infoStruct"></param>
|
|
/// <param name="index"></param>
|
|
public static unsafe void DoDeleteFriendChat(ref FriendCacheInfoStruct infoStruct, int arrayIndex)
|
|
{
|
|
if (arrayIndex < 0 || arrayIndex >= infoStruct.FriendOpData.ChatCount)
|
|
{
|
|
return;
|
|
}
|
|
|
|
DoFreeChatListByIndex(infoStruct.FriendOpData.ChatList[arrayIndex]);
|
|
|
|
//聊天的保留顺序
|
|
for (int i = arrayIndex + 1; i < infoStruct.FriendOpData.ChatCount; i++)
|
|
{
|
|
infoStruct.FriendOpData.ChatList[i - 1] = infoStruct.FriendOpData.ChatList[i];
|
|
}
|
|
infoStruct.FriendOpData.ChatList[infoStruct.FriendOpData.ChatCount - 1] = 0;
|
|
infoStruct.FriendOpData.ChatCount--;
|
|
|
|
infoStruct.SetNeedSave(true);
|
|
}
|
|
|
|
public static unsafe void DoDeleteAllChat(ref FriendCacheInfoStruct infoStruct)
|
|
{
|
|
TraceLog.Trace("FriendOp.DoDeleteAllChat uid {0} chat count {1}"
|
|
, infoStruct.Self.Uid, infoStruct.FriendOpData.ChatCount);
|
|
|
|
for (int i = 0; i < infoStruct.FriendOpData.ChatCount; i++)
|
|
{
|
|
DoFreeChatListByIndex(infoStruct.FriendOpData.ChatList[i]);
|
|
}
|
|
|
|
infoStruct.FriendOpData.ChatCount = 0;
|
|
infoStruct.SetNeedSave(true);
|
|
}
|
|
|
|
public static unsafe void DoDeleteStranger(ref FriendCacheInfoStruct selfInfo, long targetUid)
|
|
{
|
|
int arrayIndex = -1;
|
|
for (int i = 0; i < selfInfo.FriendOpData.StrangerCount; i++)
|
|
{
|
|
ref DBFriendStrangerOneStruct strangerOneStruct = ref FriendInfoCache.m_cacheStructFriendStranger.GetByIndex(selfInfo.FriendOpData.StrangerList[i]);
|
|
ref var oneFriend = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(strangerOneStruct.DBFriendOneID);
|
|
if (! oneFriend.IsNull() && oneFriend.oneFriend.Uid == targetUid)
|
|
{
|
|
arrayIndex = i;
|
|
DoFreeStrangerByIndex(strangerOneStruct.GetObjectID());
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (arrayIndex >= 0)
|
|
{
|
|
selfInfo.FriendOpData.StrangerList[arrayIndex] = selfInfo.FriendOpData.StrangerList[selfInfo.FriendOpData.StrangerCount - 1];
|
|
selfInfo.FriendOpData.StrangerList[selfInfo.FriendOpData.StrangerCount - 1] = 0;
|
|
selfInfo.FriendOpData.StrangerCount--;
|
|
|
|
selfInfo.SetNeedSave(true);
|
|
}
|
|
}
|
|
|
|
public static bool GMDeleteFriendCache = false;
|
|
|
|
/// <summary>
|
|
/// 以后实现逻辑，可以暂时不管(逻辑上问题,这个之后估计要废弃,缓存数据将跟随PlayerInfoFriend创建而创建,PlayerInfoFriend销毁而销毁)
|
|
/// </summary>
|
|
/// <param name="uid"></param>
|
|
/// <returns></returns>
|
|
public static bool CanDeleteFriendCacheInfo(long uid)
|
|
{
|
|
ref FriendCacheInfoStruct info = ref GetFriendInfoByUid(uid);
|
|
|
|
//数据需要保存
|
|
if (info.GetNeedSave())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// 停服时存盘后直接删除, 不用等超时
|
|
if (FriendServerUtils.GetApp().IsStopping)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//在线玩家不删除
|
|
PlayerInfoFriend player = FriendServerUtils.GetPlayerTableOp().GetPlayerInfo(uid);
|
|
if (player != null && player.IsOnline)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// GM测试
|
|
//if (GMDeleteFriendCache)
|
|
//{
|
|
// return true;
|
|
//}
|
|
|
|
//配置的超时时间
|
|
if (FriendServerUtils.GetTimeSecond() - info.LastAccessTime < FriendConfig.GetFriendCacheTimeout())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 清除一个玩家的数据,注意现在好像没有删除PlayerInfoFriend player的逻辑
|
|
/// </summary>
|
|
/// <param name="uid"></param>
|
|
public static unsafe void DeleteFriendCacheInfo(long uid)
|
|
{
|
|
ref FriendCacheInfoStruct info = ref GetFriendInfoByUid(uid);
|
|
if (! info.IsNull())
|
|
{
|
|
DeleteFriendCacheInfo(ref info);
|
|
}
|
|
}
|
|
|
|
private static bool logEx = false;
|
|
|
|
public static unsafe void DeleteFriendCacheInfo(ref FriendCacheInfoStruct info)
|
|
{
|
|
// 外网好像在这里core了, 没有log, catch看看是不是core这里了
|
|
try
|
|
{
|
|
for (int i = 0; i < info.FriendList.iCount; i++)
|
|
{
|
|
FriendInfoCache.m_cacheStructFriendOne.Free(info.FriendList.DBFriendOneID[i]);
|
|
}
|
|
info.FriendList.iCount = 0;
|
|
|
|
for (int i = 0; i < info.FriendOpData.OpCount; i++)
|
|
{
|
|
DoFreeFriendOPByIndex(info.FriendOpData.OpList[i]);
|
|
}
|
|
info.FriendOpData.OpCount = 0;
|
|
|
|
for (int i = 0; i < info.FriendOpData.ChatCount; i++)
|
|
{
|
|
FriendInfoCache.m_cacheStructFriendChat.Free(info.FriendOpData.ChatList[i]);
|
|
}
|
|
info.FriendOpData.ChatCount = 0;
|
|
|
|
for (int i = 0; i < info.FriendOpData.StrangerCount; i++)
|
|
{
|
|
DoFreeStrangerByIndex(info.FriendOpData.StrangerList[i]);
|
|
}
|
|
info.FriendOpData.StrangerCount = 0;
|
|
|
|
FriendInfoCache.m_cacheStructFriendInfo.Free(info.GetObjectID());
|
|
FriendInfoCache.m_selfIDMap.Remove(info.Self.Uid);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (! logEx)
|
|
{
|
|
TraceLog.Exception(e);
|
|
logEx = true;
|
|
}
|
|
}
|
|
|
|
TraceLog.Trace("FriendCacheOp.DeleteFriendCacheInfo FriendInfoCache used {0} free {1}"
|
|
, FriendInfoCache.m_cacheStructFriendInfo.GetUsedCount()
|
|
, FriendInfoCache.m_cacheStructFriendInfo.GetFreeCount());
|
|
|
|
|
|
TraceLog.Trace("FriendCacheOp.DeleteFriendCacheInfo FriendOp used {0} free {1}"
|
|
, FriendInfoCache.m_cacheStructFriendOneOp.GetUsedCount()
|
|
, FriendInfoCache.m_cacheStructFriendOneOp.GetFreeCount());
|
|
|
|
TraceLog.Trace("FriendCacheOp.DeleteFriendCacheInfo FriendChat used {0} free {1}"
|
|
, FriendInfoCache.m_cacheStructFriendChat.GetUsedCount()
|
|
, FriendInfoCache.m_cacheStructFriendChat.GetFreeCount());
|
|
|
|
TraceLog.Trace("FriendCacheOp.DeleteFriendCacheInfo FriendOne used {0} free {1}"
|
|
, FriendInfoCache.m_cacheStructFriendOne.GetUsedCount()
|
|
, FriendInfoCache.m_cacheStructFriendOne.GetFreeCount());
|
|
|
|
//TraceLog.Trace("FriendCacheOp.DeleteFriendCacheInfo FriendStranger used {0} free {1}"
|
|
// , FriendInfoCache.m_cacheStructFriendStranger.GetUsedCount()
|
|
// , FriendInfoCache.m_cacheStructFriendStranger.GetFreeCount());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 一些辅助操作函数
|
|
public static unsafe ref DBFriendOneOpStruct GetOpStructByTypeAndTargeid(long selfUid, long Uid, int type)
|
|
{
|
|
ref FriendCacheInfoStruct info = ref GetFriendInfoByUid(selfUid);
|
|
|
|
for (int i = 0; i < info.FriendOpData.OpCount; i++)
|
|
{
|
|
ref DBFriendOneOpStruct op = ref GetFriendOpByIndex(ref info, i);
|
|
if (op.IsNull())
|
|
{
|
|
continue;
|
|
}
|
|
ref DBFriendOneStruct oneFriend = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(op.DBFriendOneID);
|
|
if (oneFriend.IsNull())
|
|
{
|
|
continue;
|
|
}
|
|
if (op.OpType == type && oneFriend.oneFriend.Uid == Uid)
|
|
{
|
|
return ref op;
|
|
}
|
|
}
|
|
return ref FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(0);
|
|
}
|
|
|
|
|
|
public static unsafe long GetFriendOpIndex(ref FriendCacheInfoStruct infoStruct, long Uid, int opType)
|
|
{
|
|
ref var aa = ref GetOpStructByTypeAndTargeid(infoStruct.Self.Uid, Uid, opType);
|
|
return aa.GetObjectID();
|
|
|
|
}
|
|
|
|
public static unsafe void UpdateSelfInfoTOFriendOne(ref DBFriendSelf self, ref DBFriendOneStruct one)
|
|
{
|
|
FriendUtils.CopySelfToFriendOne(ref self, ref one.oneFriend);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// -1: error
|
|
/// 0: 不是好友，也不在stranger里面
|
|
/// 1：是好友
|
|
/// 2：stranger里面已经有了
|
|
/// </summary>
|
|
public static unsafe int ISAlreadyBeenFriend(long self, long stranger)
|
|
{
|
|
ref FriendCacheInfoStruct selfinfo = ref GetFriendInfoByUid(self);
|
|
if (selfinfo.IsNull())
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
return IsAlreadyBeenFriend(ref selfinfo, stranger);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 0: 不是好友，也不在stranger里面
|
|
/// 1：是好友
|
|
/// 2：stranger里面已经有了
|
|
/// </summary>
|
|
public static unsafe int IsAlreadyBeenFriend(ref FriendCacheInfoStruct selfinfo, long stranger)
|
|
{
|
|
//是不是已经是好友了
|
|
for (int i = 0; i < selfinfo.FriendList.iCount; i++)
|
|
{
|
|
ref var oneStruct = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(selfinfo.FriendList.DBFriendOneID[i]);
|
|
if (! oneStruct.IsNull() && oneStruct.oneFriend.Uid == stranger)
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
//陌生人列表里面有没有
|
|
for (int i = 0; i < selfinfo.FriendOpData.StrangerCount; i++)
|
|
{
|
|
//获取陌生人
|
|
ref DBFriendStrangerOneStruct strangerOneStruct = ref FriendInfoCache.m_cacheStructFriendStranger.GetByIndex(selfinfo.FriendOpData.StrangerList[i]);
|
|
//获取陌生人指向的DBFriendOneStruct
|
|
ref var oneFriend = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(strangerOneStruct.DBFriendOneID);
|
|
if (! oneFriend.IsNull() && oneFriend.oneFriend.Uid == stranger)
|
|
{
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 是不是已经存在该好友的op操作
|
|
/// </summary>
|
|
public static unsafe bool AlreadyExistOp(ref FriendCacheInfoStruct info, long opUid, DBFriendOpType opType)
|
|
{
|
|
for (int i = 0; i < info.FriendOpData.OpCount; i++)
|
|
{
|
|
ref DBFriendOneOpStruct opStruct = ref FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(info.FriendOpData.OpList[i]);
|
|
|
|
ref var oneFriend = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(opStruct.DBFriendOneID);
|
|
if (oneFriend.IsNull())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ((oneFriend.oneFriend.Uid == opUid) && (opStruct.OpType == (int)opType))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
#endregion
|
|
|
|
#region 好友进行操作时变化缓存结构数据
|
|
/// <summary>
|
|
/// 添加好友到我的Friendlist
|
|
/// </summary>
|
|
public static unsafe int DoAddFriendOneToMySelf(ref FriendCacheInfoStruct selfInfo, long friendUid, bool isSelfSubmit)
|
|
{
|
|
for (int i = 0; i < selfInfo.FriendList.iCount; i++)
|
|
{
|
|
ref var oneStruct = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(selfInfo.FriendList.DBFriendOneID[i]);
|
|
// 已经是好友了
|
|
if (! oneStruct.IsNull() && oneStruct.oneFriend.Uid == friendUid)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// 好友列表已满
|
|
if (FriendSvc.IsFriendListFull(ref selfInfo))
|
|
{
|
|
return isSelfSubmit ? (int) CSErrCode.SelfFriendListIsFull : (int) CSErrCode.TargetFriendListIsFull;
|
|
}
|
|
|
|
long posIndex = AddFriendOneToCache(friendUid);
|
|
// 新增FriendOne失败, 预先分配的空间不够了
|
|
if (posIndex <= 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
// 赠送礼物后删除好友, 重新添加后设置赠送时间
|
|
if (selfInfo.Self.TodaySendGiftUid.Contains(friendUid))
|
|
{
|
|
ref DBFriendOneStruct friendOne = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(posIndex);
|
|
friendOne.oneFriend.LastSendGiftTime = (int)FriendServerUtils.GetTimeSecond();
|
|
}
|
|
|
|
// 加入好友列表
|
|
selfInfo.FriendList.DBFriendOneID[selfInfo.FriendList.iCount] = posIndex;
|
|
selfInfo.FriendList.iCount++;
|
|
|
|
// 检查陌生人列表, 如果有则删除
|
|
DoDeleteStranger(ref selfInfo, friendUid);
|
|
|
|
// 检查Op列表, 如果有邀请则删除
|
|
DoDeleteFriendOp(ref selfInfo, friendUid, (int)DBFriendOpType.Invite);
|
|
|
|
selfInfo.SetNeedSave(true);
|
|
return 0;
|
|
}
|
|
|
|
public static unsafe void AddOrUpdateRemoteFriendOne(ref DBFriendOne friend, ref RepeatedDBFriendHeroOne_8 heroList)
|
|
{
|
|
if (FriendInfoCache.m_remoteFriendIDMap.TryGetValue(friend.Uid, out long index))
|
|
{
|
|
ref RemoteFriendOneStruct remoteFriend = ref FriendInfoCache.m_remoteFriendOneCache.GetByIndex(index);
|
|
if (remoteFriend.IsNull())
|
|
{
|
|
FriendInfoCache.m_remoteFriendOneCache.Free(index);
|
|
FriendInfoCache.m_remoteFriendIDMap.Remove(friend.Uid);
|
|
}
|
|
else
|
|
{
|
|
// 更新数据
|
|
FriendUtils.CopyDBFriendToRemoteFriend(ref friend, ref heroList, ref remoteFriend);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (FriendInfoCache.m_remoteFriendOneCache.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("FriendOp.AddOrUpdateRemoteFriendOne FriendInfoCache.m_remoteFriendOneCache not enough space");
|
|
return;
|
|
}
|
|
|
|
FriendInfoCache.m_remoteFriendIDMap.Add(friend.Uid, FriendInfoCache.m_remoteFriendOneCache.m_freeQueue.Peek());
|
|
ref RemoteFriendOneStruct friendData = ref FriendInfoCache.m_remoteFriendOneCache.Malloc();
|
|
FriendUtils.CopyDBFriendToRemoteFriend(ref friend, ref heroList, ref friendData);
|
|
|
|
TraceLog.Debug("FriendOp.AddOrUpdateRemoteFriendOne add uid {0} succ", friend.Uid);
|
|
}
|
|
|
|
public static unsafe void AddOrUpdateRemoteFriendOne(ref DBFriendSelf self)
|
|
{
|
|
if (FriendInfoCache.m_remoteFriendIDMap.TryGetValue(self.Uid, out long index))
|
|
{
|
|
ref RemoteFriendOneStruct remoteFriend = ref FriendInfoCache.m_remoteFriendOneCache.GetByIndex(index);
|
|
if (remoteFriend.IsNull())
|
|
{
|
|
FriendInfoCache.m_remoteFriendOneCache.Free(index);
|
|
FriendInfoCache.m_remoteFriendIDMap.Remove(self.Uid);
|
|
}
|
|
else
|
|
{
|
|
FriendUtils.CopySelfToRemoteFriend(ref self, ref remoteFriend);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (FriendInfoCache.m_remoteFriendOneCache.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("FriendOp.AddOrUpdateRemoteFriendOne FriendInfoCache.m_remoteFriendOneCache not enough space");
|
|
return;
|
|
}
|
|
|
|
FriendInfoCache.m_remoteFriendIDMap.Add(self.Uid, FriendInfoCache.m_remoteFriendOneCache.m_freeQueue.Peek());
|
|
ref RemoteFriendOneStruct friendData = ref FriendInfoCache.m_remoteFriendOneCache.Malloc();
|
|
FriendUtils.CopySelfToRemoteFriend(ref self, ref friendData);
|
|
|
|
TraceLog.Debug("FriendOp.AddOrUpdateRemoteFriendOne add uid {0} succ", self.Uid);
|
|
}
|
|
|
|
public static unsafe ref RemoteFriendOneStruct GetRemoteFriendOneByUid(long uid)
|
|
{
|
|
FriendInfoCache.m_remoteFriendIDMap.TryGetValue(uid, out long posIndex);
|
|
return ref FriendInfoCache.m_remoteFriendOneCache.GetByIndex(posIndex);
|
|
}
|
|
|
|
public static void DeleteRemoteFriendOne(long uid)
|
|
{
|
|
if (FriendInfoCache.m_remoteFriendIDMap.TryGetValue(uid, out long index))
|
|
{
|
|
TraceLog.Debug("FriendOp.DeleteRemoteFriendOne uid {0}", uid);
|
|
|
|
FriendInfoCache.m_remoteFriendOneCache.Free(index);
|
|
FriendInfoCache.m_remoteFriendIDMap.Remove(uid);
|
|
}
|
|
}
|
|
|
|
public static unsafe int DoAddBlackList(ref FriendCacheInfoStruct selfInfo, long targetUid)
|
|
{
|
|
ref var blacklist = ref selfInfo.Self.BlackList;
|
|
if(blacklist.Count >= FriendConfig.GetMaxBlacklistCount())
|
|
{
|
|
return (int)CSErrCode.MaxLimitSys;
|
|
}
|
|
|
|
if(blacklist.Contains(targetUid))
|
|
{
|
|
return (int)CSErrCode.InSelfBlacklist;
|
|
}
|
|
|
|
blacklist.Add(targetUid);
|
|
return 0;
|
|
}
|
|
|
|
public static unsafe int DoDelBlackList(ref FriendCacheInfoStruct selfInfo, long targetUid)
|
|
{
|
|
ref var blacklist = ref selfInfo.Self.BlackList;
|
|
|
|
for(int i = 0; i < blacklist.Count; i++)
|
|
{
|
|
if(blacklist[i] == targetUid)
|
|
{
|
|
blacklist.RemoveAt(i);
|
|
return 0;
|
|
}
|
|
}
|
|
return (int)CSErrCode.NotBlacklist;
|
|
}
|
|
|
|
public static unsafe bool IsFriend(ref FriendCacheInfoStruct selfInfo, long friendUid)
|
|
{
|
|
for (int i = 0; i < selfInfo.FriendList.iCount; i++)
|
|
{
|
|
ref var oneStruct = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(selfInfo.FriendList.DBFriendOneID[i]);
|
|
// 已经是好友了
|
|
if (!oneStruct.IsNull() && oneStruct.oneFriend.Uid == friendUid)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
/// <summary>
|
|
/// 添加聊天信息到我的聊天记录中
|
|
/// </summary>
|
|
/// <param name="SelfUid"></param>
|
|
/// <param name="chatRes"></param>
|
|
public static unsafe long DoAddNewFriendChatToMySelf(long SelfUid, ref CSChatRes chatRes)
|
|
{
|
|
FriendInfoCache.m_selfIDMap.TryGetValue(SelfUid, out long index);
|
|
ref FriendCacheInfoStruct selfStruct = ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(index);
|
|
if (selfStruct.IsNull())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//删除第一条聊天信息
|
|
while (selfStruct.FriendOpData.ChatCount >= FriendConfig.GetChatListCountMax())
|
|
{
|
|
FriendInfoCache.m_cacheStructFriendChat.Free(selfStruct.FriendOpData.ChatList[0]);
|
|
for (int i = 1; i < selfStruct.FriendOpData.ChatCount; i++)
|
|
{
|
|
selfStruct.FriendOpData.ChatList[i - 1] = selfStruct.FriendOpData.ChatList[i];
|
|
}
|
|
selfStruct.FriendOpData.ChatCount--;
|
|
}
|
|
|
|
selfStruct.FriendOpData.LastChatSeq++;
|
|
long posIndex = AddFriendChatOneToCache(ref chatRes, selfStruct.FriendOpData.LastChatSeq);
|
|
if (posIndex > 0)
|
|
{
|
|
selfStruct.FriendOpData.ChatList[selfStruct.FriendOpData.ChatCount] = posIndex;
|
|
selfStruct.FriendOpData.ChatCount++;
|
|
}
|
|
|
|
TraceLog.Trace("DoAddNewFriendChatToMySelf uid {0} curr chatSeq {1} count {2}", selfStruct.Self.Uid
|
|
, selfStruct.FriendOpData.LastChatSeq, selfStruct.FriendOpData.ChatCount);
|
|
|
|
selfStruct.SetNeedSave(true);
|
|
return posIndex;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 好友操作,比如某人邀请我加入
|
|
/// </summary>
|
|
/// <param name="selfUid"></param>
|
|
/// <param name="opUid"></param>
|
|
/// <param name="opType"></param>
|
|
public static unsafe ref DBFriendOneOpStruct DoAddNewFriendOpToMySelf(long selfUid, long opUid, int opType)
|
|
{
|
|
ref DBFriendOneOpStruct empty = ref FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(0);
|
|
|
|
if (!FriendInfoCache.m_selfIDMap.TryGetValue(selfUid, out long index))
|
|
{
|
|
return ref empty;
|
|
}
|
|
|
|
ref FriendCacheInfoStruct infoStruct = ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(index);
|
|
|
|
if (AlreadyExistOp(ref infoStruct, opUid, (DBFriendOpType)opType))
|
|
{
|
|
return ref empty;
|
|
}
|
|
|
|
if (FriendSvc.IsFriendOpListFull(ref infoStruct))
|
|
{
|
|
return ref empty;
|
|
}
|
|
|
|
//判断操作者信息
|
|
if (!FriendInfoCache.m_selfIDMap.TryGetValue(opUid, out long opIndex))
|
|
{
|
|
return ref empty;
|
|
}
|
|
|
|
ref FriendCacheInfoStruct opInfoStruct = ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(opIndex);
|
|
if (opInfoStruct.IsNull())
|
|
{
|
|
return ref empty;
|
|
}
|
|
|
|
//生成一个op
|
|
DBFriendOneOp newOp = new DBFriendOneOp();
|
|
newOp.OpType = opType;
|
|
newOp.OpSeq = ++infoStruct.FriendOpData.LastOpSeq;
|
|
FriendUtils.CopySelfToFriendOne(ref opInfoStruct.Self, ref newOp.Friend);
|
|
|
|
//注意这个里面的一环套了一环DBFriendOne
|
|
long opPosIndex = AddFriendOneOpToCache(ref newOp);
|
|
if (opPosIndex > 0)
|
|
{
|
|
infoStruct.FriendOpData.OpList[infoStruct.FriendOpData.OpCount] = opPosIndex;
|
|
infoStruct.FriendOpData.OpCount++;
|
|
infoStruct.SetNeedSave(true);
|
|
|
|
return ref FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(opPosIndex);
|
|
}
|
|
|
|
return ref empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 将好友操作加入到我的FriendOp列表, 比如某人申请加我为好友
|
|
/// </summary>
|
|
public static unsafe int DoAddNewFriendOpToMySelf(ref FriendCacheInfoStruct selfInfo, long opUid, int opType)
|
|
{
|
|
if (AlreadyExistOp(ref selfInfo, opUid, (DBFriendOpType)opType))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (FriendSvc.IsFriendOpListFull(ref selfInfo))
|
|
{
|
|
return (int)CSErrCode.FriendOpListIsFull;
|
|
}
|
|
|
|
//注意这个里面的一环套了一环DBFriendOne
|
|
long opPosIndex = AddFriendOneOpToCache(opUid, opType, ++selfInfo.FriendOpData.LastOpSeq);
|
|
if (opPosIndex > 0)
|
|
{
|
|
selfInfo.FriendOpData.OpList[selfInfo.FriendOpData.OpCount] = opPosIndex;
|
|
selfInfo.FriendOpData.OpCount++;
|
|
selfInfo.SetNeedSave(true);
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 通过缓存中的info解析出self, friendList, opData
|
|
/// </summary>
|
|
/// <param name="friendInfo"></param>
|
|
/// <param name="self"></param>
|
|
/// <param name="friendList"></param>
|
|
/// <param name="opData"></param>
|
|
public static unsafe bool TransFriendCacheInfoStruct(ref FriendCacheInfoStruct friendInfo,
|
|
ref DBFriendSelf self, ref DBFriendList friendList, ref DBFriendOpData opData)
|
|
{
|
|
if (friendInfo.IsNull())
|
|
{
|
|
TraceLog.Error("FriendOp.TransFriendCacheInfoStruct friendCacheInfo is null");
|
|
return false;
|
|
}
|
|
|
|
//拷贝DBFriendSelf 信息
|
|
self.CopyFrom(ref friendInfo.Self);
|
|
|
|
//拷贝DBFriendList 信息
|
|
for (int i = 0; i < friendInfo.FriendList.iCount; i++)
|
|
{
|
|
ref DBFriendOneStruct one = ref GetFriendOneByIndex(ref friendInfo, i);
|
|
if (! one.IsNull())
|
|
{
|
|
friendList.AllFriends.Add(ref one.oneFriend);
|
|
}
|
|
}
|
|
|
|
//拷贝DBFriendOpData 操作信息
|
|
opData.LastOpSeq = friendInfo.FriendOpData.LastOpSeq;
|
|
for (int i = 0; i < friendInfo.FriendOpData.OpCount; i++)
|
|
{
|
|
ref DBFriendOneOpStruct one = ref GetFriendOpByIndex(ref friendInfo, i);
|
|
if (! one.IsNull())
|
|
{
|
|
DBFriendOneOp oneOp = new DBFriendOneOp();
|
|
oneOp.OpType = one.OpType;
|
|
oneOp.OpSeq = one.OpSeq;
|
|
ref DBFriendOneStruct oneFriend = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(one.DBFriendOneID);
|
|
oneOp.Friend.CopyFrom(ref oneFriend.oneFriend);
|
|
|
|
opData.OpList.Add(ref oneOp);
|
|
}
|
|
}
|
|
|
|
//拷贝DBFriendOpData 聊天信息
|
|
opData.LastChatSeq = friendInfo.FriendOpData.LastChatSeq;
|
|
for (int i = 0; i < friendInfo.FriendOpData.ChatCount; i++)
|
|
{
|
|
ref DBFriendChatOneStruct one = ref GetFriendChatByIndex(ref friendInfo, i);
|
|
if (! one.IsNull())
|
|
{
|
|
opData.ChatList.Add(ref one.oneFriendChat);
|
|
}
|
|
}
|
|
|
|
//拷贝DBFriendOpData 陌生人信息
|
|
for (int i = 0; i < friendInfo.FriendOpData.StrangerCount; i++)
|
|
{
|
|
ref DBFriendStrangerOneStruct one = ref GetFriendStrangerByIndex(ref friendInfo, i);
|
|
if (! one.IsNull())
|
|
{
|
|
DBFriendStrangerOne oneStranger = new DBFriendStrangerOne();
|
|
oneStranger.PlayTogetherCount = one.PlayTogetherCount;
|
|
oneStranger.LastUpdateTime = one.LastUpdateTime;
|
|
ref DBFriendOneStruct oneFriend = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(one.DBFriendOneID);
|
|
oneStranger.Data.CopyFrom(ref oneFriend.oneFriend);
|
|
|
|
opData.StrangerList.Add(ref oneStranger);
|
|
}
|
|
}
|
|
|
|
friendInfo.LastAccessTime = FriendServerUtils.GetTimeSecond();
|
|
return true;
|
|
}
|
|
|
|
// 从FriendInfoCache中获取FriendOpData
|
|
public static unsafe void GetOpDataFromFriendCacheInfo(long selfUid, ref DBFriendOpData opData, bool needChat)
|
|
{
|
|
if (FriendInfoCache.m_selfIDMap.TryGetValue(selfUid, out long posIndex) == false)
|
|
{
|
|
TraceLog.Error("FriendOp.GetOpDataFromFriendCacheInfo not find selfUid {0} in FriendInfoCache.m_selfIDMap", selfUid);
|
|
return ;
|
|
}
|
|
|
|
ref FriendCacheInfoStruct myInfo = ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(posIndex);
|
|
if (myInfo.IsNull())
|
|
{
|
|
TraceLog.Error("FriendOp.GetOpDataFromFriendCacheInfo not find FriendCacheInfoStruct uid {0},index {1}", selfUid, posIndex);
|
|
return ;
|
|
}
|
|
|
|
//拷贝DBFriendOpData 操作信息
|
|
opData.LastOpSeq = myInfo.FriendOpData.LastOpSeq;
|
|
for (int i = 0; i < myInfo.FriendOpData.OpCount; i++)
|
|
{
|
|
ref DBFriendOneOpStruct one = ref GetFriendOpByIndex(ref myInfo, i);
|
|
if (! one.IsNull())
|
|
{
|
|
DBFriendOneOp oneOp = new DBFriendOneOp();
|
|
oneOp.OpType = one.OpType;
|
|
oneOp.OpSeq = one.OpSeq;
|
|
ref DBFriendOneStruct oneFriend = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(one.DBFriendOneID);
|
|
oneOp.Friend.CopyFrom(ref oneFriend.oneFriend);
|
|
|
|
opData.OpList.Add(ref oneOp);
|
|
}
|
|
}
|
|
|
|
// chat要走chatsvr单独下发, 拉取好友数据时不下发
|
|
if (needChat)
|
|
{
|
|
//拷贝DBFriendOpData 聊天信息
|
|
opData.LastChatSeq = myInfo.FriendOpData.LastChatSeq;
|
|
for (int i = 0; i < myInfo.FriendOpData.ChatCount; i++)
|
|
{
|
|
ref DBFriendChatOneStruct one = ref GetFriendChatByIndex(ref myInfo, i);
|
|
if (! one.IsNull())
|
|
{
|
|
opData.ChatList.Add(ref one.oneFriendChat);
|
|
}
|
|
}
|
|
}
|
|
|
|
//拷贝DBFriendOpData 陌生人信息
|
|
for (int i = 0; i < myInfo.FriendOpData.StrangerCount; i++)
|
|
{
|
|
ref DBFriendStrangerOneStruct one = ref GetFriendStrangerByIndex(ref myInfo, i);
|
|
if (! one.IsNull())
|
|
{
|
|
DBFriendStrangerOne oneStranger = new DBFriendStrangerOne();
|
|
oneStranger.PlayTogetherCount = one.PlayTogetherCount;
|
|
oneStranger.LastUpdateTime = one.LastUpdateTime;
|
|
ref DBFriendOneStruct oneFriend = ref FriendInfoCache.m_cacheStructFriendOne.GetByIndex(one.DBFriendOneID);
|
|
oneStranger.Data.CopyFrom(ref oneFriend.oneFriend);
|
|
|
|
opData.StrangerList.Add(ref oneStranger);
|
|
}
|
|
}
|
|
|
|
myInfo.LastAccessTime = FriendServerUtils.GetTimeSecond();
|
|
}
|
|
|
|
public static unsafe void FillBlacklistInfo(ref FriendCacheInfoStruct info, ref SSQueryBlacklistRes res)
|
|
{
|
|
ref var blacklist = ref info.Self.BlackList;
|
|
for (int i = 0; i < blacklist.Count; i++)
|
|
{
|
|
if (FriendUtils.IsPlayerBelongThisServer(blacklist[i]))
|
|
{
|
|
ref FriendCacheInfoStruct friendInfo = ref FriendOp.GetFriendInfoByUid(blacklist[i]);
|
|
if (!friendInfo.IsNull())
|
|
{
|
|
DBFriendOne friendOne = new DBFriendOne();
|
|
FriendUtils.CopySelfToFriendOne(ref friendInfo.Self, ref friendOne);
|
|
res.Blacklist.Add(ref friendOne);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ref RemoteFriendOneStruct friendInfo = ref FriendOp.GetRemoteFriendOneByUid(blacklist[i]);
|
|
if (!friendInfo.IsNull())
|
|
{
|
|
DBFriendOne friendOne = new DBFriendOne();
|
|
FriendUtils.CopyRemoteFriendToDBFriend(ref friendInfo, ref friendOne);
|
|
res.Blacklist.Add(ref friendOne);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 增加一个玩家的FriendcacheInfoStruct 到内存中
|
|
/// </summary>
|
|
/// <param name="self"></param>
|
|
/// <param name="friendList"></param>
|
|
/// <param name="opData"></param>
|
|
public static unsafe ref FriendCacheInfoStruct AddFriendCacheInfoStruct(ref DBFriendSelf self,
|
|
ref DBFriendList friendList, ref DBFriendOpData opData)
|
|
{
|
|
//玩家正好自己登陆，或者有人调用好友信息
|
|
if (FriendInfoCache.m_selfIDMap.TryGetValue(self.Uid, out long index))
|
|
{
|
|
ref FriendCacheInfoStruct info = ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(index);
|
|
if (!info.IsNull())
|
|
{
|
|
return ref info;
|
|
}
|
|
|
|
// index存在但是数据不存在?
|
|
FriendInfoCache.m_cacheStructFriendInfo.Free(index);
|
|
FriendInfoCache.m_selfIDMap.Remove(self.Uid);
|
|
}
|
|
|
|
if (FriendInfoCache.m_cacheStructFriendInfo.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("FriendOp.AddFriendCacheInfoStruct FriendInfoCache.m_cacheStructFriendInfo not enough space");
|
|
return ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(0);
|
|
}
|
|
|
|
ref FriendCacheInfoStruct infoStruct = ref FriendInfoCache.m_cacheStructFriendInfo.Malloc();
|
|
|
|
// 拷贝DBFriendSelf 信息
|
|
infoStruct.Self.CopyFrom(ref self);
|
|
|
|
// 设置realm信息
|
|
if (infoStruct.Self.RealmId == 0 || infoStruct.Self.RealmName.Length == 0)
|
|
{
|
|
var player = FriendServerUtils.GetPlayerTableOp().GetPlayerInfo(self.Uid);
|
|
if (player != null)
|
|
{
|
|
if (infoStruct.Self.RealmId == 0)
|
|
{
|
|
infoStruct.Self.RealmId = player.realmId;
|
|
}
|
|
|
|
if (infoStruct.Self.RealmName.Length == 0)
|
|
{
|
|
var realm = FriendServerUtils.GetRealmBriefInfo(player.realmId);
|
|
if (realm != null)
|
|
{
|
|
infoStruct.Self.RealmName.SetString(realm.realmName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 防止运营期间修改参数, 正常情况不会出现
|
|
if (friendList.AllFriends.Count > FriendConfig.GetFriendListCountMax())
|
|
{
|
|
TraceLog.Error("FriendOp.AddFriendCacheInfoStruct uid {0} friendNum {1} > friendMax {2}"
|
|
, self.Uid, friendList.AllFriends.Count, FriendConfig.GetFriendListCountMax());
|
|
}
|
|
|
|
//拷贝DBFriendList 信息
|
|
infoStruct.FriendList.iCount = 0;
|
|
for (int i = 0; i < friendList.AllFriends.Count; i++)
|
|
{
|
|
long posIndex = AddFriendOneToCache(ref friendList.AllFriends[i]);
|
|
if (posIndex == 0)
|
|
{
|
|
TraceLog.Error("FriendOp.AddFriendCacheInfoStruct uid {0} add friendOne {1} failed"
|
|
, self.Uid, friendList.AllFriends[i].Uid);
|
|
DeleteFriendCacheInfo(ref infoStruct);
|
|
return ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(0);
|
|
}
|
|
|
|
infoStruct.FriendList.DBFriendOneID[i] = posIndex;
|
|
infoStruct.FriendList.iCount++;
|
|
}
|
|
|
|
// 防止运营期间修改参数, 正常情况不会出现
|
|
if (opData.OpList.Count > FriendConfig.GetFriendOpListCountMax())
|
|
{
|
|
TraceLog.Error("FriendOp.AddFriendCacheInfoStruct uid {0} friendOpNum {1} > friendOpMax {2}"
|
|
, self.Uid, opData.OpList.Count, FriendConfig.GetFriendOpListCountMax());
|
|
}
|
|
|
|
//拷贝DBFriendOpData 操作信息
|
|
infoStruct.FriendOpData.LastOpSeq = opData.LastOpSeq;
|
|
infoStruct.FriendOpData.OpCount = 0;
|
|
for (int i = 0; i < opData.OpList.Count; i++)
|
|
{
|
|
long posIndex = AddFriendOneOpToCache(ref opData.OpList[i]);
|
|
if (posIndex == 0)
|
|
{
|
|
TraceLog.Error("FriendOp.AddFriendCacheInfoStruct uid {0} add friendOp failed", self.Uid);
|
|
DeleteFriendCacheInfo(ref infoStruct);
|
|
return ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(0);
|
|
}
|
|
|
|
infoStruct.FriendOpData.OpList[i] = posIndex;
|
|
infoStruct.FriendOpData.OpCount++;
|
|
}
|
|
|
|
// 防止运营期间修改参数, 正常情况不会出现
|
|
if (opData.ChatList.Count > FriendConfig.GetChatListCountMax())
|
|
{
|
|
TraceLog.Error("FriendOp.AddFriendCacheInfoStruct uid {0} chatNum {1} > chatMax {2}"
|
|
, self.Uid, opData.ChatList.Count, FriendConfig.GetChatListCountMax());
|
|
}
|
|
|
|
//拷贝DBFriendOpData 聊天信息
|
|
infoStruct.FriendOpData.LastChatSeq = opData.LastChatSeq;
|
|
infoStruct.FriendOpData.ChatCount = 0;
|
|
for (int i = 0; i < opData.ChatList.Count; i++)
|
|
{
|
|
long posIndex = AddFriendChatOneToCache(ref opData.ChatList[i]);
|
|
if (posIndex == 0)
|
|
{
|
|
TraceLog.Error("FriendOp.AddFriendCacheInfoStruct uid {0} add chat failed", self.Uid);
|
|
DeleteFriendCacheInfo(ref infoStruct);
|
|
return ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(0);
|
|
}
|
|
|
|
infoStruct.FriendOpData.ChatList[i] = posIndex;
|
|
infoStruct.FriendOpData.ChatCount++;
|
|
}
|
|
|
|
// 防止运营期间修改参数, 正常情况不会出现
|
|
if (opData.StrangerList.Count > FriendConfig.GetFriendStrangerListCountMax())
|
|
{
|
|
TraceLog.Error("FriendOp.AddFriendCacheInfoStruct uid {0} strangerNum {1} > strangerMax {2}"
|
|
, self.Uid, opData.StrangerList.Count, FriendConfig.GetFriendStrangerListCountMax());
|
|
}
|
|
|
|
//拷贝DBFriendOpData 陌生人信息
|
|
infoStruct.FriendOpData.StrangerCount = 0;
|
|
for (int i = 0; i < opData.StrangerList.Count; i++)
|
|
{
|
|
long posIndex = AddFriendStrangerOneToCache(ref opData.StrangerList[i]);
|
|
if (posIndex == 0)
|
|
{
|
|
TraceLog.Error("FriendOp.AddFriendCacheInfoStruct uid {0} add stranger failed", self.Uid);
|
|
DeleteFriendCacheInfo(ref infoStruct);
|
|
return ref FriendInfoCache.m_cacheStructFriendInfo.GetByIndex(0);
|
|
}
|
|
|
|
infoStruct.FriendOpData.StrangerList[i] = posIndex;
|
|
infoStruct.FriendOpData.StrangerCount++;
|
|
}
|
|
|
|
infoStruct.LastAccessTime = FriendServerUtils.GetTimeSecond();
|
|
|
|
// 最后加入哈希表
|
|
FriendInfoCache.m_selfIDMap.Add(self.Uid, infoStruct.GetObjectID());
|
|
|
|
TraceLog.Trace("FriendOp.AddFriendCacheInfoStruct uid {0} succ", infoStruct.Self.Uid);
|
|
|
|
AlertUsedPercent();
|
|
|
|
return ref infoStruct;
|
|
}
|
|
|
|
private static void AlertUsedPercent()
|
|
{
|
|
int usedRate = FriendInfoCache.m_cacheStructFriendInfo.GetUsedPercent();
|
|
if (usedRate > 80)
|
|
{
|
|
string str = $"warning: friendInfo used {usedRate}% > 80%";
|
|
FriendServerUtils.GetApp().Alerter.AlertMsg(str, 3600);
|
|
}
|
|
|
|
usedRate = FriendInfoCache.m_cacheStructFriendOne.GetUsedPercent();
|
|
if (usedRate > 80)
|
|
{
|
|
string str = $"warning: friendOne used {usedRate}% > 80%";
|
|
FriendServerUtils.GetApp().Alerter.AlertMsg(str, 3600);
|
|
}
|
|
|
|
usedRate = FriendInfoCache.m_cacheStructFriendOneOp.GetUsedPercent();
|
|
if (usedRate > 80)
|
|
{
|
|
string str = $"warning: friendOp used {usedRate}% > 80%";
|
|
FriendServerUtils.GetApp().Alerter.AlertMsg(str, 3600);
|
|
}
|
|
|
|
usedRate = FriendInfoCache.m_cacheStructFriendChat.GetUsedPercent();
|
|
if (usedRate > 80)
|
|
{
|
|
string str = $"warning: friendChat used {usedRate}% > 80%";
|
|
FriendServerUtils.GetApp().Alerter.AlertMsg(str, 3600);
|
|
}
|
|
|
|
usedRate = FriendInfoCache.m_remoteFriendOneCache.GetUsedPercent();
|
|
if (usedRate > 80)
|
|
{
|
|
string str = $"warning: remote friendOne used {usedRate}% > 80%";
|
|
FriendServerUtils.GetApp().Alerter.AlertMsg(str, 3600);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 从数据库拉取时添加
|
|
|
|
// 该接口只是个简单封装, 调用前必须保证friendUid相关数据在FriendInfoCache.DBFriendSelf或RemoteFriendOne.DBFriendOne中
|
|
private static long AddFriendOneToCache(long friendUid)
|
|
{
|
|
if (FriendUtils.IsPlayerBelongThisServer(friendUid))
|
|
{
|
|
ref FriendCacheInfoStruct friendCache = ref GetFriendInfoByUid(friendUid);
|
|
if (! friendCache.IsNull())
|
|
{
|
|
return AddFriendOneToCache(ref friendCache.Self);
|
|
}
|
|
|
|
TraceLog.Error("AddFriendOneToCache error, local uid {0} no FriendCacheInfoStruct", friendUid);
|
|
}
|
|
else
|
|
{
|
|
ref RemoteFriendOneStruct remoteFriend = ref GetRemoteFriendOneByUid(friendUid);
|
|
if (!remoteFriend.IsNull())
|
|
{
|
|
return AddFriendOneToCache(ref remoteFriend);
|
|
}
|
|
|
|
TraceLog.Error("AddFriendOneToCache error, remote uid {0} no RemoteFriendOneStruct", friendUid);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加一个新的DBFriendOne到缓存中,返回添加后的 索引位置
|
|
/// 所有添加到缓存中的操作请通过这个接口
|
|
/// </summary>
|
|
/// <param name="oneFriend"></param>
|
|
/// <returns></returns>
|
|
private static long AddFriendOneToCache(ref DBFriendOne oneFriend)
|
|
{
|
|
//不够时操作,一旦到这里问题就大了,前面之后一定要添加目前已经使用多少缓存的警告,如果超过要及时停服维护扩充
|
|
if (FriendInfoCache.m_cacheStructFriendOne.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("AddFriendOneToCache error, m_freeQueue.Count not enough");
|
|
return 0;
|
|
}
|
|
|
|
long cacheIndex = FriendInfoCache.m_cacheStructFriendOne.m_freeQueue.Peek();
|
|
ref DBFriendOneStruct one = ref FriendInfoCache.m_cacheStructFriendOne.Malloc();
|
|
one.oneFriend.CopyFrom(ref oneFriend);
|
|
return cacheIndex;
|
|
}
|
|
|
|
private static long AddFriendOneToCache(ref DBFriendSelf self)
|
|
{
|
|
//不够时操作,一旦到这里问题就大了,前面之后一定要添加目前已经使用多少缓存的警告,如果超过要及时停服维护扩充
|
|
if (FriendInfoCache.m_cacheStructFriendOne.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("AddFriendOneToCache error, m_freeQueue.Count not enough");
|
|
return 0;
|
|
}
|
|
long cacheIndex = FriendInfoCache.m_cacheStructFriendOne.m_freeQueue.Peek();
|
|
ref DBFriendOneStruct one = ref FriendInfoCache.m_cacheStructFriendOne.Malloc();
|
|
FriendUtils.CopySelfToFriendOne(ref self, ref one.oneFriend);
|
|
return cacheIndex;
|
|
}
|
|
|
|
private static long AddFriendOneToCache(ref RemoteFriendOneStruct remoteFriend)
|
|
{
|
|
//不够时操作,一旦到这里问题就大了,前面之后一定要添加目前已经使用多少缓存的警告,如果超过要及时停服维护扩充
|
|
if (FriendInfoCache.m_cacheStructFriendOne.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("AddFriendOneToCache error, m_freeQueue.Count not enough");
|
|
return 0;
|
|
}
|
|
long cacheIndex = FriendInfoCache.m_cacheStructFriendOne.m_freeQueue.Peek();
|
|
ref DBFriendOneStruct one = ref FriendInfoCache.m_cacheStructFriendOne.Malloc();
|
|
FriendUtils.CopyRemoteFriendToDBFriend(ref remoteFriend, ref one.oneFriend);
|
|
return cacheIndex;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加一条聊天信息到缓存中
|
|
/// </summary>
|
|
/// <param name="chatone"></param>
|
|
/// <returns></returns>
|
|
private static long AddFriendChatOneToCache(ref DBFriendChatOne chatone)
|
|
{
|
|
//不够时操作,一旦到这里问题就大了,前面之后一定要添加目前已经使用多少缓存的警告,如果超过要及时停服维护扩充
|
|
if (FriendInfoCache.m_cacheStructFriendChat.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("AddFriendChatOneToCache error FriendInfoCache.m_cacheStructFriendChat.m_freeQueue.Count not enough");
|
|
return 0;
|
|
}
|
|
|
|
ref DBFriendChatOneStruct chatOneStruct = ref FriendInfoCache.m_cacheStructFriendChat.Malloc();
|
|
chatOneStruct.oneFriendChat.CopyFrom(ref chatone);
|
|
|
|
return chatOneStruct.GetObjectID();
|
|
}
|
|
|
|
private static long AddFriendChatOneToCache(ref CSChatRes chatRes, int seq)
|
|
{
|
|
//不够时操作,一旦到这里问题就大了,前面之后一定要添加目前已经使用多少缓存的警告,如果超过要及时停服维护扩充
|
|
if (FriendInfoCache.m_cacheStructFriendChat.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("AddFriendChatOneToCache error FriendInfoCache.m_cacheStructFriendChat.m_freeQueue.Count not enough");
|
|
return 0;
|
|
}
|
|
|
|
ref DBFriendChatOneStruct chatOneStruct = ref FriendInfoCache.m_cacheStructFriendChat.Malloc();
|
|
chatOneStruct.oneFriendChat.SenderUid = chatRes.Uid;
|
|
chatOneStruct.oneFriendChat.SenderNick = chatRes.Nick;
|
|
chatOneStruct.oneFriendChat.SenderIcon = chatRes.Icon;
|
|
chatOneStruct.oneFriendChat.SenderGender = chatRes.Gender;
|
|
chatOneStruct.oneFriendChat.Message = chatRes.Message;
|
|
chatOneStruct.oneFriendChat.SendTime = chatRes.SendTime;
|
|
chatOneStruct.oneFriendChat.ChatSeq = seq;
|
|
chatOneStruct.oneFriendChat.TargetUid = chatRes.TargetUid;
|
|
chatOneStruct.oneFriendChat.IconFrameId = chatRes.IconFrameId;
|
|
return chatOneStruct.GetObjectID();
|
|
}
|
|
/// <summary>
|
|
/// 添加一条操作到缓存中(注意不是添加到玩家中,返回的位置索引再关联到玩家)
|
|
/// </summary>
|
|
/// <param name="oneOp"></param>
|
|
/// <returns></returns>
|
|
private static long AddFriendOneOpToCache(ref DBFriendOneOp oneOp)
|
|
{
|
|
//不够时操作,一旦到这里问题就大了,前面之后一定要添加目前已经使用多少缓存的警告,如果超过要及时停服维护扩充
|
|
if (FriendInfoCache.m_cacheStructFriendOneOp.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("AddFriendOneOpToCache error FriendInfoCache.m_cacheStructFriendOneOp.m_freeQueue.Count not enough");
|
|
return 0;
|
|
}
|
|
//1:先判断能不能添加一个好友信息到缓存
|
|
long oneFriendindex = AddFriendOneToCache(ref oneOp.Friend);
|
|
if (oneFriendindex == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
long cacheIndex = FriendInfoCache.m_cacheStructFriendOneOp.m_freeQueue.Peek();
|
|
ref DBFriendOneOpStruct oneOpStruct = ref FriendInfoCache.m_cacheStructFriendOneOp.Malloc();
|
|
oneOpStruct.OpSeq = oneOp.OpSeq;
|
|
oneOpStruct.OpType = oneOp.OpType;
|
|
oneOpStruct.DBFriendOneID = oneFriendindex;
|
|
oneOpStruct.FriendUid = oneOp.Friend.Uid;
|
|
return cacheIndex;
|
|
}
|
|
|
|
// 调用前必须保证submit的信息在FriendCache或者RemoteFriendOne中
|
|
private static long AddFriendOneOpToCache(long submitUid, int opType, int opSeq)
|
|
{
|
|
//不够时操作,一旦到这里问题就大了,前面之后一定要添加目前已经使用多少缓存的警告,如果超过要及时停服维护扩充
|
|
if (FriendInfoCache.m_cacheStructFriendOneOp.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("AddFriendOneOpToCache error FriendInfoCache.m_cacheStructFriendOneOp not enough space");
|
|
return 0;
|
|
}
|
|
|
|
// 先判断能不能添加一个好友信息到缓存
|
|
long oneFriendindex = AddFriendOneToCache(submitUid);
|
|
if (oneFriendindex <= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
long cacheIndex = FriendInfoCache.m_cacheStructFriendOneOp.m_freeQueue.Peek();
|
|
ref DBFriendOneOpStruct oneOpStruct = ref FriendInfoCache.m_cacheStructFriendOneOp.Malloc();
|
|
oneOpStruct.OpType = opType;
|
|
oneOpStruct.OpSeq = opSeq;
|
|
oneOpStruct.DBFriendOneID = oneFriendindex;
|
|
oneOpStruct.FriendUid = submitUid;
|
|
return cacheIndex;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加一个陌生人到缓存中(注意不是添加到玩家中,返回的位置索引再关联到玩家)
|
|
/// </summary>
|
|
/// <param name="strangerOne"></param>
|
|
/// <returns></returns>
|
|
private static long AddFriendStrangerOneToCache(ref DBFriendStrangerOne strangerOne)
|
|
{
|
|
//不够时操作,一旦到这里问题就大了,前面之后一定要添加目前已经使用多少缓存的警告,如果超过要及时停服维护扩充
|
|
if (FriendInfoCache.m_cacheStructFriendStranger.m_freeQueue.Count == 0)
|
|
{
|
|
TraceLog.Error("AddFriendStrangerOneToCache error FriendInfoCache.m_cacheStructFriendStranger.m_freeQueue.Count not enough");
|
|
return 0;
|
|
}
|
|
//1:先判断能不能添加一个好友信息到缓存
|
|
long oneFriendindex = AddFriendOneToCache(ref strangerOne.Data);
|
|
if (oneFriendindex == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
long cacheIndex = FriendInfoCache.m_cacheStructFriendStranger.m_freeQueue.Peek();
|
|
ref DBFriendStrangerOneStruct oneStruct = ref FriendInfoCache.m_cacheStructFriendStranger.Malloc();
|
|
oneStruct.PlayTogetherCount = strangerOne.PlayTogetherCount;
|
|
oneStruct.LastUpdateTime = strangerOne.LastUpdateTime;
|
|
oneStruct.DBFriendOneID = oneFriendindex;
|
|
|
|
return cacheIndex;
|
|
}
|
|
#endregion
|
|
|
|
#region 释放缓存
|
|
public static void DoFreeFriendOPByIndex(long index)
|
|
{
|
|
DBFriendOneOpStruct oneOpStruct = FriendInfoCache.m_cacheStructFriendOneOp.GetByIndex(index);
|
|
if (oneOpStruct.IsNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
DoFreeFriendOneByIndex(oneOpStruct.DBFriendOneID);
|
|
|
|
FriendInfoCache.m_cacheStructFriendOneOp.Free(index);
|
|
}
|
|
|
|
|
|
private static void DoFreeStrangerByIndex(long index)
|
|
{
|
|
DBFriendStrangerOneStruct oneStruct = FriendInfoCache.m_cacheStructFriendStranger.GetByIndex(index);
|
|
if (oneStruct.IsNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
DoFreeFriendOneByIndex(oneStruct.DBFriendOneID);
|
|
|
|
FriendInfoCache.m_cacheStructFriendStranger.Free(index);
|
|
}
|
|
|
|
private static void DoFreeChatListByIndex(long index)
|
|
{
|
|
DBFriendChatOneStruct chatOneStruct = FriendInfoCache.m_cacheStructFriendChat.GetByIndex(index);
|
|
if (chatOneStruct.IsNull())
|
|
{
|
|
return;
|
|
}
|
|
FriendInfoCache.m_cacheStructFriendChat.Free(index);
|
|
}
|
|
|
|
private static void DoFreeFriendOneByIndex(long index)
|
|
{
|
|
DBFriendOneStruct one = FriendInfoCache.m_cacheStructFriendOne.GetByIndex(index);
|
|
if (one.IsNull())
|
|
{
|
|
return;
|
|
}
|
|
FriendInfoCache.m_cacheStructFriendOne.Free(index);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
|