好友：赠送领取爱心

2021-02-03 19:12:36 +08:00
parent 0046dc2afa
commit fe85f0e247
11 changed files with 449 additions and 66 deletions
--- a/game-server/app/servers/role/handler/friendHandler.ts
+++ b/game-server/app/servers/role/handler/friendHandler.ts
@@ -1,15 +1,19 @@
 import { Application, BackendSession } from "pinus";
-import { resResult, getRandEelm, getResStr } from "../../../pubUtils/util";
+import { resResult, getRandEelm, getResStr, shouldRefresh } from "../../../pubUtils/util";
 import { STATUS, ROLE, FRIEND_DROP_TYPE, FRIEND_RELATION_TYPE, POPULATE_TYPE, BLOCK_OPEATE } from "../../../consts";
 import { RoleModel, RoleType } from "../../../db/Role";
 import { getBeforeDaySeconds } from "../../../pubUtils/timeUtil";
 import { FriendApplyModel } from "../../../db/FriendApply";
-import { FriendApplyParams, FriendListParam, FriendRecommendParams, BlackListParam } from "../../../domain/roleField/friend";
+import { FriendApplyParams, FriendListParam, FriendRecommendParams, BlackListParam, FriendValueListParam } from "../../../domain/roleField/friend";
 import { FriendShipModel, FriendShipType } from "../../../db/FriendShip";
-import { FriendRelationModel } from "../../../db/FriendRelation";
+import { FriendRelationModel, Relation } from "../../../db/FriendRelation";
 import { isRoleOnline } from "../../../services/redisService";
-import { increaseFrdCnt, getRecommendType } from "../../../services/friendService";
+import { increaseFrdCnt, getRecommendType, sortByBeSentHeart } from "../../../services/friendService";
 import { FriendPointModel } from "../../../db/FriendPoint";
+import { gameData } from "../../../pubUtils/data";
+import { addItems } from "../../../services/rewardService";
+import { getFriendPointObject } from "../../../pubUtils/itemUtils";
+

 export default function (app: Application) {
    return new FriendHandler(app);
@@ -159,7 +163,7 @@ export class FriendHandler {
                await FriendRelationModel.addFriend(roleId, friend, friendShip);
                await FriendRelationModel.addFriend(friend.roleId, role, friendShip);

-                let param = new FriendListParam(friend, friendShip);
+                let param = new FriendListParam(friend, roleId, friendShip);
                let isOnline = await isRoleOnline(friend.roleId);
                param.setOnline(isOnline);

@@ -193,21 +197,18 @@ export class FriendHandler {
            let role = <RoleType>friend.role;
            let friendShip = <FriendShipType>friend.friendShip;
            if(!role || !friendShip) continue;
-            let param = new FriendListParam(role, friendShip);
+
+            let fs = <FriendShipType>friend.friendShip;
+            let ref = shouldRefresh(fs.refTime, new Date(), 0);
+            if(ref) {
+                friendShip = await FriendShipModel.refreshSendAndReceive(roleId, role.roleId);
+            }
+
+            let param = new FriendListParam(role, roleId, friendShip);
            let isOnline = await isRoleOnline(role.roleId);
            param.setOnline(isOnline);
            
-            let frd = FriendShipModel.getRoleSendAndReceive(roleId, [roleId, role.roleId], friendShip);
-            if(!frd) continue;
-            let { sendHeart, receiveHeart, beSentHeart } = frd;
-            if(sendHeart <= 1) {
-                param.setCanSend(true);
-            }
-            if(beSentHeart >= 1 && receiveHeart < beSentHeart) {
-                param.setCanReceive(true);
-            }
            list.push(param);
-
        }

        let { friendCnt = 0, blockCnt = 0 } = role;
@@ -329,4 +330,122 @@ export class FriendHandler {
            friendCnt, blockCnt
        });
    }
