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

✨ feat(活动): 节日活动-火神祭祀

Browse Source
This commit is contained in:
luying
2023-03-16 17:25:31 +08:00
parent f6a19fdc01
commit 04cecc2d5d
24 changed files with 566 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
game-server/app/servers/activity/handler/forgeHandler.ts Normal file
View File

@@ -0,0 +1,117 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { FIRST_GIFT_STATE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getMetialStr, getPlayerForgeData, getPlayerForgeDataShow } from '../../../services/activity/forgeService';
import { ActivityForgeModel } from '../../../db/ActivityForge';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new ForgeHandler(app);
}
export class ForgeHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getForgeActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 铸造
* @param {{ activityId: number, id: number, material: {id: number, count: number}[]}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async build(msg: { activityId: number, id: number, material: {id: number, count: number}[] }, session: BackendSession) {
const { activityId, id, material } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let materialCnt = material.reduce((pre, cur) => pre + cur.count, 0);
if(materialCnt <= 0) return resResult(STATUS.ACTIVITY_MATERIAL_COUNT_NOT_ZERO);
let manual = playerData.findManual(id);
if(!manual) return resResult(STATUS.ACTIVITY_MANUAL_NOT_FOUND);
// 解锁日期
if(manual.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_MANUAL_DAY_LOCK);
// 铸造次数
if(manual.buildCnt >= manual.freeCnt + manual.buyCnt) return resResult(STATUS.ACTIVITY_BUILD_COUNT);
// 配比是否正确
let isSuccess = manual.checkMaterial(material);
// 扣材料
let costResult = await handleCost(roleId, sid, material, ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityForgeModel.build(serverId, activityId, roleId, playerData.roundIndex, id, { todayIndex: playerData.todayIndex, isSuccess, material: getMetialStr(material) });
// 更新数据
manual.setPlayerData(buildResult, playerData.todayIndex);
let activityGoods = undefined;
if(isSuccess) {
let { goods } = await addReward(roleId, roleName, sid, serverId, stringToRewardParam(manual.reward), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
activityGoods = goods;
}
return resResult(STATUS.SUCCESS, {
isSuccess,
curManual: manual,
activityGoods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async buyCnt(msg: { activityId: number, id: number, count: number }, session: BackendSession) {
const { activityId, id, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let manual = playerData.findManual(id);
if(!manual) return resResult(STATUS.ACTIVITY_MANUAL_NOT_FOUND);
// 解锁日期
if(manual.buyCnt >= manual.maxBuyCnt) return resResult(STATUS.ACTIVITY_BUY_CNT_MAX);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.consume), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityForgeModel.buyCnt(serverId, activityId, roleId, playerData.roundIndex, id, count);
// 更新数据
manual.setPlayerData(buildResult, playerData.todayIndex);
return resResult(STATUS.SUCCESS, {
curManual: manual
});
}
}

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

@@ -76,7 +76,7 @@ export class RefreshShopHandler {
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count }));
let rewardArray = stringToRewardParam(item.reward, playerData.nextRefreshTime).map(cur => ({...cur, count: cur.count * count }));
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
await ActivityRefreshShopModel.addRecord(activityId, roleId, roundIndex, pageIndex, id, count);

4
game-server/app/servers/activity/handler/refreshTaskHandler.ts
View File

@@ -70,7 +70,7 @@ export class RefreshTaskHandler {
await ActivityRefreshTaskModel.addReceiveRecord(serverId, activityId, roleId, roundIndex, pageIndex, id, dailyItemData.getRefTime(), 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward, playerData.nextRefreshTime);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_REWARD)
//获得点数
@@ -110,7 +110,7 @@ export class RefreshTaskHandler {
await ActivityRefreshTaskPointModel.addReceiveRecord(serverId, activityId, roleId, playerData.consumePoint);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward, playerData.nextRefreshTime);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_EXCHANGE)
playerData.exchangePoint += playerData.consumePoint;

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

@@ -101,7 +101,7 @@ export class SignInHandler {
await ActivitySignInModel.addSignInRecord(activityId, roleId, roundIndex, dayIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(signinItemData.reward);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(signinItemData.reward, playerData.nextRefreshTime);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.SIGNIN)
return resResult(STATUS.SUCCESS, Object.assign(result, {

6
game-server/app/services/activity/activityService.ts
View File

@@ -41,6 +41,7 @@ import { getPopNoticeData } from './popNoticeService';
import { _getActivities, _getActivitiesByServerId, _getActivitiesByType, _getActivityById } from './activityRemoteService';
import { getGroupShopDataShow } from './groupShopService';
import { getBindPhoneDataShow } from './bindPhoneService';
import { getPlayerForgeDataShow } from './forgeService';
/**
* 获取活动数据
@@ -232,6 +233,11 @@ export async function getActivity(serverId: number, roleId: string, uid: number,
activityData = await getBindPhoneDataShow(activityId, roleId, serverId, uid);
break
}
case ACTIVITY_TYPE.FORGE:
{
activityData = await getPlayerForgeDataShow(activityId, serverId, roleId);
break
}
default: {
console.log('未知活动类型.........', activityType)
break;

42
game-server/app/services/activity/forgeService.ts Normal file
View File

@@ -0,0 +1,42 @@
import { ActivityForgeModel } from "../../db/ActivityForge";
import { ForgeData } from "../../domain/activityField/forgeField";
import { getRoleCreateTime, getServerCreateTime } from "../redisService";
import { getActivityById } from "./activityService";
/**
* 玩家活动数据
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
*
*/
export async function getPlayerForgeData(activityId: number, serverId: number, roleId: string) {
let activityData = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new ForgeData(activityData, createTime, serverTime);
let playerRecords = await ActivityForgeModel.findData(serverId, activityId, playerData.roundIndex, roleId);
playerData.setPlayerRecords(playerRecords);
return playerData;
}
/**
* 玩家活动数据
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
*
*/
export async function getPlayerForgeDataShow(activityId: number, serverId: number, roleId: string) {
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if(playerData && playerData.canShow && playerData.canShow()) {
return playerData.getShowResult();
}
return null
}
export function getMetialStr(material: { id: number, count: number }[]) {
return material.map(({id, count}) => `${id}&${count}`).join('|')
}

13
game-server/app/services/activity/giftPackageService.ts
View File

@@ -14,6 +14,7 @@ import { recordGuildFund } from './timeLimitRankService';
import { filterGoods, isGoodsHidden, isHeroHidden } from '../dataService';
import { DicGiftPackagePlan } from '../../pubUtils/dictionary/DicGiftPackagePlan';
import { Floor, GiftPackageFloorModel } from '../../db/GiftPackageFloor';
import { isNumber } from 'underscore';
@@ -127,7 +128,7 @@ export function rewardItemData(reward: Array<RewardParam>) {
heroes.push({ hid: obj.id, count: obj.count })
break;
case ACTIVITY_RESOURCES_TYPE.GOODS:
goods.push({ id: obj.id, count: obj.count })
goods.push({ id: obj.id, count: obj.count, expireTime: obj.expireTime })
break;
case ACTIVITY_RESOURCES_TYPE.GIFTPACKAGE://配置成礼包会立刻兑换，配置成物品会把礼包放入背包中
let goodData = gameData.goods.get(obj.id);//礼包物品
@@ -274,15 +275,19 @@ async function randomSelectedData(pool: DicGiftPackagePlan[], roleId: string, gi
}
//数据格式转换'类型&id&数量|类型&id&数量|' ->> Array<RewardParam> 活动奖励
export function stringToRewardParam(rewardStr: string): Array<RewardParam> {
let result = new Array<{ type: number, id: number, count: number }>();
export function stringToRewardParam(rewardStr: string, expireTime?: number): Array<RewardParam> {
let result = new Array<{ type: number, id: number, count: number, expireTime?: number }>();
if (!rewardStr) return result;
let decodeArr = decodeArrayListStr(rewardStr);
for (let [type, id, count] of decodeArr) {
if (isNaN(parseInt(type)) || isNaN(parseInt(id)) || isNaN(parseInt(count))) {
continue;
}
result.push({ type: parseInt(type), id: parseInt(id), count: parseInt(count) });
if(expireTime && isNumber(expireTime)) {
result.push({ type: parseInt(type), id: parseInt(id), count: parseInt(count), expireTime: Math.floor(expireTime/1000) });
} else {
result.push({ type: parseInt(type), id: parseInt(id), count: parseInt(count) });
}
}
return result
}

17
game-server/app/services/checkParam.ts
View File

@@ -119,6 +119,7 @@ export function checkRouteParam(route: string, msg: any) {
case 'activity.yuanbaoShopHandler.getShopActivity':
case 'activity.groupShopHandler.getGroupShopPage':
case 'activity.groupShopHandler.leaveGroupShopPage':
case 'activity.forgeHandler.getForgeActivity':
{
if(!checkNaturalNumbers(msg.activityId)) return false;
break;
@@ -425,6 +426,22 @@ export function checkRouteParam(route: string, msg: any) {
if(!checkNaturalNumbers(activityId, price, itemId, buyCnt)) return false;
break;
}
case 'activity.forgeHandler.build':
{
let { activityId, id, material } = msg;
if(!checkNaturalNumbers(activityId, id)) return false;
if(!checkNaturalArray(material)) return false;
for(let { id, count } of material) {
if(!checkNaturalNumbers(id, count)) return false
}
break;
}
case 'activity.forgeHandler.buyCnt':
{
let { activityId, id, count } = msg;
if(!checkNaturalNumbers(activityId, id, count)) return false;
break;
}
case "battle.barrageHandler.getBarrageList":
{
if(!checkNaturalStrings(msg.rid)) return false;

5
game-server/app/services/connectorService.ts
View File

@@ -8,7 +8,7 @@ import { getCurTask, getPvpTask } from './task/taskService';
import { RoleType } from '../db/Role';
import { Application, FrontendOrBackendSession, pinus, RpcClient } from 'pinus';
import { getRandEelmWithWeight, resResult } from '../pubUtils/util';
import { STATUS, PUSH_BATCH, PUSH_INTERVAL, CONSUME_TYPE, HERO_SELECT, ENTERY_ROLE_PICK, JEWEL_SELECT, ITEM_SELECT, SKIN_SELECT, PUSH_ROUTE, ARTIFACT_SELECT } from '../consts';
import { STATUS, PUSH_BATCH, PUSH_INTERVAL, CONSUME_TYPE, HERO_SELECT, ENTERY_ROLE_PICK, JEWEL_SELECT, ITEM_SELECT, SKIN_SELECT, PUSH_ROUTE, ARTIFACT_SELECT, ACTIVITYITEM_SELECT } from '../consts';
import { getAllShopList } from './shopService';
import { getGeneralRank, getRankFirstReward } from './rankService';
import { getFriendList, getApplyList } from './friendService';
@@ -51,6 +51,7 @@ import { dispatch } from '../pubUtils/dispatcher';
import { PvpDataReturn } from '../domain/battleField/pvp';
import { getHiddenData } from './dataService';
import { ArtifactModel } from '../db/Artifact';
import { ActivityItemModel } from '../db/ActivityItem';
/**
* init: 初始的时候是否推送 true-推 false-不推
@@ -125,6 +126,7 @@ export async function getModuleData(type: string, data: { role: RoleType, sessio
let items = await ItemModel.findbyRole(role.roleId, ITEM_SELECT.ENTRY);
let skins = await SkinModel.findbyRole(role.roleId, SKIN_SELECT.ENTRY);
let artifacts = await ArtifactModel.findbyRole(role.roleId, ARTIFACT_SELECT.ENTRY);
let activityItems = await ActivityItemModel.findbyRole(role.roleId, ACTIVITYITEM_SELECT.ENTRY);
role['heros'] = heros.map(hero => new HeroParam(hero));
role['jewels'] = jewels;
@@ -134,6 +136,7 @@ export async function getModuleData(type: string, data: { role: RoleType, sessio
role['apJson'] = apJson;
role['ipLocation'] = role.fixedIpLocation||role.ipLocation||'未知';
role['artifacts'] = artifacts;
role['activityItems'] = activityItems;
if (!role.showLineup) role.showLineup = role.topLineup.map(cur => cur.hid);
role.heads = role.heads.filter(cur => cur.status);

42
game-server/app/services/role/rewardService.ts
View File

@@ -23,10 +23,11 @@ import { calculateCeWithHero, calculateCeWithRole } from '../playerCeService';
import { sendMessageToUserWithSuc } from '../pushService';
import { filterGoods } from '../dataService';
import { ArtifactModel, ArtifactModelType, ArtifactModelUpdate } from '../../db/Artifact';
import { ActivityItemModel } from '../../db/ActivityItem';
export async function handleCost(roleId: string, sid: string, goods: Array<ItemInter>, reason: ITEM_CHANGE_REASON) {
let { items, jewels, gold, coin, artifacts } = sortItems(goods, HANDLE_REWARD_TYPE.COST);
let { items, jewels, gold, coin, artifacts, activityItems } = sortItems(goods, HANDLE_REWARD_TYPE.COST);
let jewelSeqIds = jewels.map(cur => cur.seqId);
let resJewels: JewelType[] = [];
let artifactSeqIds = artifacts.map(cur => cur.seqId);
@@ -59,6 +60,13 @@ export async function handleCost(roleId: string, sid: string, goods: Array<ItemI
sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ITEM_UPDATE, { goods: result.map(cur => ({...cur, reason })) }, sid);
saveItemChangeLog(roleId, result, reason);
}
//检查并修改道具
if (activityItems.length > 0) {
let { hasError, result } = await ActivityItemModel.decreaseActivityItems(roleId, activityItems);
if (hasError) return false;
sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ACTIVITY_ITEM_UPDATE, { goods: result.map(cur => ({...cur, reason })) }, sid);
saveItemChangeLog(roleId, result, reason);
}
//删除装备
if (resJewels.length > 0) {
@@ -136,8 +144,8 @@ export async function handleCost(roleId: string, sid: string, goods: Array<ItemI
export async function addItems(roleId: string, roleName: string, sid: string, goods: Array<ItemInter>, reason: ITEM_CHANGE_REASON) {
goods = filterGoods(goods, obj => obj.id, roleId, reason);
let { items, jewels, gold, coin, ap, skins, figures, artifacts } = sortItems(goods, HANDLE_REWARD_TYPE.RECEIVE);
let showItems: { id: number, seqId?: number, count: number, isBag?: boolean }[] = [];
let { items, jewels, gold, coin, ap, skins, figures, artifacts, activityItems } = sortItems(goods, HANDLE_REWARD_TYPE.RECEIVE);
let showItems: { id: number, seqId?: number, count: number, isBag?: boolean, expireTime?: number }[] = [];
let role = await RoleModel.findByRoleId(roleId);
// 1. 装备处理
if(jewels.length > 0) {
@@ -283,6 +291,19 @@ export async function addItems(roleId: string, roleName: string, sid: string, go
}
}
// 7. 活动道具处理
if(activityItems.length > 0) {
let { items: itemInfos } = await addActivityItems(roleId, roleName, activityItems, reason);
for (let item of activityItems) {
showItems.push({ id: item.id, count: item.count, expireTime: item.expireTime });
}
//背包除去装备推送
if (!!itemInfos.length) {
sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ACTIVITY_ITEM_UPDATE, { goods: itemInfos }, sid);
saveItemChangeLog(roleId, itemInfos, reason);
}
}
return showItems;
}
@@ -439,6 +460,21 @@ export async function addBag(roleId: string, roleName: string, data: { id: numbe
return { id: item.id, count: item.count, inc: count, reason };
}
export async function addActivityItems(roleId: string, roleName: string, datas: { id: number, count: number, expireTime?: number }[], reason: number) {
let items: { id: number, count: number, inc: number, expireTime: number }[] = [];
for(let data of datas) {
let item = await addActivityItem(roleId, roleName, data, reason);
items.push(item)
}
return { items }
}
export async function addActivityItem(roleId: string, roleName: string, data: { id: number, count: number, expireTime?: number }, reason: number) {
let { id, count, expireTime } = data;
let { name: itemName, itid } = gameData.goods.get(id);
let item = await ActivityItemModel.increaseActivityItem(roleId, id, count, { roleId, roleName, itemName, id, expireTime });
return { id: item.id, count: item.count, inc: count, expireTime: item.expireTime, reason };
}
export async function addJewels(roleId: string, roleName: string, jewels: { id: number, }[], reason: number) {
let jewelInfo: jewelUpdate[] = [];

10
game-server/app/services/role/util.ts
View File

@@ -12,6 +12,7 @@ export function sortItems(goods: ItemInter[], handleType: HANDLE_REWARD_TYPE) {
let ap: number = 0;
let skins: number[] = [];
let figures: number[] = [];
let activityItems: { id: number, count: number, expireTime?: number }[] = []; // 可叠加道具
for(let good of goods) {
if(good.count == 0) continue;
@@ -85,11 +86,18 @@ export function sortItems(goods: ItemInter[], handleType: HANDLE_REWARD_TYPE) {
artifacts.push({ seqId: good.seqId });
}
}
} else if (table == ITEM_TABLE.ACTIVITY_ITEM) { // 活动道具，限时，可堆叠
let index = activityItems.findIndex(cur => cur.id == good.id);
if(index >= 0) {
activityItems[index].count += good.count;
} else {
activityItems.push({ id: good.id, count: good.count, expireTime: good.expireTime });
}
}
}
return { items, jewels, gold, coin, ap, skins, figures, artifacts }
return { items, jewels, gold, coin, ap, skins, figures, artifacts, activityItems }
}
export function getGoldEventProperties(inc: number, count: number, reason: ITEM_CHANGE_REASON) {