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

✨ feat(gvg): 农庄

Browse Source
This commit is contained in:
luying
2023-01-12 20:50:36 +08:00
parent 54837f24b6
commit b2b9404684
30 changed files with 1192 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
game-server/app/services/gvg/gvgBattleService.ts Normal file
View File

@@ -0,0 +1,10 @@
import { GVGLeagueType } from "../../db/GVGLeague";
/**
* TODO 获取本联军上周占领的城池
* @param league
* @returns number[] 城池id
*/
export async function getGVGCities(league: GVGLeagueType) {
return []
}

15
game-server/app/services/gvg/gvgItemService.ts
View File

@@ -1,9 +1,8 @@
import { GVG_RETURN_ITEM_TYPE, ITEM_CHANGE_REASON, LEAGUE_ITEM_REFRESH_TYPE, PUSH_ROUTE } from "../../consts";
import { GVG_RETURN_ITEM_TYPE, ITEM_CHANGE_REASON, LEAGUE_ITEM_REFRESH_TYPE, GVG_ITEM, PUSH_ROUTE } from "../../consts";
import { GVGUserItemModel } from "../../db/GVGUserItem";
import { gameData } from "../../pubUtils/data";
import { RewardInter } from "../../pubUtils/interface";
import { DAY_TO_SECOND, getZeroPoint } from "../../pubUtils/timeUtil";
import { getFutureTime } from "../gmService";
import { DAY_TO_SECOND, getZeroPoint, getFutureTime } from "../../pubUtils/timeUtil";
import { sendMessageToUserWithSuc } from "../pushService";
import { addItems, handleCost } from "../role/rewardService";
import { getGVGConfig } from "./gvgService";
@@ -73,4 +72,14 @@ export async function handleGVGCost(roleId: string, leagueCode: string, sid: str
const decreaseResult = await GVGUserItemModel.decreaseItem(configId, leagueCode, roleId, leagueItems);
return decreaseResult;
}
export function getProduceCoinCnt(items: RewardInter[]) {
let produceCoinCnt = 0;
for(let { id, count } of items) {
if(id == GVG_ITEM.PRODUCE_COIN) {
produceCoinCnt = count; break;
}
}
return produceCoinCnt;
}

305
game-server/app/services/gvg/gvgPrepareService.ts
View File

