224 lines
9.3 KiB
TypeScript
224 lines
9.3 KiB
TypeScript
import { GVGTeamMem } from "../../domain/battleField/gvgBattle";
|
|
import { GVGLeagueType } from "../../db/GVGLeague";
|
|
import { GVGTeamModel, GVGTeamType, GVGTeamUpdate } from "../../db/GVGTeam";
|
|
import { GVGCityModel, GVGCityType } from "../../db/GVGCity";
|
|
import { gameData } from "../../pubUtils/data";
|
|
import { GVG_AREA_TYPE, GVG_TECH_TYPE, STATUS } from "../../consts";
|
|
import { nowSeconds } from "../../pubUtils/timeUtil";
|
|
import { DicGVGAreaPoint } from "../../pubUtils/dictionary/DicGVGAreaPoint";
|
|
import { getGVGBattleData, getGVGBattleMap } from "./gvgBattleMemory";
|
|
import { GVGCityMapInfo } from "../../domain/gvgField/returnData";
|
|
import { pick } from "underscore";
|
|
import { GVG } from "../../pubUtils/dicParam";
|
|
import { GVGHeroInfo, PvpEnemies, PvpHeroInfo } from "../../domain/dbGeneral";
|
|
import { getGVGConfig } from "./gvgService";
|
|
import { GVGLeaguePrepareModel } from "../../db/GVGLeaguePrepare";
|
|
import { pinus } from "pinus";
|
|
import { dispatch } from "../../pubUtils/dispatcher";
|
|
|
|
|
|
/**
|
|
* TODO 检查上周是否有占领城池
|
|
* @param league
|
|
* @returns boolean 是否占领
|
|
*/
|
|
export async function checkHasCities(league: GVGLeagueType) {
|
|
return false
|
|
}
|
|
|
|
/**
|
|
* TODO 获取本联军上周占领的城池
|
|
* @param league
|
|
* @returns number[] 城池id
|
|
*/
|
|
export async function getGVGCities(league: GVGLeagueType) {
|
|
return []
|
|
}
|
|
|
|
/**
|
|
* 获取当前城池状态
|
|
* @returns [{cityId: number, guardLeagueCode: string, guardLeagueName: string, teamCnt: number }]
|
|
*/
|
|
export async function getGVGCitiesInfo(configId: number, groupId: number, serverType: number, league: GVGLeagueType): Promise<{cityId: number, guardLeagueName: string, teamCnt: number }[]> {
|
|
let cities = await GVGCityModel.findGuardCityByLeague(configId, groupId, serverType);
|
|
let result: GVGCityMapInfo[] = [];
|
|
for(let city of cities) {
|
|
let players = (city.players||[]).filter(cur => cur.leagueCode == league.leagueCode);
|
|
let obj = new GVGCityMapInfo(city, players.length);
|
|
result.push(obj);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* 获取内存中队伍的数据结构
|
|
*/
|
|
export function getGVGTeamMemInfo(team: GVGTeamType): GVGTeamMem {
|
|
const teamMem = new GVGTeamMem(team);
|
|
teamMem.isMoving = false;
|
|
teamMem.startMoveTime = 0;
|
|
teamMem.stopMoveTime = 0;
|
|
return teamMem;
|
|
}
|
|
|
|
export function getBirthAreaOfCity(city: GVGCityType, leagueCode: string) {
|
|
let isGuard = city.guardLeague == leagueCode;
|
|
let dicGVGCity = gameData.gvgCity.get(city.cityId);
|
|
return isGuard? dicGVGCity.defenseBirth: dicGVGCity.attackBirth;
|
|
}
|
|
|
|
// guild.gvgBattleHandler.startMove 检测
|
|
export function checkMoveStatus(team: GVGTeamType, cityId: number, areaId: number) {
|
|
if(!team) return STATUS.GVG_BATTLE_TEAM_NOT_FOUND;
|
|
if(team.cityId != cityId) return STATUS.GVG_BATTLE_IS_NOT_IN_CITY;
|
|
if(team.pointId > 0) return STATUS.GVG_BATTLE_TEAM_IS_SELLTED;
|
|
if(team.stopMoveTime > nowSeconds()) return STATUS.GVG_BATTLE_IS_MOVING;
|
|
let dicArea = gameData.gvgArea.get(areaId);
|
|
if(!dicArea) return STATUS.DIC_DATA_NOT_FOUND;
|
|
if(dicArea.relateArea.indexOf(team.areaId) == -1) return STATUS.GVG_BATTLE_AREA_NOT_RELATE;
|
|
return STATUS.SUCCESS;
|
|
}
|
|
|
|
export async function initRobots(confidId: number, groupId: number, serverType: number, cityId: number) {
|
|
let robotTeams = await GVGTeamModel.findRobotTeams(groupId, serverType, cityId);
|
|
let updateDicPoints: DicGVGAreaPoint[] = [];
|
|
let { areaIds = []} = gameData.gvgCity.get(cityId);
|
|
for(let [_, point] of gameData.gvgAreaPoint) {
|
|
if(areaIds.indexOf(point.areaId) == -1) continue;
|
|
let robotTeam = robotTeams.find(team => team.pointId == point.pointId);
|
|
if(!robotTeam || (!robotTeam.isBroken && robotTeam.configId != confidId) ) {
|
|
updateDicPoints.push(point);
|
|
}
|
|
}
|
|
if(updateDicPoints.length > 0) {
|
|
robotTeams = await GVGTeamModel.initRobots(confidId, groupId, serverType, cityId, updateDicPoints);
|
|
// 存入内存
|
|
let teamObj = getGVGBattleData(groupId, serverType);
|
|
teamObj.enterCity(...robotTeams);
|
|
}
|
|
return robotTeams;
|
|
}
|
|
|
|
export function checkAreaIsInCity(cityId: number, areaIds: number[]) {
|
|
let dicCity = gameData.gvgCity.get(cityId);
|
|
if(!dicCity) return false;
|
|
for(let areaId of areaIds) {
|
|
if(dicCity.areaIds.indexOf(areaId) == -1) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
export function calBattleScoreByCe(isSuccess: boolean, lineupCe: number) {
|
|
let winScore = Math.floor(lineupCe/GVG.GVG_BATTLE_SCORE);
|
|
if(winScore <= 0) winScore = 1;
|
|
return isSuccess? winScore: 0;
|
|
}
|
|
|
|
export async function teamBreak(city: GVGCityType, team: GVGTeamType) {
|
|
if(team.durability > 0) return team
|
|
let areaId = getBirthAreaOfCity(city, team.leagueCode);
|
|
team = await GVGTeamModel.teamBreak(team.teamCode, team.isRobot, team.maxDurability, areaId);
|
|
return team;
|
|
}
|
|
|
|
export function getGVGWarId(defenseTeam: GVGTeamType) {
|
|
if(!defenseTeam.isRobot) return GVG.GVG_CITY_BGMAP_GKID; // 玩家防守地图
|
|
if(!defenseTeam.isCatapult) return GVG.GVG_CATAPULT_WARJSON; // 投石车使用
|
|
return GVG.GVG_ROBOT_WARJSON; // 据点守卫使用
|
|
}
|
|
|
|
// guild.gvgBattleHandler.battleStart 里的heroes返回
|
|
export function getOppHeroes(warId: number, isRobot: boolean, lineup: GVGHeroInfo[]) {
|
|
let heroes: PvpEnemies[] = [];
|
|
const dicWar = gameData.war.get(warId);
|
|
if(!dicWar) { console.error(`warId ${warId} not found`); return [] }
|
|
const dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId)||[];
|
|
for(let warJson of dicWarJson) {
|
|
if(!isRobot) {
|
|
let heroInfo = lineup.find(cur => cur.dataId == warJson.dataId);
|
|
if(!heroInfo) continue;
|
|
let hero = new PvpEnemies(warJson, heroInfo);
|
|
heroes.push(hero);
|
|
} else {
|
|
if(warJson.relation == 2) {
|
|
let dicHero = gameData.hero.get(warJson.actorId);
|
|
if(!dicHero) continue;
|
|
let heroInfo = new PvpHeroInfo();
|
|
heroInfo.setRobotInfo(dicHero, warJson.lv);
|
|
let hero = new PvpEnemies(warJson, heroInfo);
|
|
heroes.push(hero);
|
|
}
|
|
}
|
|
}
|
|
return heroes
|
|
}
|
|
|
|
// guild.gvgBattleHandler.battleStart 检测
|
|
export function checkGVGBattleStart(roleId: string, attackTeam: GVGTeamType, defenseTeam: GVGTeamType) {
|
|
|
|
if(!attackTeam || !defenseTeam) return STATUS.GVG_BATTLE_TEAM_INVALID;
|
|
if(attackTeam.roleId != roleId) return STATUS.GVG_TEAM_IS_NOT_MINE;
|
|
if(attackTeam.leagueCode == defenseTeam.leagueCode) return STATUS.GVG_SAME_LEAGUE_CANNOT_ATTACK;
|
|
if(attackTeam.areaId != defenseTeam.areaId) return STATUS.GVG_TEAM_NOT_SAME_AREA;
|
|
|
|
if(attackTeam.attackTime > nowSeconds()) return STATUS.GVG_TEAM_ATTACKING;
|
|
if(defenseTeam.defenseTime > nowSeconds() || defenseTeam.lockTime > nowSeconds()) return STATUS.GVG_TEAM_DEFENSEING;
|
|
if(attackTeam.durability <= 0) return STATUS.GVG_ATTACK_TEAM_BROKEN;
|
|
if(defenseTeam.durability <= 0) return STATUS.GVG_DEFENSE_TEAM_BROKEN;
|
|
|
|
return STATUS.SUCCESS;
|
|
}
|
|
|
|
// gvg激战期开始定时器
|
|
export async function gvgBattleStart() {
|
|
let servers = pinus.app.getServersByType('guild');
|
|
|
|
let { configId } = getGVGConfig();
|
|
let guardCities = await GVGCityModel.findAllGuardCities(configId);
|
|
for(let { cityId, groupId, serverType, guardLeague, guardLeagueName } of guardCities) {
|
|
let sid = dispatch(cityId.toString(), servers)?.id;
|
|
await pinus.app.rpc.guild.guildRemote.initCatapult.toServer(sid, cityId, groupId, serverType, guardLeague, guardLeagueName);
|
|
}
|
|
}
|
|
|
|
// 每次活动开始初始化投石车
|
|
export async function initCatapult(cityId: number, groupId: number, serverType: number, leagueCode: string, leagueName: string) {
|
|
let { configId } = getGVGConfig();
|
|
|
|
let leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, leagueCode);
|
|
let activeTech = leaguePrepare?.activeTech||[];
|
|
let hasCatapult = false, atk = 0, durability = 0;
|
|
for(let techId of activeTech) {
|
|
let dicTech = gameData.gvgTech.get(techId);
|
|
if(dicTech && dicTech.type == GVG_TECH_TYPE.BATTLE_ITEM_CATAPULT) {
|
|
hasCatapult = true, atk = dicTech.param[0]; durability = dicTech.param[1];
|
|
}
|
|
}
|
|
if(hasCatapult) {
|
|
let dicCity = gameData.gvgCity.get(cityId);
|
|
let areaIds = (dicCity?.areaIds||[]).filter(areaId => {
|
|
let dicArea = gameData.gvgArea.get(areaId);
|
|
return dicArea && dicArea.areaType == GVG_AREA_TYPE.CATAPULT;
|
|
});
|
|
let teams = await GVGTeamModel.initCatapult(configId, groupId, serverType, cityId, leagueCode, leagueName, areaIds, atk, durability);
|
|
// 处理内存
|
|
let teamObj = getGVGBattleData(groupId, serverType);
|
|
teamObj.enterCity(...teams);
|
|
}
|
|
}
|
|
|
|
// 投石车投伤害
|
|
export async function catapultHurt() {
|
|
for(let [_, teamObj] of getGVGBattleMap()) {
|
|
let teams = teamObj.findCatapult();
|
|
for(let catapult of teams) {
|
|
if(catapult.isBroken) continue;
|
|
let dicArea = gameData.gvgArea.get(catapult.areaId);
|
|
let relateArea = dicArea?.relateArea||[];
|
|
let teamCodes = teamObj.findCatapultAttackTeam(relateArea, catapult.leagueCode);
|
|
let dicGVGCity = gameData.gvgCity.get(catapult.cityId);
|
|
let teams = await GVGTeamModel.attackByCatapult(teamCodes, catapult.captapultAtk, dicGVGCity.attackBirth)
|
|
teamObj.battleEnd(teams);
|
|
}
|
|
}
|
|
} |