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

活动：限时排行榜

Browse Source
This commit is contained in:
luying
2022-03-03 14:11:56 +08:00
parent d0eb46ece4
commit f099daf80b
27 changed files with 871 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
game-server/app/servers/activity/handler/activityHandler.ts
View File

@@ -42,7 +42,7 @@ export class ActivityHandler {
let activityData = await getActivityById(activityId);
if (activityData) {
let playerActivityData = await getActivity(serverId, roleId, activityId, activityData.type);
if(playerActivityData && playerActivityData.canShow && playerActivityData.canShow()) {
if(playerActivityData) {
playerGroupActivityArray.push(playerActivityData);
}
}

99
game-server/app/servers/activity/handler/timeLimitRankHandler.ts Normal file
View File

@@ -0,0 +1,99 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { DEBUG_MAGIC_WORD, getRedisKeyByRankType, HERO_SELECT, ITEM_CHANGE_REASON, RANK_TYPE, ROLE_SELECT, STATUS } from '../../../consts';
import { addItems, combineItems, handleCost } from '../../../services/rewardService';
import { ActivityTurntableModel } from '../../../db/ActivityTurntableRec';
import { pick } from 'underscore';
import { addReward, stringToRewardInter, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getTimeLimitRankData, getTimeLimitRankDataShow, sendRankMail, takeSnapshot } from '../../../services/activity/timeLimitRankService';
import { getRankInHandler, Rank } from '../../../services/rankService';
import { getActivityById } from '../../../services/activity/activityService';
import { TimeLimitRankData } from '../../../domain/activityField/timeLimitRankField';
import { hasKey } from '../../../services/redisService';
import { KeyName } from '../../../domain/rank';
export default function (app: Application) {
new HandlerService(app, {});
return new TimeLimitRankHandler(app);
}
export class TimeLimitRankHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof TimeLimitRankHandler
*/
async getTimeLimitRankData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
let playerData = await getTimeLimitRankDataShow(activityId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 获得排行榜
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof TimeLimitRankHandler
*/
async getRank(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getTimeLimitRankData(activityId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let type = playerData.rankType;
let redisKey = getRedisKeyByRankType(type, true);
let keyName = new KeyName(redisKey, { serverId, activityId });
if(!(await hasKey(keyName.getName()))) {
redisKey = getRedisKeyByRankType(type);
}
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let result = await getRankInHandler(redisKey, type, { serverId, activityId: playerData.activityId }, session);
if(!result) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, {
...pick(playerData, ['activityId', 'tabName', 'beginTime', 'endTime', 'rankEndTime', 'rankType']),
...result
});
}
async debugSendMail(msg: { magicWord: string, activityId: number }, session: BackendSession) {
const { magicWord, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let playerData = await getTimeLimitRankData(activityId);
await sendRankMail(playerData);
return resResult(STATUS.SUCCESS);
}
async debugTakeSnapshot(msg: { magicWord: string, activityId: number }, session: BackendSession) {
const { magicWord, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let activityData = await getActivityById(activityId);
let playerData = new TimeLimitRankData(activityData, 0);
if(!playerData.needSnapshot) return resResult(STATUS.WRONG_PARMS);
await takeSnapshot(playerData, activityData.groupId);
return resResult(STATUS.SUCCESS);
}
}

2
game-server/app/servers/activity/remote/activityRemote.ts
View File

@@ -72,7 +72,7 @@ export class ActivityRemote {
this.activityByType.clear();
for(let [_, activity] of this.activities) {
let servers = this.groupToServer.get(activity.activityId)||[];
let servers = this.groupToServer.get(activity.groupId)||[];
for(let serverId of servers) {
if(!this.activityByServer.has(serverId)) {
this.activityByServer.set(serverId, []);

35
game-server/app/servers/guild/handler/donateHandler.ts
View File

@@ -8,7 +8,7 @@ import { getArmyDonateBaseByLv, getArmyDonateBoxBaseById } from '../../../pubUti
import { GuildModel } from '../../../db/Guild';
import { handleCost, addItems } from '../../../services/rewardService';
import { CHAT_SERVER, GUILD_POINT_WAYS } from '../../../consts';
import { getDonation } from '../../../services/donateService';
import { addFund, getDonation } from '../../../services/donateService';
import { getUserGuildWithRefActive, refreshUserGuild } from '../../../services/guildService';
import { ARMY } from '../../../pubUtils/dicParam';
import { addActive } from '../../../services/guildService'
@@ -36,10 +36,14 @@ export class DonationHandler {
const { myUserGuild } = msg;
let userGuild = await refreshUserGuild(myUserGuild, roleId);
if (!userGuild)
if (!userGuild) return resResult(STATUS.WRONG_PARMS);
let guild = await GuildModel.findGuild(userGuild.guildCode, serverId, 'structure lv');
if(!guild) {
return resResult(STATUS.WRONG_PARMS);
}
const { guildCode: code, donateCnt, receiveBoxs } = userGuild;
let { donateFund, reports, donationLv } = await getDonation(code, serverId);
let { donateFund, reports, donationLv } = await getDonation(code, guild, serverId);
return resResult(STATUS.SUCCESS, { receiveBoxs, donateFund, reports, donateCnt: donateCnt || 0, donationLv });
}
/**
@@ -53,8 +57,8 @@ export class DonationHandler {
const roleName: string = session.get('roleName');
const serverId: number = parseInt(session.get('serverId'));
const sid: string = session.get('sid');
let res: any = await lockData(serverId, DATA_NAME.DONATE, roleId);// 玩家可能会快速做多次操作，加一下锁
const guildCode: string = session.get('guildCode');
let res: any = await lockData(serverId, DATA_NAME.DONATE, guildCode);// 锁定资金的增加
try {
if (!res) {
return resResult(STATUS.REDLOCK_ERR);
@@ -66,11 +70,18 @@ export class DonationHandler {
return resResult(STATUS.WRONG_PARMS);
}
const { guildCode: code, donateCnt: resdonateCnt } = userGuild;
let guild = await GuildModel.findGuild(code, serverId, 'structure lv');
if(!guild) {
res.releaseCallback();
return resResult(STATUS.WRONG_PARMS);
}
if (resdonateCnt >= ARMY.ARMY_DONATE_TIMES) {
res.releaseCallback();
return resResult(STATUS.GUILD_DONATE_TIMES_NOT_ENOUGH);
}
let { donationLv } = await getDonation(code, serverId);
let { donationLv } = await getDonation(code, guild, serverId);
let { donateReward } = getArmyDonateBaseByLv(donationLv);
let { rewardGood, rewardFund, cosume } = donateReward.get(id);
let result = await handleCost(roleId, sid, [cosume], ITEM_CHANGE_REASON.DONATE);
@@ -85,8 +96,8 @@ export class DonationHandler {
if (!!rewardGood)
goods = await addItems(roleId, roleName, sid, [rewardGood], ITEM_CHANGE_REASON.DONATE);
//增加基金
const { fund } = await GuildModel.updateInfo(code, {}, { fund: rewardFund }, 'fund');
this.app.rpc.chat.guildRemote.updateInfo.toServer(CHAT_SERVER, code, { fund });
await addFund(code, serverId, rewardFund);
await addActive(roleId, serverId, GUILD_POINT_WAYS.DONATE, id);
// 任务
await checkTask(roleId, sid, TASK_TYPE.GUILD_DONATE, 1, true, {});
@@ -115,10 +126,16 @@ export class DonationHandler {
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code, receiveBoxs: resReceiveBoxs } = userGuild;
let guild = await GuildModel.findGuild(code, serverId, 'structure lv');
if(!guild) {
return resResult(STATUS.WRONG_PARMS);
}
if (resReceiveBoxs.indexOf(id) != -1)
return resResult(STATUS.GUILD_DONATE_BOXS_IS_GOT);
let { boxRewards, fund, level } = getArmyDonateBoxBaseById(id);
let { donateFund, donationLv } = await getDonation(code, serverId);
let { donateFund, donationLv } = await getDonation(code, guild, serverId);
if( donationLv < level) return resResult(STATUS.GUILD_DONATE_LV_NOT_ENOUGH)
if (donateFund < fund)
return resResult(STATUS.GUILD_DONATE_BOXS_NOT_GOT);

15
game-server/app/servers/guild/handler/guildHandler.ts
View File

@@ -27,6 +27,7 @@ import { checkActivityTask, checkTask } from '../../../services/taskService';
import { guildInter } from '../../../pubUtils/interface';
import * as dicParam from '../../../pubUtils/dicParam';
import { reportTAEvent } from '../../../services/sdkService';
import { addFund } from '../../../services/donateService';
export default function (app: Application) {
@@ -932,9 +933,17 @@ export class GuildHandler {
// if (magicWord !== DEBUG_MAGIC_WORD) {
// return resResult(STATUS.TOKEN_ERR);
// }
const guild = await GuildModel.updateInfo(code, {}, { fund: count }, 'fund');
let chatSid = await getGuildChannelSid(code);
this.app.rpc.chat.guildRemote.updateInfo.toServer(chatSid, code, { fund: guild.fund });
let guild = await GuildModel.findByCode(code);
if(!guild) {
return resResult(STATUS.WRONG_PARMS);
}
guild = await addFund(code, guild.serverId, count);
if(!guild) {
return resResult(STATUS.WRONG_PARMS);
}
return resResult(STATUS.SUCCESS, { code, fund: guild.fund });
}

55
game-server/app/servers/role/handler/rankHandler.ts
View File

@@ -1,10 +1,10 @@
import { Application, BackendSession, HandlerService, pinus, } from "pinus";
import { resResult } from "../../../pubUtils/util";
import { STATUS, RANK_TYPE_TO_KEY, ROLE_SELECT, RANK_TYPE, HERO_SELECT, GUILD_SELECT, RANK_FIRST_REWARD_STATUS, ITEM_CHANGE_REASON } from "../../../consts";
import { STATUS, getRedisKeyByRankType, ROLE_SELECT, RANK_TYPE, HERO_SELECT, GUILD_SELECT, RANK_FIRST_REWARD_STATUS, ITEM_CHANGE_REASON } from "../../../consts";
import { RoleModel } from "../../../db/Role";
import { UserGuildModel } from "../../../db/UserGuild";
import { GuildModel } from "../../../db/Guild";
import { Rank, getGeneralRank, getRankFirstReward } from "../../../services/rankService";
import { Rank, getGeneralRank, getRankFirstReward, getRankInHandler } from "../../../services/rankService";
import { nowSeconds } from "../../../pubUtils/timeUtil";
import { gameData } from "../../../pubUtils/data";
import { addItems } from "../../../services/rewardService";
@@ -55,51 +55,10 @@ export class RoleHandler {
let guildCode = session.get('guildCode');
let { type } = msg;
let redisKey = RANK_TYPE_TO_KEY.get(type);
let redisKey = getRedisKeyByRankType(type);
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let r = new Rank(redisKey, { serverId });
r.setGenerFieldsFun((obj => {
let result = new RoleAndGuildRankInfo(obj.rank, obj.num);
if(obj instanceof GuildRankInfo) {
result.setGuildInfo(obj);
}
if(obj instanceof RoleRankInfo) {
result.setUserInfo(obj);
}
return result
}));
let { ranks, myRank } = await r.getRankListWithMyRank({ roleId, guildCode });
if (!myRank) {
let role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
if (type == RANK_TYPE.TOP_LINTUP) {
myRank = await r.generMyRankWithRole(roleId, role.topLineupCe, 0, role);
} else if (type == RANK_TYPE.TOP_HERO) {
let hero = await HeroModel.getMyTopHero(roleId, HERO_SELECT.RANK_LINEUP);
myRank = await r.generMyRankWithHero(roleId, hero.hid, hero.ce, 0, hero, role);
} else if (type == RANK_TYPE.HERO_NUM) {
myRank = await r.generMyRankWithRole(roleId, role.heroNum, role.heroNumUpdatedAt, role);
} else if (type == RANK_TYPE.USER_LV) {
myRank = await r.generMyRankWithRole(roleId, role.lv, role.updatedAt.getTime(), role);
} else if (type == RANK_TYPE.SUM_CE) {
myRank = await r.generMyRankWithRole(roleId, role.ce, role.updatedAt.getTime(), role);
} else if (type == RANK_TYPE.TOWER) {
myRank = await r.generMyRankWithRole(roleId, role.towerLv - 1, role.towerUpTime?.getTime() || 0, role);
// } else if (type == RANK_TYPE.DUNGEON) {
// myRank = await r.generMyRankWithRole(roleId, role.dungeonWarId, role.dungeonUpdatedAt, role);
} else if (type == RANK_TYPE.MAIN) {
myRank = await r.generMyRankWithRole(roleId, role.mainWarId, role.mainUpdatedAt, role);
} else if (type == RANK_TYPE.MAIN_ELITE) {
myRank = await r.generMyRankWithRole(roleId, role.mainEliteWarId, role.mainEliteUpdatedAt, role);
} else if (type == RANK_TYPE.GUILD_LV) {
if(role.hasGuild) {
let guild = await GuildModel.findByCode(guildCode, serverId);
myRank = await r.generMyRankWithGuild2(roleId, guild.lv, guild.activeWeekly, guild.lvUpdateTime, guild);
}
}
}
return resResult(STATUS.SUCCESS, { type, ranks, myRank });
let result = await getRankInHandler(redisKey, type, { serverId }, session);
return resResult(STATUS.SUCCESS, { type, ...result });
}
// 查看活跃排行榜
@@ -110,7 +69,7 @@ export class RoleHandler {
let { type } = msg;
let redisKey = RANK_TYPE_TO_KEY.get(type);
let redisKey = getRedisKeyByRankType(type);
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let r = new Rank(redisKey, { serverId });
@@ -134,7 +93,7 @@ export class RoleHandler {
let serverId = session.get('serverId')
let { type, hid } = msg;
let redisKey = RANK_TYPE_TO_KEY.get(type);
let redisKey = getRedisKeyByRankType(type);
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let r = new Rank(redisKey, { serverId, hid });