+
+    // 赠送爱心/一键赠送
+    public async sendHeart(msg: { roleId: string }, session: BackendSession) {
+        let roleId: string = session.get('roleId');
+        let roleName: string = session.get('roleName');
+
+        let { roleId: hisRoleId } = msg;
+        
+        let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIENDSHIP); // 好友关系，只有friendship被populate了
+        let friends = myRelation?myRelation.friends: [];
+        let arr = new Array<Relation>();
+        if(hisRoleId != '') {
+            let cur = friends.find(cur => cur.roleId == hisRoleId);
+            if(!cur) return resResult(STATUS.FRIEND_NOT_FOUND);
+
+            arr.push(cur);
+        } else {
+            arr = friends;
+        }
+        let canSendList = sortByBeSentHeart(roleId, arr);
+    
+        let {lv} = await RoleModel.findByRoleId(roleId, ROLE.GET_LV);
+        let dicFriendLv = gameData.roleFriend.get(lv);
+        if(!dicFriendLv) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+
+        // 情谊值有上限，送到上限为止
+        let max = dicFriendLv.sendMax;
+        let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleId, FRIEND_DROP_TYPE.SEND_GIFT);
+        let { sendCnt: todaySendCnt = 0 } = frdPointRec||{};
+
+        let todaySendInc = 0;
+        let list = new Array<FriendValueListParam>();
+        for(let relation of canSendList) {
+
+            if(todaySendCnt + 1 > max) break;
+            let fs = <FriendShipType>relation.friendShip;
+            let ref = shouldRefresh(fs.refTime, new Date(), 0);
+            let sendHeartRec = await FriendShipModel.sendHeart(roleId, relation.roleId, 1, 1, ref);
+            if(!sendHeartRec) continue;
+
+            let param = new FriendValueListParam(relation.roleId, roleId, sendHeartRec);
+            list.push(param);
+
+            todaySendCnt += 1;
+            todaySendInc += 1;
+        }
+        if(todaySendInc <= 0) return resResult(STATUS.FRIEND_HAS_SENT);
+
+        // 更新情谊值
+        frdPointRec = await FriendPointModel.updateSendCntToday(roleId, roleName, todaySendInc, max, FRIEND_DROP_TYPE.SEND_GIFT); 
+
+        return resResult(STATUS.SUCCESS, {
+            todaySendCnt, list
+        })
+    }
+
+
+    // 领取爱心/一键领取
+    public async receiveHeart(msg: { roleId: string }, session: BackendSession) {
+        let roleId: string = session.get('roleId');
+        let roleName: string = session.get('roleName');
+        let sid: string = session.get('sid');
+
+        let { roleId: hisRoleId } = msg;
+        
+        let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIENDSHIP); // 好友关系，只有friendship被populate了
+        let friends = myRelation?myRelation.friends: [];
+        let arr = new Array<Relation>();
+        if(hisRoleId != '') {
+            let cur = friends.find(cur => cur.roleId == hisRoleId);
+            if(!cur) return resResult(STATUS.FRIEND_NOT_FOUND);
+
+            arr.push(cur);
+        } else {
+            arr = friends;
+        }
+        let canReceiveList = sortByBeSentHeart(roleId, arr);
+
+        let {lv} = await RoleModel.findByRoleId(roleId, ROLE.GET_LV);
+        let dicFriendLv = gameData.roleFriend.get(lv);
+        if(!dicFriendLv) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+
+        // 情谊值有上限，到上限为止
+        let max = dicFriendLv.receiveMax;
+        let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleId, FRIEND_DROP_TYPE.SEND_GIFT);
+        let { cnt: todayReceiveCnt = 0 } = frdPointRec||{};
+        
+        let todayReceiveInc = 0;
+        let list = new Array<FriendValueListParam>();
+        for(let relation of canReceiveList) {
+            if(relation.beSentHeart > 0) {
+                if(todayReceiveCnt + 1 > max) break;
+
+                // 收取爱心
+                let fs = <FriendShipType>relation.friendShip;
+                let ref = shouldRefresh(fs.refTime, new Date(), 0);
+                let receiveHeartRec = await FriendShipModel.receiveHeart(roleId, relation.roleId, 1, relation.beSentHeart, ref);
+                if(!receiveHeartRec) continue;
+    
+                let param = new FriendValueListParam(relation.roleId, roleId, receiveHeartRec);
+                list.push(param);
+    
+                todayReceiveCnt += 1;
+                todayReceiveInc += 1;
+            }
+        }
+        if(todayReceiveInc <= 0) return resResult(STATUS.FRIEND_HAS_RECEIVE);
+        let fp = getFriendPointObject(todayReceiveCnt);
+        let goods = await addItems(roleId, roleName, sid, [fp])
+
+        frdPointRec = await FriendPointModel.updatePointToday(roleId, roleName, todayReceiveInc, max, FRIEND_DROP_TYPE.SEND_GIFT); 
+
+        return resResult(STATUS.SUCCESS, {
+            goods,
+            todayReceiveCnt, list
+        })
+    }
+
 }
