✨ feat(gvg): 农庄

2023-01-12 20:50:36 +08:00
parent 54837f24b6
commit b2b9404684
30 changed files with 1192 additions and 104 deletions
--- a/game-server/app/servers/gm/handler/gmServerHandler.ts
+++ b/game-server/app/servers/gm/handler/gmServerHandler.ts
@@ -5,8 +5,8 @@ import { UpdateHiddenDataParam, CreatePvpConfigParam, CreateServerParam, UpdateR
 import { RegionModel, RegionType } from '../../../db/Region';
 import { gameData } from '../../../pubUtils/data';
 import { Maintenance, ServerlistModel, ServerlistUpdate } from '../../../db/Serverlist';
-import { nowSeconds } from '../../../pubUtils/timeUtil';
-import { calHiddenData, createNewServer, getFutureTime, getPastTime } from '../../../services/gmService';
+import { nowSeconds, getFutureTime, getPastTime } from '../../../pubUtils/timeUtil';
+import { calHiddenData, createNewServer } from '../../../services/gmService';
 import { isNumber } from 'util';
 import { MarqueeModel } from '../../../db/Marquee';
 import { setApiIsCloseToRemote } from '../../../services/chatService';
--- a/game-server/app/servers/guild/handler/gvgHandler.ts
+++ b/game-server/app/servers/guild/handler/gvgHandler.ts
@@ -1,5 +1,5 @@
 import { Application, BackendSession, ChannelService, HandlerService, pinus } from "pinus";
-import { BATTLE_FEAT_ID, DATA_NAME, GVG_ACTIVE_TYPE, GVG_PERIOD, GVG_SERVER_TYPE, ITEM_CHANGE_REASON, LEAGUE_JOB, LEAGUE_MANAGE_TYPE, STATUS } from "../../../consts";
+import { GVG_ITEM, DATA_NAME, GVG_ACTIVE_TYPE, GVG_PERIOD, GVG_SERVER_TYPE, ITEM_CHANGE_REASON, LEAGUE_JOB, LEAGUE_MANAGE_TYPE, STATUS } from "../../../consts";
 import { GVGLeagueModel } from "../../../db/GVGLeague";
 import { GVGLeaguePrepareModel } from "../../../db/GVGLeaguePrepare";
 import { GVGMainData, LeagueDistributeInfo, LeagueMemberDistributeInfo, LeagueMemberListInfo } from "../../../domain/gvgField/returnData";
@@ -12,13 +12,13 @@ import { GVGUserItemModel } from "../../../db/GVGUserItem";
 import { GVGUserTaskModel } from "../../../db/GVGUserTask";
 import { GVG } from "../../../pubUtils/dicParam";
 import { RoleModel } from "../../../db/Role";
-import { addGVGActive, addGVGTechActive, calProduce, checkPreTech, checkTechIsIng, getDailyLoginReward, getGVGDailyItems } from "../../../services/gvg/gvgPrepareService";
+import { addGVGTechActive, calProduce, checkPreTech, checkTechIsIng, getDailyLoginReward, getMyDistribute } from "../../../services/gvg/gvgPrepareService";
 import { GVGUserDailyDataModel } from "../../../db/GVGUserDailyData";
 import { gameData } from "../../../pubUtils/data";
 import { lockLeagueData } from "../../../services/redLockService";
 import { addGVGReward, handleGVGCost } from "../../../services/gvg/gvgItemService";
 import { RewardInter } from "../../../pubUtils/interface";
-import { GuildModel } from "../../../db/Guild";
+import { getGVGCities } from "../../../services/gvg/gvgBattleService";

 export default function (app: Application) {
    new HandlerService(app, {});
@@ -61,10 +61,13 @@ export class GVGHandler {
            let tasks = await GVGUserTaskModel.findByRole(configId, league.leagueCode, roleId);
            data.setPlayerInfo(userData, getMyAuth(league, roleId), await checkCanPrepare(roleId), checkCanChooseJob(userData?.job, leaguePrepare), items, tasks);

-            let { reward: dailyReward } = await getDailyLoginReward(roleId, roleName, sid, league.leagueCode, userData?.job);
-            if(dailyReward) data.setFistLogin(dailyReward);
+            let dailyReward = await getDailyLoginReward(roleId, roleName, sid, league.leagueCode, userData?.job);
+            if(dailyReward) data.setFistLogin(dailyReward.reward);

            data.setLeagueCe(await calLeagueCe(league));
+
+            let cities = await getGVGCities(league);
+            data.setCities(cities);
        }

        return resResult(STATUS.SUCCESS, data)
@@ -107,14 +110,14 @@ export class GVGHandler {
        myUserData = await GVGUserDataModel.chooseJob(configId, myLeague.leagueCode, roleId, job);
        // 更新prepare
        leaguePrepare = await GVGLeaguePrepareModel.chooseJob(configId, myLeague.leagueCode, job);
-        let { reward: dailyReward } = await getDailyLoginReward(roleId, roleName, sid, myLeague.leagueCode, myUserData?.job);
+        let dailyReward = await getDailyLoginReward(roleId, roleName, sid, myLeague.leagueCode, myUserData?.job);

        return resResult(STATUS.SUCCESS, {
            leagueCode: myLeague.leagueCode,
            job: myUserData.job,
            producerCnt: leaguePrepare.producerCnt,
            fighterCnt: leaguePrepare.fighterCnt,
-            leagueGoods: dailyReward? dailyReward: []
+            leagueGoods: dailyReward? dailyReward.reward: []
         });
    }

@@ -161,15 +164,10 @@ export class GVGHandler {
            result.push(disObj)
        }

-        const myDistribute = await GVGUserDailyDataModel.findByRole(configId, myLeague.leagueCode, roleId);
+        const userDailyData = await GVGUserDailyDataModel.findByRole(configId, myLeague.leagueCode, roleId);

        return resResult(STATUS.SUCCESS, {
-            myDistribute: {
-                food: myDistribute?.food||0,
-                mineral: myDistribute?.mineral||0,
-                wood: myDistribute?.wood||0,
-                score: myDistribute?.score||0,
-            },
+            myDistribute: getMyDistribute(userDailyData),
            list: result
         });
    }
@@ -269,7 +267,7 @@ export class GVGHandler {
        }

        // 扣战功
-        const costResult = await handleGVGCost(roleId, myLeague.leagueCode, sid, [{ id: BATTLE_FEAT_ID, count: battleFeats }], [], ITEM_CHANGE_REASON.GVG_ACTIVE_TECH);
+        const costResult = await handleGVGCost(roleId, myLeague.leagueCode, sid, [{ id: GVG_ITEM.BATTLE_FEAT, count: battleFeats }], [], ITEM_CHANGE_REASON.GVG_ACTIVE_TECH);
        if(!costResult) return resResult(STATUS.GVG_BATTLE_FEAT_NOT_ENOUGH);

        leaguePrepare = await GVGLeaguePrepareModel.addProgress(configId, myLeague.leagueCode, techId, battleFeats);
--- a/game-server/app/servers/guild/handler/gvgManageHandler.ts
+++ b/game-server/app/servers/guild/handler/gvgManageHandler.ts
@@ -5,7 +5,7 @@ import { GuildModel, GuildType } from "../../../db/Guild";
 import { UserGuildModel } from "../../../db/UserGuild";
 import { GVGLeagueModel, GVGLeagueType } from "../../../db/GVGLeague";
 import { GVGLeagueApplyModel } from "../../../db/GVGLeagueApply";
-import { calLeagueCe, getGroupIdOfServer, getGVGPeriodData, getGVGServerType, getServersOfSameGroup } from "../../../services/gvg/gvgService";
+import { calLeagueCe, getGroupIdOfServer, getGVGConfig, getGVGPeriodData, getGVGServerType, getServersOfSameGroup } from "../../../services/gvg/gvgService";
 import { checkCanManage, checkGuildLeader, checkLeagueAuth, createLeague, getLeagueApplyData, getLeagueInviteData, getMyAuth, joinGuildToLeague } from "../../../services/gvg/gvgTeamService";
 import { LeagueGuildInfo, LeagueListInfo, LeagueMemberListInfo, LeagueSimpleInfo } from "../../../domain/gvgField/returnData";
 import { getAllServerName, getServerName } from "../../../services/redisService";
@@ -16,6 +16,7 @@ import { sendMessageToGuildWithSuc, sendMessageToUserWithSuc } from "../../../se
 import { GVGLeaguePrepareModel } from "../../../db/GVGLeaguePrepare";
 import { createGroupMsg, pushGroupMsgToRoom } from "../../../services/chatService";
 import { sendMailToGuildByContent } from "../../../services/mailService";
+import { getGVGCities } from "../../../services/gvg/gvgBattleService";

 export default function (app: Application) {
    new HandlerService(app, {});
@@ -94,6 +95,9 @@ export class GVGManageHandler {
        result.setHasApply(hasApply);

        // TODO 占领城池
+        const cities = await getGVGCities(league);
+        result.setCities(cities);
+        
        return resResult(STATUS.SUCCESS, {
            league: result
        } );
@@ -323,7 +327,7 @@ export class GVGManageHandler {
        const league = await GVGLeagueModel.findByCode(targetLeagueCode);
        if(!league) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);

-        let { configId } = getGVGPeriodData();
+        let { configId } = getGVGConfig();
        const guilds = await GuildModel.findByCodes(league.guildCodes);
        const members = league.members||[];
        let roleIds = members.map(member => member.roleId);
@@ -355,7 +359,7 @@ export class GVGManageHandler {
        const league = await GVGLeagueModel.findByCode(targetLeagueCode);
        if(!league) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);

-        let { configId } = getGVGPeriodData();
+        let { configId } = getGVGConfig();

        const members = league.members||[];
        let roleIds = members.map(member => member.roleId);
@@ -499,7 +503,7 @@ export class GVGManageHandler {
        const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.ABDICATE);
        if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);

-        let { configId } = getGVGPeriodData();
+        let { configId } = getGVGConfig();

        const members = myLeague.members||[];
        const candidates = members.filter(cur => cur.auth == LEAGUE_AUTH.SUB_LEADER);
--- a/game-server/app/servers/guild/handler/gvgProduceHandler.ts
+++ b/game-server/app/servers/guild/handler/gvgProduceHandler.ts
@@ -0,0 +1,296 @@
+import { Application, BackendSession, ChannelService, HandlerService } from "pinus";
+import { GVG_ACTIVE_TYPE, GVG_ITEM, GVG_ITEM_TYPE, GVG_PERIOD, GVG_RESOURCE_TYPE, ITEM_CHANGE_REASON, MAIL_TYPE, STATUS } from "../../../consts";
+import { GVGLeagueModel } from "../../../db/GVGLeague";
+import { GVGLeagueFarmModel, GVGLeagueFarmType } from "../../../db/GVGLeagueFarm";
+import { GVGLeaguePrepareModel } from "../../../db/GVGLeaguePrepare";
+import { RoleModel } from "../../../db/Role";
+import { LeagueFarmListInfo, LeagueFarmMember, LeagueField } from "../../../domain/gvgField/returnData";
+import { gameData, getGVGResourceBasesByType } from "../../../pubUtils/data";
+import { ItemInter, RewardInter } from "../../../pubUtils/interface";
+import { nowSeconds } from "../../../pubUtils/timeUtil";
+import { resResult } from "../../../pubUtils/util";
+import { addGVGReward, getProduceCoinCnt, handleGVGCost } from "../../../services/gvg/gvgItemService";
+import { addGVGActive, addResource, calFarmOutputs, getCostSeedReward, getItemIdOfSeedType, getLeagueFarmShowResult, getLockFieldCnt, getmyDistributeRank, rollbackUnPlantFields, unlockField } from "../../../services/gvg/gvgPrepareService";
+import { getGVGConfig, getGVGPeriodData } from "../../../services/gvg/gvgService";
+import { sendMailByContent } from "../../../services/mailService";
+import { getAllServerName, getRoleOnlineInfo } from "../../../services/redisService";
+
+
+export default function (app: Application) {
+    new HandlerService(app, {});
+    return new GVGProduceHandler(app);
+}
+
+export class GVGProduceHandler {
+    channelService: ChannelService;
+    constructor(private app: Application) {
+        this.channelService = app.get('channelService');
+    }
+
+    // 内政令兑换
+    async exchangeItem(msg: { id: number, count: number }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const roleName = session.get('roleName');
+        const sid = session.get('sid');
+        const guildCode = session.get('guildCode');
+        const { id, count } = msg;
+
+        const dicGVGItem = gameData.gvgItem.get(id);
+        if(!dicGVGItem) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+        if(dicGVGItem.type != GVG_ITEM_TYPE.SEED && dicGVGItem.type != GVG_ITEM_TYPE.SCOOP && dicGVGItem.type != GVG_ITEM_TYPE.AXE) {
+            return resResult(STATUS.GVG_ITEMS_NOT_PRODUCE);
+        }
+
+        const myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
+        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
+
+        const leagueItems = dicGVGItem.leagueConsume.map(cur => ({ id: cur.id, count: cur.count * count }));
+        const items = dicGVGItem.consume.map(cur => ({ id: cur.id, count: cur.count * count }));
+
+        const costResult = await handleGVGCost(roleId, myLeague.leagueCode, sid, leagueItems, items, ITEM_CHANGE_REASON.GVG_EXCHANGE_SEEDS);
+        if(!costResult) return resResult(STATUS.GVG_ITEMS_NOT_ENOUGH);
+
+        const leagueGoods = await addGVGReward(roleId, roleName, myLeague.leagueCode, sid, [{ id, count }], [], ITEM_CHANGE_REASON.GVG_EXCHANGE_SEEDS);
+
+        return resResult(STATUS.SUCCESS, {
+            leagueGoods
+        });
+    }
+
+    // 获取农场/矿山/林场状态
+    async getProduceList(msg: { type: number }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const guildCode = session.get('guildCode');
+
+        const { type } = msg;
+
+        let { configId, period } = getGVGPeriodData();
+        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);
+
+        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
+        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
+
+        const leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, myLeague.leagueCode);
+        const leagueLv = leaguePrepare?.lv||0;
+
+        const leagueFarms = await GVGLeagueFarmModel.findByType(configId, myLeague.leagueCode, type);
+
+        const dicFarms = getGVGResourceBasesByType(type);
+        const result: LeagueFarmListInfo[] = [];
+        for(let { id, lv } of dicFarms) {
+            if(lv > leagueLv) continue;
+            const leagueFarm = leagueFarms.filter(cur => cur.farmId == id && cur.unlockTime >= nowSeconds()); // 已种植单位
+            const canHarvestFarms = leagueFarms.filter(cur => cur.farmId == id && cur.lockRoleId == roleId && cur.harvestTime > 0 && cur.harvestTime <= nowSeconds());
+            let obj = new LeagueFarmListInfo(id, leagueFarm.length, canHarvestFarms.length > 0);
+            result.push(obj);
+        }
+
+        return resResult(STATUS.SUCCESS, {
+            type,
+            list: result
+        });
+    }
+
+    // 不能进的农场，获取其他人的状态
+    async getOtherFarms(msg: { farmId: number }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const guildCode = session.get('guildCode');
+        const { farmId } = msg;
+
+        let { configId, period } = getGVGPeriodData();
+        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);
+
+        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
+        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
+
+        const leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, myLeague.leagueCode);
+
+        const fields = await GVGLeagueFarmModel.findPlantedByFarmId(configId, myLeague.leagueCode, farmId);
+        const roleIds: string[] = [], fieldByRoleId = new Map<string, GVGLeagueFarmType[]>();
+        for(let field of fields) {
+            if(roleIds.indexOf(field.lockRoleId) == -1) {
+                roleIds.push(field.lockRoleId);
+                fieldByRoleId.set(field.lockRoleId, []);
+            }
+            fieldByRoleId.get(field.lockRoleId).push(field);
+        } 
+
+        const serverNames = await getAllServerName();
+        const roles = await RoleModel.findByRoleIds(roleIds);
+        const result: LeagueFarmMember[] = [];
+        for(let role of roles) {
+            let obj = new LeagueFarmMember(role, serverNames);
+            let myFields = fieldByRoleId.get(role.roleId)||[]
+            obj.setByFields(myFields);
+            const { foodSum } = await calFarmOutputs(myFields, myLeague, leaguePrepare);
+            obj.setOutput(foodSum);
+            result.push(obj);
+        }
+
+        return resResult(STATUS.SUCCESS, {
+            ...await getLeagueFarmShowResult(myLeague.leagueCode, roleId, farmId, false),
+            members: result
+        });
+    }
+
+    // 小游戏界面
+    async getMyFarm(msg: { farmId: number }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const guildCode = session.get('guildCode');
+
+        const { farmId } = msg;
+
+        let { period } = getGVGPeriodData();
+        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);
+
+        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
+        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
+
+        await unlockField(myLeague.leagueCode, roleId, farmId);
+        const myRank = await getmyDistributeRank(myLeague.leagueCode, myLeague.members, roleId);
+
+        return resResult(STATUS.SUCCESS, {
+            ...await getLeagueFarmShowResult(myLeague.leagueCode, roleId, farmId),
+            myRank,
+        });
+    }
+
+    // 种田
+    async plant(msg: { farmId: number, results: { fieldId: number, seedType: number }[] }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const roleName = session.get('roleName');
+        const guildCode = session.get('guildCode');
+        const sid = session.get('sid');
+
+        const { farmId, results } = msg;
+        let { configId, period } = getGVGPeriodData();
+        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);
+
+        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
+        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
+
+        const cost: RewardInter[] = [], updateFields: { fieldId: number, seedType: number, time: number }[] = [];
+        for(let { fieldId, seedType } of results) {
+            let itemId = getItemIdOfSeedType(seedType);
+            let dicItem = gameData.gvgItem.get(itemId);
+            updateFields.push({ fieldId, seedType, time: dicItem.ripeTime });
+            // 算消耗的种子
+            let costObj = cost.find(({ id }) => id == itemId);
+            costObj? costObj.count++: cost.push({ id: itemId, count: 1 });
+        }
+        const costResult = await handleGVGCost(roleId, myLeague.leagueCode, sid, cost, [], ITEM_CHANGE_REASON.PLANT)
+        if(!costResult) return resResult(STATUS.GVG_ITEMS_NOT_ENOUGH);
+
+        const plantResult = await GVGLeagueFarmModel.plant(configId, myLeague.leagueCode, farmId, updateFields, roleId);
+        await rollbackUnPlantFields(cost, plantResult, session, myLeague.leagueCode);  // 可能会有田已经被其他人占领的情况，将种子还回去
+
+        return resResult(STATUS.SUCCESS, {
+            ...await getLeagueFarmShowResult(myLeague.leagueCode, roleId, farmId)
+        });
+    }
+
+    // 收获
+    async harvest(msg: { farmId: number, fieldIds: number[] }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const roleName = session.get('roleName');
+        const sid = session.get('sid');
+        const guildCode = session.get('guildCode');
+
+        const { farmId, fieldIds } = msg;
+        let { configId, period } = getGVGPeriodData();
+        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);
+
+        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
+        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
+
+        const leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, myLeague.leagueCode);
+
+        const myResultFields = await GVGLeagueFarmModel.harvest(configId, myLeague.leagueCode, farmId, fieldIds, roleId); // 解锁
+        if(myResultFields.length <= 0) return resResult(STATUS.GVG_CANNOT_HARVEST);
+        // 计算产量
+        const { foodSum, rewardSum, leagueRewardSum, activeSum } = await calFarmOutputs(myResultFields, myLeague, leaguePrepare);
+        // 资源
+        let resourceResult = await addResource(myLeague.leagueCode, roleId, GVG_RESOURCE_TYPE.FOOD, foodSum)||{};
+        // 相关物品
+        let leagueGoods = await addGVGReward(roleId, roleName, myLeague.leagueCode, sid, leagueRewardSum, rewardSum, ITEM_CHANGE_REASON.HARVEST)
+        // 活跃
+        const active = await addGVGActive(myLeague.leagueCode, roleId, GVG_ACTIVE_TYPE.COST_PRODUCE_COIN, activeSum);
+        // 收获后再次预锁定一批田
+        await unlockField(myLeague.leagueCode, roleId, farmId);
+
+        return resResult(STATUS.SUCCESS, {
+            ...await getLeagueFarmShowResult(myLeague.leagueCode, roleId, farmId),
+            leagueGoods,
+            active,
+            ...resourceResult
+        });
+    }
+
+    // 关闭页面
+    async plantEnd(msg: { farmId: number }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const guildCode = session.get('guildCode');
+
+        const { farmId } = msg;
+        let { configId } = getGVGConfig();
+
+        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
+        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
+        await GVGLeagueFarmModel.releaseLock(configId, myLeague.leagueCode, farmId, roleId);
+
+        return resResult(STATUS.SUCCESS, {
+            ...await getLeagueFarmShowResult(myLeague.leagueCode, roleId, farmId),
+        });
+    }
+
+    // 帮收
+    async helpHarvest(msg: { farmId: number, fieldId: number }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const roleName = session.get('roleName');
+        const guildCode = session.get('guildCode');
+
+        const { farmId, fieldId } = msg;
+        let { configId, period } = getGVGPeriodData();
+        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);
+
+        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
+        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
+
+        const leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, myLeague.leagueCode);
+
+        const resultField = await GVGLeagueFarmModel.helpHarvest(configId, myLeague.leagueCode, farmId, fieldId); // 解锁
+        if(!resultField) return resResult(STATUS.GVG_CANNOT_HARVEST);
+
+        let targetRoleId = resultField.lockRoleId;
+        let targetOnlineInfo = await getRoleOnlineInfo(targetRoleId);
+
+        // 计算产量
+        const { foodSum, rewardSum, leagueRewardSum, activeSum } = await calFarmOutputs([resultField], myLeague, leaguePrepare);
+        // 资源
+        await addResource(myLeague.leagueCode, targetRoleId, GVG_RESOURCE_TYPE.FOOD, foodSum)||{};
+        await sendMailByContent(MAIL_TYPE.HELP_HARVEST, targetRoleId, { sendName: roleName, goods: rewardSum });
+        // 相关物品
+        await addGVGReward(targetRoleId, roleName, myLeague.leagueCode, targetOnlineInfo.sid, leagueRewardSum, [], ITEM_CHANGE_REASON.HARVEST)
+        // 活跃
+        await addGVGActive(myLeague.leagueCode, targetRoleId, GVG_ACTIVE_TYPE.COST_PRODUCE_COIN, activeSum);
+
+        return resResult(STATUS.SUCCESS, {
+            ...await getLeagueFarmShowResult(myLeague.leagueCode, roleId, farmId),
+        });
+    }
+
+    // 获取资源
+    async debugAddResource(msg: { type: number, count: number }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const guildCode = session.get('guildCode');
+        const { type, count } = msg;
+
+        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
+        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
+
+        let resourceResult = await addResource(myLeague.leagueCode, roleId, type, count);
+        if(!resourceResult) return resResult(STATUS.WRONG_PARMS);
+
+        return resResult(STATUS.SUCCESS, resourceResult);
+    }
+}
--- a/game-server/app/services/checkParam.ts
+++ b/game-server/app/services/checkParam.ts
@@ -1,6 +1,5 @@
 import { isArray, isBoolean, isNumber, isString } from "underscore";
