xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

好友：赠送领取爱心

Browse Source
This commit is contained in:
luying
2021-02-03 19:12:36 +08:00
parent 0046dc2afa
commit fe85f0e247
11 changed files with 449 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
shared/consts/constModules/sysConst.ts
View File

@@ -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 {

3
shared/consts/statusCode.ts
View File

@@ -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

11
shared/db/FriendPoint.ts
View File

@@ -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;
}

10
shared/db/FriendRelation.ts
View File

@@ -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;

115
shared/db/FriendShip.ts
View File

@@ -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);

30
shared/domain/roleField/friend.ts
View File

@@ -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 = "";

141
shared/pubUtils/friendUtil.ts Normal file
View File

@@ -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;
}
}
}

8
shared/pubUtils/itemUtils.ts
View File

@@ -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};
}

2
shared/pubUtils/util.ts
View File

@@ -555,4 +555,4 @@ export function getRobotInfo() {
robotRoleName: getChineseName(),
robotRoleId: genCode(8)
}
}
}