--- a/game-server/app/services/friendService.ts
+++ b/game-server/app/services/friendService.ts
@@ -1,8 +1,10 @@
 import { gameData } from "../pubUtils/data";
 import { RoleType, RoleModel } from "../db/Role";
-import { FriendRelationType } from "../db/FriendRelation";
+import { FriendRelationType, Relation } from "../db/FriendRelation";
 import { getResStr } from "../pubUtils/util";
 import { STATUS, FRIEND_RELATION_TYPE } from "../consts";
+import { FriendShipType } from "../db/FriendShip";
+import { outputCnt } from '../pubUtils/friendUtil';

 /**
 * 增加双方好友数
@@ -48,4 +50,41 @@ export function getRecommendType(myFriendRelation: FriendRelationType, myRoleId:
        return FRIEND_RELATION_TYPE.HAS_BLOCKED;
    }
    return FRIEND_RELATION_TYPE.NORMAL;
+}
+
+/**
+ * 根据收到的新及时间排序
+ * 
+ * @param roleId 自己的玩家id 
+ * @param list 需要排序列表
+ */
+export function sortByBeSentHeart(roleId: string, list: Relation[]) {
+
+    let result = list.map(cur => {
+        let json = getSentHeart(roleId, cur);
+        return {...cur, ...json};
+    })
+    result.sort((a, b) => {
+        if(a.beSentHeart == b.beSentHeart) {
+            return a.beSentHeartTime - b.beSentHeartTime;
+        } else {
+            return b.beSentHeart - a.beSentHeart;
+        }
+    });
+    return result
+}
+
+function getSentHeart(roleId: string, relation: Relation) {
+    let friendShip = <FriendShipType>relation.friendShip;
+    let json = outputCnt(roleId, friendShip);
+    if(!json) {
+        return {
+            beSentHeart: 0,
+            beSentHeartTime: 0
+        }
+    }
+    return {
+        beSentHeart: json.beSentHeart,
+        beSentHeartTime: json.beSentHeartTime
+    }
 }