-import { BLOCK_OPEATE, DEBUG_MAGIC_WORD, GM_MAIL_TYPE, GUILD_AUTH, GUILD_STRUCTURE, LEAGUE_JOB, LINEUP_NUM, MSG_TYPE } from "../consts";
-import { GVG } from "../pubUtils/dicParam";
+import { BLOCK_OPEATE, DEBUG_MAGIC_WORD, GM_MAIL_TYPE, GUILD_AUTH, GUILD_STRUCTURE, GVG_RESOURCE_TYPE, LEAGUE_JOB, LINEUP_NUM, MSG_TYPE } from "../consts";
 import { pvpEndParamInter } from "../pubUtils/interface";
 import { isDevelopEnv } from "./utilService";

@@ -1235,6 +1234,12 @@ export function checkRouteParam(route: string, msg: any) {
                if(!isNumber(msg.techId)) return false;
                break;
            }
+
+        case "guild.gvgProduceHandler.getProduceList": 
+            {
+                if(!checkIsInEnum(GVG_RESOURCE_TYPE, msg.type)) return false;
+                break;
+            }
        case "order.orderHandler.applyOrder":
            {
                let { productID, payType, activityId, paramStr, useVoucher } = msg;
--- a/game-server/app/services/gmService.ts
+++ b/game-server/app/services/gmService.ts
@@ -7,7 +7,7 @@ import { pinus } from "pinus";
 import { ServerlistModel, ServerlistType } from "../db/Serverlist";
 import { sendMailsByGmMail } from "./mailService";
 import GMMail, { GMMailModel } from '../db/GMMail';
-import { nowSeconds } from "../pubUtils/timeUtil";
+import { getPastTime, nowSeconds } from "../pubUtils/timeUtil";
 import { CreateServerParam } from "../domain/backEndField/params";
 import { SignInData } from "../domain/activityField/signInField";
 import { RegionModel, RegionType } from "../db/Region";
@@ -406,16 +406,4 @@ export async function calHiddenData(uid: number) {
        }
    }
    await HiddenDataModel.updateHiddenData(getPastTime(), heroes, goods, uid);
-}
-
-export function getPastTime() {
-    return moment('2022-01-01').unix();
-}
-
-export function getFutureTime() {
-    return moment('2100-01-01').unix();
-}
-
-export function initServerZone() {
-    
 }
--- a/game-server/app/services/gvg/gvgBattleService.ts
+++ b/game-server/app/services/gvg/gvgBattleService.ts
@@ -0,0 +1,10 @@
+import { GVGLeagueType } from "../../db/GVGLeague";
+
+/**
+ * TODO 获取本联军上周占领的城池
+ * @param league 
+ * @returns number[] 城池id
+ */
+export async function getGVGCities(league: GVGLeagueType) {
+    return []
+}
--- a/game-server/app/services/gvg/gvgItemService.ts
+++ b/game-server/app/services/gvg/gvgItemService.ts
@@ -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;
 }
--- a/game-server/app/services/gvg/gvgPrepareService.ts
+++ b/game-server/app/services/gvg/gvgPrepareService.ts
@@ -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;
 }