@@ -1,12 +1,22 @@
import { GVG_ACTIVE_TYPE, ITEM_CHANGE_REASON, LEAGUE_JOB } from "../../consts";
import { Tech } from "../../db/GVGLeaguePrepare";
import { GVGUserDailyDataModel } from "../../db/GVGUserDailyData";
import { BackendSession } from "pinus";
import { GVG_ACTIVE_TYPE, GVG_ITEM, GVG_RESOURCE_TYPE, GVG_SEED_TYPE, GVG_TECH_TYPE, ITEM_CHANGE_REASON, LEAGUE_JOB } from "../../consts";
import { GVGLeagueFarmModel, GVGLeagueFarmType } from "../../db/GVGLeagueFarm";
import { GVGLeaguePrepareModel, GVGLeaguePrepareType, Tech } from "../../db/GVGLeaguePrepare";
import { GVGUserDailyDataModel, GVGUserDailyDataType } from "../../db/GVGUserDailyData";
import { GVGUserDataModel, GVGUserDataType } from "../../db/GVGUserData";
import { gameData } from "../../pubUtils/data";
import { GVGUserItemModel } from "../../db/GVGUserItem";
import { LeagueField } from "../../domain/gvgField/returnData";
import { calLeagueLv, gameData, getFieldMaxAddType } from "../../pubUtils/data";
import { GVG } from "../../pubUtils/dicParam";
import { parseGoodStr } from "../../pubUtils/util";
import { RewardInter } from "../../pubUtils/interface";
import { nowSeconds } from "../../pubUtils/timeUtil";
import { getArrayOfNumber, getRandEelm, getRandValueByMinMax, parseGoodStr, sortArrRandom } from "../../pubUtils/util";
import { addGVGReward } from "./gvgItemService";
import { getGVGConfig } from "./gvgService";
import { getProduceCoinCnt } from "./gvgItemService";
import { GVGLeagueType } from "../../db/GVGLeague";
import { getCities } from "../guildActivity/guildActivityService";
import { getGVGCities } from "./gvgBattleService";
export function checkPreTech(techId: number, activeQueue: number[], techQueue: Tech[]) {
const dicTech = gameData.gvgTech.get(techId);
@@ -41,11 +51,11 @@ export function calProduce(obj: { food: number, mineral: number, wood: number })
* @param type GVG_ACTIVE_TYPE
* @returns
*/
export async function addGVGActive(leagueCode: string, roleId: string, type: GVG_ACTIVE_TYPE) {
export async function addGVGActive(leagueCode: string, roleId: string, type: GVG_ACTIVE_TYPE, count = 1) {
let { configId } = getGVGConfig();
let add = gameData.gvgActive.get(type)||0;
let result = await GVGUserDataModel.addActive(configId, leagueCode, roleId, type, add);
let result = await GVGUserDataModel.addActive(configId, leagueCode, roleId, type, add * count);
return result.active;
}
@@ -75,4 +85,285 @@ export async function getDailyLoginReward(roleId: string, roleName: string, sid:
return { active, reward: leagueGoods }
}
return null;
}
export function getMyDistribute(userDailyData: GVGUserDailyDataType) {
return {
food: userDailyData?.food||0,
mineral: userDailyData?.mineral||0,
wood: userDailyData?.wood||0,
score: userDailyData?.score||0,
}
}
/**
* 资源
* @param leagueCode 联军id
* @param roleId 玩家id
* @param resourceType 资源类型
* @param count 数量
* @returns
*/
export async function addResource(leagueCode: string, roleId: string, resourceType: GVG_RESOURCE_TYPE, count: number) {
let { configId } = getGVGConfig();
let resources = getResourceCnt(resourceType, count);
if(!resources) return false;
let { food = 0, mineral = 0, wood = 0 } = resources;
// 联军更新资源
let league = await GVGLeaguePrepareModel.addResource(configId, leagueCode, food, mineral, wood);
// 联军升级
let lv = calLeagueLv(league.resources);
league = await GVGLeaguePrepareModel.setLv(configId, leagueCode, lv);
// 个人贡献更新
await GVGUserDataModel.addResource(configId, leagueCode, roleId, food, mineral, wood);
// 个人今日贡献更新
let userDailyData = await GVGUserDailyDataModel.addResource(configId, leagueCode, roleId, food, mineral, wood);
let myDistribute = getMyDistribute(userDailyData);
return { resource: league.resources, lv: league.lv, myDistribute }
}
function getResourceCnt(resourceType: GVG_RESOURCE_TYPE, count: number) {
switch(resourceType) {
case GVG_RESOURCE_TYPE.FOOD:
return { food: count };
case GVG_RESOURCE_TYPE.MINERAL:
return { mineral: count };
case GVG_RESOURCE_TYPE.WOOD:
return { wood: count };
}
}
export async function unlockField(leagueCode: string, roleId: string, farmId: number) {
let { configId } = getGVGConfig();
const produceCoinCnt = await getLockFieldCnt(leagueCode, roleId);
if(produceCoinCnt == 0) return
const leagueFarms = await GVGLeagueFarmModel.findByFarmId(configId, leagueCode, farmId);
// 查询现有的田
let { maxAddTypeCntMap, myAddTypeCntMap, allLands, myFieldCnt, myLockField } = calCntFromFarms(farmId, leagueFarms, roleId);
if(allLands.length <= 0 || myLockField >= produceCoinCnt) return; // 田数量不足 or 已经锁过了
let allAdd = calAddType(myFieldCnt, myAddTypeCntMap, maxAddTypeCntMap, produceCoinCnt - myLockField);
let randLand = sortArrRandom(getRandEelm(allLands, produceCoinCnt - myLockField));
let lands: { fieldId: number, addType: number }[] = [];
for(let fieldId of randLand) {
let addType = 0;
for(let [_addType, addCnt] of allAdd) {
if(addCnt > 0) {
addType = _addType;
allAdd.set(_addType, addCnt - 1);
break;
}
}
lands.push({ fieldId, addType });
}
// 更新田
let result = await GVGLeagueFarmModel.lockFields(configId, leagueCode, farmId, roleId, lands);
return await GVGLeagueFarmModel.findByFarmIdAndRoleId(configId, leagueCode, farmId, roleId);
}
function calCntFromFarms(farmId: number, leagueFarms: GVGLeagueFarmType[], roleId: string) {
let maxAddTypeCntMap = getFieldMaxAddType(farmId); // 加成田最大数量
let myAddTypeCntMap = new Map<number, number>();
let myFieldCnt = 0; // 玩家已有的田有
let myLockField = 0; // 玩家没有种只是锁住了的田
let allLands = getArrayOfNumber(gameData.gvgResource.get(farmId)?.sum??0); // 全部可使用的田
for(let leagueFarm of leagueFarms) {
// 全联军
if(leagueFarm.addType) maxAddTypeCntMap.set(leagueFarm.addType, maxAddTypeCntMap.get(leagueFarm.addType) - 1);
if(leagueFarm.unlockTime >= nowSeconds()) {
let index = allLands.indexOf(leagueFarm.fieldId);
if(index > -1) allLands.splice(index);
}
// 玩家数据
if(leagueFarm.lockRoleId == roleId && leagueFarm.unlockTime >= nowSeconds()) {
if(leagueFarm.addType) {
if(!myAddTypeCntMap.has(leagueFarm.addType)) myAddTypeCntMap.set(leagueFarm.addType, 0);
myAddTypeCntMap.set(leagueFarm.addType, myAddTypeCntMap.get(leagueFarm.addType) + 1);
}
myFieldCnt++;
if(leagueFarm.harvestTime == 0) myLockField++;
}
}
return { maxAddTypeCntMap, myAddTypeCntMap, allLands, myFieldCnt, myLockField }
}
/**
*
* @param myFieldCnt 我已种的田的数量
* @param myAddTypeCntMap 我已种的田的有加成的田分别的数量
* @param maxAddTypeCntMap 联军最多可以加成田的数量
* @param count 本次可以加的田
* @returns
*/
function calAddType(myFieldCnt: number, myAddTypeCntMap: Map<number, number>, maxAddTypeCntMap: Map<number, number>, count: number) {
let result = new Map<number, number>(); // 加成类型, 数量
let minSpField = Math.floor((myFieldCnt + count) * gameData.gvgSpFieldRatio.min / 100); // 最少需要这么多个特殊田
let maxSpField = Math.floor((myFieldCnt + count) * gameData.gvgSpFieldRatio.max / 100); // 最多可以有这么多个特殊田
let myAllAddFieldCnt = 0;
for(let [_, cnt] of myAddTypeCntMap) myAllAddFieldCnt += cnt;
if(myAllAddFieldCnt >= maxSpField) return result;
let randCnt = getRandValueByMinMax(minSpField, maxSpField);
for(let [addType, ratio] of gameData.gvgFieldAddType) { // 按比例加田
let maxCnt = maxAddTypeCntMap.get(addType)||0;
if(maxCnt == 0) continue;
let cnt = Math.ceil(randCnt * ratio / 100);
let resultCnt = maxCnt > cnt? cnt: maxCnt;
myAllAddFieldCnt += resultCnt;
maxAddTypeCntMap.set(addType, maxAddTypeCntMap.get(addType) - 1);
result.set(addType, resultCnt);
}
if(myAllAddFieldCnt < minSpField) {
for(let [addType, addCnt] of result) { // 如果还有多的塞一塞
let maxCnt = maxAddTypeCntMap.get(addType)||0;
if(maxCnt > addCnt) {
let inc = maxCnt - addCnt > minSpField - myAllAddFieldCnt? minSpField - myAllAddFieldCnt: maxCnt - addCnt;
result.set(addType, count + inc);
myAllAddFieldCnt += inc;
if(myAllAddFieldCnt >= minSpField) break;
} else {
break;
}
}
}
return result;
}
export async function rollbackUnPlantFields(cost: RewardInter[], plantResult: GVGLeagueFarmType[], session: BackendSession, leagueCode: string) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
let add: RewardInter[] = [];
for(let { id, count } of cost) add.push({ id, count });
for(let { seedType } of plantResult) {
let index = add.findIndex(({ id }) => id == getItemIdOfSeedType(seedType));
console.log('#### index', index);
if(index != -1) {
add[index].count --;
if(add[index].count <= 0) add.splice(index);
}
}
console.log('rollbackUnPlantFields', add, 'plantResult', plantResult)
await addGVGReward(roleId, roleName, leagueCode, sid, add, [], ITEM_CHANGE_REASON.PLANT_ROLLBACK);
return add;
}
// 计算实际消耗的种子
export function getCostSeedReward(plantResult: GVGLeagueFarmType[]) {
const reward: RewardInter[] = [], leagueReward: RewardInter[] = [];
for(let { seedType } of plantResult) {
let itemId = getItemIdOfSeedType(seedType);
let dicGVGItem = gameData.gvgItem.get(itemId);
if(!dicGVGItem) continue;
for(let { id, count } of dicGVGItem.reward) {
let rewardObj = reward.find(({ id }) => id == id);
rewardObj? rewardObj.count += count: reward.push({ id, count: count });
}
for(let { id, count } of dicGVGItem.leagueReward) {
let rewardObj = leagueReward.find(({ id }) => id == id);
rewardObj? rewardObj.count += count: leagueReward.push({ id, count: count });
}
}
return { reward, leagueReward }
}
export function getItemIdOfSeedType(seedType: GVG_SEED_TYPE) {
switch(seedType) {
case GVG_SEED_TYPE.WHEAT:
return GVG_ITEM.WHEAT;
case GVG_SEED_TYPE.CORN:
return GVG_ITEM.CORN;
case GVG_SEED_TYPE.RICE:
return GVG_ITEM.RICE;
}
}
export async function getLockFieldCnt(leagueCode: string, roleId: string) {
let { configId } = getGVGConfig();
const itemIds = [GVG_ITEM.WHEAT, GVG_ITEM.CORN, GVG_ITEM.RICE, GVG_ITEM.PRODUCE_COIN];
const items = await GVGUserItemModel.findByRoleAndIds(configId, leagueCode, roleId, itemIds);
return items.reduce((pre, cur) => pre + cur.count, 0);
}
export async function getmyDistributeRank(leagueCode: string, members: { roleId: string }[], targetRoleId: string) {
let { configId } = getGVGConfig();
const roleIds = members.map(member => member.roleId);
const userDatas = await GVGUserDataModel.findByRoles(configId, leagueCode, roleIds);
userDatas.sort((a, b) => calProduce(b.distribute) - calProduce(a.distribute));
for(let i = 0; i < userDatas.length; i++) {
if(userDatas[i].roleId == targetRoleId) return i + 1;
}
return 0
}
export async function getLeagueFarmShowResult(leagueCode: string, roleId: string, farmId: number, needField = true) {
let { configId } = getGVGConfig();
const leagueFarms = await GVGLeagueFarmModel.findLockedByFarmId(configId, leagueCode, farmId);
if(!needField) return { farmId, count: leagueFarms.length };
const fields = await GVGLeagueFarmModel.findByFarmIdAndRoleId(configId, leagueCode, farmId, roleId);
const result = fields.map(field => new LeagueField(field));
return { farmId, count: leagueFarms.length, fields: result }
}
export async function calFarmOutputs(myResultFields: GVGLeagueFarmType[], league: GVGLeagueType, leaguePrepare: GVGLeaguePrepareType) {
let cities = await getGVGCities(league);
let [foodSum = 0, rewardSum = new Array<RewardInter>(), leagueRewardSum = new Array<RewardInter>(), activeSum = 0] = [];
for(let { seedType, addType, farmId } of myResultFields) {
let { food, reward, leagueReward, active } = calResourceResult(seedType, addType, farmId, cities||[], leaguePrepare?.activeTech||[]);
foodSum += food;
for(let { id, count } of reward) {
let rewardObj = rewardSum.find(cur => cur.id == id);
rewardObj? rewardObj.count += count: rewardSum.push({id, count});
}
for(let { id, count } of leagueReward) {
let rewardObj = leagueRewardSum.find(cur => cur.id == id);
rewardObj? rewardObj.count += count: leagueRewardSum.push({id, count});
}
activeSum += active;
}
return { foodSum, rewardSum, leagueRewardSum, activeSum }
}
function calResourceResult(seedType: number, addType: number, farmId: number, cities: number[], activeTech: number[]) {
// 种子基础产量 * ( 1 + 格子加成 + 农庄等级加成 + 战力城池加成 + 科技树加成)
let itemId = getItemIdOfSeedType(seedType);
let dicGVGItem = gameData.gvgItem.get(itemId);
let dicFarm = gameData.gvgResource.get(farmId);
if(!dicGVGItem || !dicFarm) return {};
let { value: foodBase, reward, leagueReward, leagueConsume } = dicGVGItem;
let addRatio = seedType == addType? GVG.GVG_SP_FIELD_ADD: 0;
let farmRatio = dicFarm.fieldAdd;
let cityRatio = getCitiesAdd(cities);
let techRatio = getTechAdd(activeTech);
let produceCoin = getProduceCoinCnt(leagueConsume);
return {
food: Math.floor(foodBase * (1 + (addRatio + farmRatio + cityRatio + techRatio)/100)),
reward, leagueReward,
active: produceCoin
}
}
// TODO 城池加成，多城池取最大加成
function getCitiesAdd(cities: number[]) {
return 0
}
// 科技树加成 叠加
function getTechAdd(activeTech: number[]) {
let ratio = 0;
for(let techId of activeTech) {
let dicTech = gameData.gvgTech.get(techId);
if(dicTech.type == GVG_TECH_TYPE.PRODUCE_UP) {
ratio += dicTech.param[0];
}
}
return ratio;
}