--- a/shared/consts/constModules/sysConst.ts
+++ b/shared/consts/constModules/sysConst.ts
@@ -374,7 +374,8 @@ export enum FRIEND_RELATION_TYPE {
 export enum POPULATE_TYPE {
  NOT = 0,
  FRIEND = 1,
-  BLACKLIST = 2
+  BLACKLIST = 2,
+  FRIENDSHIP = 3
 }

 export enum BLOCK_OPEATE {
--- a/shared/consts/statusCode.ts
+++ b/shared/consts/statusCode.ts
@@ -254,6 +254,9 @@ export const STATUS = {
    FRIEND_BLACK_MAX: { code: 30707, simStr: '黑名单数量已达上限' },
    FRIEND_BLACK_NOT_FOUND: { code: 30709, simStr: '该玩家不在黑名单' },
    FRIEND_BLACK_HAS_ADD: { code: 30710, simStr: '该玩家已在黑名单' },
+    FRIEND_NOT_FOUND: { code: 30711, simStr: '未找到该好友' },
+    FRIEND_HAS_SENT: { code: 30712, simStr: '赠送达到上限' },
+    FRIEND_HAS_RECEIVE: { code: 30713, simStr: '领取达到上限' },

    // 社交相关状态 40000 - 49999
    // 运营模块相关状态 50000 - 59999
--- a/shared/db/FriendPoint.ts
+++ b/shared/db/FriendPoint.ts
@@ -28,10 +28,17 @@ export default class FriendPoint extends BaseModel {
     * @param {boolean} [lean=true]
     * @memberof FriendPoint
     */
-    public static async updatePointToday(roleId: string, roleName: string, cntInc: number, maxPerDay: number, lean = true) {
+    public static async updatePointToday(roleId: string, roleName: string, cntInc: number, maxPerDay: number, type: number, lean = true) {
        const curTime = new Date((new Date()).setHours(0, 0, 0, 0));
        // 当 oldCnt + cntInc > maxPerDay 时需计算实际可以获得的点数：cntInc - (newCnt - maxPerDay)
-        const rec: FriendPointType = await FriendPointModel.findOneAndUpdate({roleId, roleName, createdAt: {$gte: curTime}, cnt: {$lt: maxPerDay}}, {$inc: {cnt: cntInc}}, {upsert: true, new: true}).lean(lean);
+        const rec: FriendPointType = await FriendPointModel.findOneAndUpdate({roleId, roleName, createdAt: {$gte: curTime}, cnt: {$lt: maxPerDay}, type}, {$inc: {cnt: cntInc}}, {upsert: true, new: true}).lean(lean);
+        return rec;
+    }
+
+    public static async updateSendCntToday(roleId: string, roleName: string, cntInc: number, maxPerDay: number, type: number, lean = true) {
+        const curTime = new Date((new Date()).setHours(0, 0, 0, 0));
+        // 当 oldCnt + cntInc > maxPerDay 时需计算实际可以获得的点数：cntInc - (newCnt - maxPerDay)
+        const rec: FriendPointType = await FriendPointModel.findOneAndUpdate({roleId, roleName, createdAt: {$gte: curTime}, sendCnt: {$lt: maxPerDay}, type}, {$inc: {sendCnt: cntInc}}, {upsert: true, new: true}).lean(lean);
        return rec;
    }

--- a/shared/db/FriendRelation.ts
+++ b/shared/db/FriendRelation.ts
@@ -2,9 +2,9 @@ import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, mongoose, Ref } from '@typegoose/typegoose';
 import Role, { RoleType } from './Role';
 import FriendShip, { FriendShipType } from './FriendShip';
-import { ROLE } from '../consts';
+import { ROLE, POPULATE_TYPE } from '../consts';

-class Relation {
+export class Relation {
    @prop({ required: true, default: '' })
    roleId: string;     // 对方玩家id
    @prop({ required: true, ref: 'Role', type: mongoose.Schema.Types.ObjectId })
@@ -45,13 +45,15 @@ export default class FriendRelation extends BaseModel {
        let document = FriendRelationModel.findOne({ roleId })
            .lean({ getters: true, virtuals: true });

-        if (populateType == 1) {
+        if (populateType == POPULATE_TYPE.FRIEND) {
            document
                .populate('friends.role', ROLE.SHOW_SIMPLE, 'Role')
                .populate('friends.friendShip', null, 'FriendShip');
-        } else if (populateType == 2) {
+        } else if (populateType == POPULATE_TYPE.BLACKLIST) {
            document
                .populate('blacklist.role', ROLE.SHOW_SIMPLE, 'Role')
+        } else if (populateType == POPULATE_TYPE.FRIENDSHIP) {
+            document.populate('friends.friendShip', null, 'FriendShip');
        }

        let result: FriendRelationType = await document;
--- a/shared/db/FriendShip.ts
+++ b/shared/db/FriendShip.ts
@@ -1,6 +1,8 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 import { getFriendLvByExp } from '../pubUtils/data';
+import * as util from '../pubUtils/friendUtil';
+import { nowSeconds } from '../pubUtils/timeUtil';

 /**
  * 好友直接的亲密值
@@ -19,12 +21,24 @@ export default class FriendShip extends BaseModel {

    @prop({ required: true, default: 0 })
    sendHeartCntA: number;         // 玩家A给玩家B送的心
+    @prop({ required: true, default: 0 })
+    sendHeartCntATime: number;         // 玩家A给玩家B赠送时间
+
    @prop({ required: true, default: 0 })
    sendHeartCntB: number;         // 玩家B给玩家A送的心
+    @prop({ required: true, default: 0 })
+    sendHeartCntBTime: number;         // 玩家B给玩家A送的心赠送时间
+
    @prop({ required: true, default: 0 })
    receiveHeartCntA: number;      // 玩家B领取玩家A送的心
+    @prop({ required: true, default: 0 })
+    receiveHeartCntATime: number;      // 玩家B领取玩家A送的心时间
+
    @prop({ required: true, default: 0 })
    receiveHeartCntB: number;      // 玩家A领取玩家B送的心
+    @prop({ required: true, default: 0 })
+    receiveHeartCntBTime: number;      // 玩家A领取玩家B送的心时间
+
    @prop({ required: true, default: new Date() })
    refTime: Date;

@@ -35,40 +49,10 @@ export default class FriendShip extends BaseModel {
        return getFriendLvByExp(this.friendValue);
    }

-    private static getRoleIds(roleIds: string[]) {
-        roleIds.sort();
-        return {
-            roleIdA: roleIds[0],
-            roleIdB: roleIds[1],
-            roleIds: roleIds.join('|')
-        }
-    }
-
-    public static getRoleSendAndReceive(myRoleId: string, roleIds: string[], friendShip: FriendShipType) {
-        let { roleIdA, roleIdB } = this.getRoleIds(roleIds);
-        if (roleIdA == myRoleId) {
-            return {
-                sendHeart: friendShip.sendHeartCntA,
-                beSentHeart: friendShip.sendHeartCntB,
-                recieveHeart: friendShip.receiveHeartCntA,
-                beReceivedHeart: friendShip.receiveHeartCntB
-            }
-        } else if (roleIdB == myRoleId) {
-            return {
-                sendHeart: friendShip.sendHeartCntB,
-                beSentHeart: friendShip.sendHeartCntA,
-                receiveHeart: friendShip.receiveHeartCntB,
-                beReceivedHeart: friendShip.receiveHeartCntA
-            }
-        } else {
-            return false
-        }
-    }
-
    // 创建
    public static async createFriendShip(roleIdList: string[]) {
        if (roleIdList.length != 2) return false;
-        let { roleIdA, roleIdB, roleIds } = this.getRoleIds(roleIdList);
+        let { roleIdA, roleIdB, roleIds } = util.getRoleIds(roleIdList);

        const doc = new FriendShipModel();
        const update = Object.assign(doc.toJSON(), { roleIdA, roleIdB, roleIds });
@@ -81,7 +65,7 @@ export default class FriendShip extends BaseModel {
    // 清空亲密度
    public static async clearValue(roleIdList: string[]) {
        if (roleIdList.length != 2) return false;
-        let { roleIds } = this.getRoleIds(roleIdList);
+        let { roleIds } = util.getRoleIds(roleIdList);

        const result: FriendShipType = await FriendShipModel.findOneAndUpdate({ roleIds }, { $set: { friendValue: 0 } }, { new: true }).lean();
        return result;
@@ -93,6 +77,73 @@ export default class FriendShip extends BaseModel {
        return result;
    }

+    public static async refreshSendAndReceive(roleId: string, hisRoleId: string) {
+        let { roleIds } = util.getRoleIds([roleId, hisRoleId]);
+        let obj = this.getRefData();
+        const result: FriendShipType = await FriendShipModel.findOneAndUpdate({ roleIds }, { 
+            $set: { ...obj  } 
+        }, { new: true }).lean();
+        return result;
+    }
+
+    private static getRefData() {
+        return {
+            sendHeartCntA: 0, sendHeartCntB: 0, receiveHeartCntA: 0, receiveHeartCntB: 0, refTime: new Date()
+        }
+    }
+
+    // 赠送爱心
+    public static async sendHeart(roleId: string, hisRoleId: string, inc: number, max: number, shouldRefresh: boolean) {
+        let { roleIds } = util.getRoleIds([roleId, hisRoleId]);
+        let params = util.inputSendCnt(roleId, hisRoleId, { 
+            inc: { sendHeart: inc }, 
+            set: { sendHeartTime: nowSeconds() },
+            lt: { sendHeart: max - inc }
+        });
+        console.log(JSON.stringify(params))
+        if (!params) return false;
+        let result: FriendShipType;
+        if(shouldRefresh) {
+            let obj = this.getRefData();
+            result = await FriendShipModel.findOneAndUpdate({ roleIds }, {
+                $inc: { friendValue: 5}, 
+                $set: { ...obj, ...params.inc, ...params.set }
+            }, { new: true }).lean({ virtuals: true });
+        } else {
+            result = await FriendShipModel.findOneAndUpdate({ roleIds, ...params.lt }, {
+                $inc: { ...params.inc, friendValue: 5}, 
+                $set: params.set
+            }, { new: true }).lean({ virtuals: true });
+        }
+        return result;
+    }
+
+    // 领取爱心
+    public static async receiveHeart(roleId: string, hisRoleId: string, inc: number, max: number, shouldRefresh: boolean) {
+        let { roleIds } = util.getRoleIds([roleId, hisRoleId]);
+        let params = util.inputReceiveCnt(roleId, hisRoleId, { 
+            inc: { receiveHeart: inc }, 
+            set: { receiveHeartTime: nowSeconds() },
+            lt: { receiveHeart: max - inc }
+        });
+        if (!params) return false;
+
+        let result: FriendShipType;
+        if(shouldRefresh) {
+            let obj = this.getRefData();
+            result = await FriendShipModel.findOneAndUpdate({ roleIds }, {
+                $inc: { friendValue: 5}, 
+                $set: { ...obj, ...params.inc, ...params.set }
+            }, { new: true }).lean({ virtuals: true });
+        } else {
+            result = await FriendShipModel.findOneAndUpdate({ roleIds, ...params.lt }, {
+                $inc: { ...params.inc, friendValue: 5}, 
+                $set: params.set
+            }, { new: true }).lean({ virtuals: true });
+        }
+
+        return result;
+    }
 }

 export const FriendShipModel = getModelForClass(FriendShip);
--- a/shared/domain/roleField/friend.ts
+++ b/shared/domain/roleField/friend.ts
@@ -1,5 +1,7 @@
 import { RoleType } from "../../db/Role";
 import { FriendShipType } from "../../db/FriendShip";
+import * as friendUtil from '../../pubUtils/friendUtil'
+import { Relation } from "../../db/FriendRelation";

 export class FriendParams {
    roleId: string;
@@ -57,28 +59,38 @@ export class FriendListParam extends FriendParams {
    canReceive: boolean = false; // 初始没人送肯定不能领取
    canSend: boolean = true; // 初始可以赠送

-    constructor(role: RoleType, friendship: FriendShipType) {
+    constructor(role: RoleType, myRoleId: string, friendship: FriendShipType) {
        super(role);
        if(role.guildName) this.guildName = role.guildName;
        this.quitTime = role.quitTime;

        this.friendLv = friendship.friendLv;
        this.friendValue = friendship.friendValue;
+
+        friendUtil.setCanReceiveAndCanSend.bind(this, myRoleId, friendship)();
    }

    setOnline(isOnline: boolean) {
        this.isOnline = isOnline;
    }
-
-    setCanReceive(canReceive: boolean) {
-        this.canReceive = canReceive;
-    }
-
-    setCanSend(canSend: boolean) {
-        this.canSend = canSend;
-    }
 }

+export class FriendValueListParam {
+    roleId: string;
+    friendValue: number = 0;
+    friendLv: number = 1;
+    canReceive: boolean = false;
+    canSend: boolean = true;
+
+    constructor(roleId: string, myRoleId: string, friendship: FriendShipType) {
+        this.roleId = roleId;
+
+        this.friendLv = friendship.friendLv;
+        this.friendValue = friendship.friendValue;
+
+        friendUtil.setCanReceiveAndCanSend.bind(this, myRoleId, friendship)();
+    }
+}

 export class BlackListParam extends FriendParams {
    guildName: string = "";
--- a/shared/pubUtils/friendUtil.ts
+++ b/shared/pubUtils/friendUtil.ts
@@ -0,0 +1,141 @@
+import {FriendShipType} from '../db/FriendShip';
+
+export function getRoleIds(roleIds: string[]) {
+    roleIds.sort();
+    return {
+        roleIdA: roleIds[0],
+        roleIdB: roleIds[1],
+        roleIds: roleIds.join('|')
+    }
+}
+
+export function outputCnt(myRoleId: string, friendShip: FriendShipType) {
+    let roleIds = friendShip.roleIds.split('|');
+    let { roleIdA, roleIdB } = getRoleIds(roleIds);
+    if (roleIdA == myRoleId) {
+        return {
+            sendHeart: friendShip.sendHeartCntA, // 我送给他
+            sendHeartTime: friendShip.sendHeartCntATime, // 我送他时间
+            beSentHeart: friendShip.sendHeartCntB, // 他送我
+            beSentHeartTime: friendShip.sendHeartCntBTime, // 他送我时间
+            receiveHeart: friendShip.receiveHeartCntA, // 我收他
+            receiveHeartTime: friendShip.receiveHeartCntATime, // 我收他时间
+            beReceivedHeart: friendShip.receiveHeartCntB, // 他收我
+            beReceivedHeartTime: friendShip.receiveHeartCntBTime // 他收我时间
+        }
+    } else if (roleIdB == myRoleId) {
+        return {
+            sendHeart: friendShip.sendHeartCntB,
+            sendHeartTime: friendShip.sendHeartCntBTime,
+            beSentHeart: friendShip.sendHeartCntA,
+            beSentHeartTime: friendShip.sendHeartCntATime,
+            receiveHeart: friendShip.receiveHeartCntB,
+            receiveHeartTime: friendShip.receiveHeartCntBTime,
+            beReceivedHeart: friendShip.receiveHeartCntA,
+            beReceivedHeartTime: friendShip.receiveHeartCntATime
+        }
+    } else {
+        return false
+    }
+}
+
+interface InputParam {
+    inc: {
+        sendHeart?: number; // 赠送
+        receiveHeart?: number; // 收取
+    },
+    set: {
+        sendHeartTime?: number; // 赠送时间
+        receiveHeartTime?: number; // 收取时间
+    },
+    lt: {
+        sendHeart?: number; // 赠送
+        receiveHeart?: number; // 收取
+    }
+}
+
+export function inputSendCnt(myRoleId: string, hisRoleId: string, param: InputParam) {
+    let { roleIdA, roleIdB } = getRoleIds([myRoleId, hisRoleId]);
+    if(roleIdA == myRoleId) {
+        return {
+            inc: {
+                sendHeartCntA: param.inc.sendHeart,
+            },
+            set: {
+                sendHeartCntATime: param.set.sendHeartTime,
+            },
+            lt: {
+                sendHeartCntA: {
+                    $lt: param.inc.sendHeart
+                }
+            }
+        }
+    } else if (roleIdB == myRoleId) {
+        return {
+            inc: {
+                sendHeartCntB: param.inc.sendHeart
+            },
+            set: {
+                sendHeartCntBTime: param.set.sendHeartTime
+            },
+            lt: {
+                sendHeartCntB: {
+                    $lt: param.inc.sendHeart
+                }
+            }
+        }
+    } else {
+        return false;
+    }
+}
+
+export function inputReceiveCnt(myRoleId: string, hisRoleId: string, param: InputParam) {
+    let { roleIdA, roleIdB } = getRoleIds([myRoleId, hisRoleId]);
+    if(roleIdA == myRoleId) {
+        return {
+            inc: {
+                receiveHeartCntA: param.inc.receiveHeart,
+            },
+            set: {
+                receiveHeartCntATime: param.set.receiveHeartTime
+            },
+            lt: {
+                receiveHeartCntA: {
+                    $lt: param.inc.receiveHeart
+                }
+            }
+        }
+    } else if (roleIdB == myRoleId) {
+        return {
+            inc: {
+                receiveHeartCntB: param.inc.receiveHeart,
+            },
+            set: {
+                receiveHeartCntBTime: param.set.receiveHeartTime
+            },
+            lt: {
+                receiveHeartCntB: {
+                    $lt: param.inc.receiveHeart
+                }
+            }
+        }
+    } else {
+        return false;
+    }
+}
+
+
+export function setCanReceiveAndCanSend(this: any, roleId: string, friendship: FriendShipType) {
+
+    let frd = outputCnt(roleId, friendship);
+    if(frd) {
+        let { sendHeart, receiveHeart, beSentHeart } = frd;
+        console.log('***',sendHeart, receiveHeart, beSentHeart)
+        if(sendHeart >= 1) {
+            this.canSend = false;
+        }
+        if(beSentHeart >= 1 && receiveHeart < beSentHeart) {
+            this.canReceive = true;
+        }
+    }
+}
--- a/shared/pubUtils/itemUtils.ts
+++ b/shared/pubUtils/itemUtils.ts
@@ -66,4 +66,12 @@ export async function addEquips(roleId: string, roleName: string, weapon: EquipI
 */
 export function getGoldObject(count: number) {
    return { id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count};
+}
+
+/**
+ * @description 获取友情点物品 { id, count }
+ * @param count 友情点数量
+ */
+export function getFriendPointObject(count: number) {
+    return { id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.FRIEND_POINT), count};
 }
--- a/shared/pubUtils/util.ts
+++ b/shared/pubUtils/util.ts
@@ -555,4 +555,4 @@ export function getRobotInfo() {
        robotRoleName: getChineseName(),
        robotRoleId: genCode(8)
    }
-}
+}