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

🦄 refactor(热更新): 分割状态代码和功能代码

Browse Source
This commit is contained in:
luying
2023-05-05 15:42:00 +08:00
parent 50a24cb4b8
commit a362a397b5
39 changed files with 676 additions and 622 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game-server/app/services/guildActivity/cityActivityObj.ts
+36 -38
View File
@@ -1,25 +1,19 @@
// 军团活动蛮夷入侵城门血量等数据存储
import { GUILD_ACTIVITY_STATUS } from "../../consts";
import { Member } from "../../domain/battleField/guildActivity";
import { CityActivityData } from "../../domain/battleField/guildActivity";
import { getCityActivityGateHp } from "./guildActivityService";
// 军团诸侯混战等数据
export class CityActivityObject {
public guildActivityStatus = GUILD_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束
private gateHp: Map<string, number> = new Map(); // 城门血条，每个cityId有一条血条 serverId&cityId => gateHp
private maxHp: Map<string, number> = new Map(); // 城门血条，每个cityId最大城门血量 serverId&cityId => gateHp
private members: Map<string, Array<Member>> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
private cities: Map<string, string[]> = new Map(); // 各个城池参与的军团 serverId&cityId => [guildCode]
private guilds: Map<string, number> = new Map(); // 军团所在的城池 guildCode => cityId
private sentCity: string[] = [];
private startTime: number = 0;
data: CityActivityData = new CityActivityData();
private getKey(serverId: number, cityId: number) {
public getKey(serverId: number, cityId: number) {
return `${serverId}_${cityId}`;
}
private decodeKey(key: string) {
public decodeKey(key: string) {
let arr = key.split('_');
return {
serverId: parseInt(arr[0]),
@@ -30,25 +24,29 @@ export class CityActivityObject {
public getObj( serverId: number, cityId: number, guildCode: string) {
let key = this.getKey(serverId, cityId);
return {
gateHp: this.gateHp.get(key),
maxHp: this.maxHp.get(key),
members: this.members.get(guildCode),
city: this.cities.get(key),
guild: this.guilds.get(guildCode)
gateHp: this.data.gateHp.get(key),
maxHp: this.data.maxHp.get(key),
members: this.data.members.get(guildCode),
city: this.data.cities.get(key),
guild: this.data.guilds.get(guildCode)
}
}
public startActivity() {
this.startTime = Date.now();
this.guildActivityStatus = GUILD_ACTIVITY_STATUS.START;
this.data.startTime = Date.now();
this.data.guildActivityStatus = GUILD_ACTIVITY_STATUS.START;
}
public endActivity() {
this.guildActivityStatus = GUILD_ACTIVITY_STATUS.END;
this.data.guildActivityStatus = GUILD_ACTIVITY_STATUS.END;
}
public getStatus() {
return this.data.guildActivityStatus;
}
public getTimeGap() {
return Math.floor((Date.now() - this.startTime)/1000);
return Math.floor((Date.now() - this.data.startTime)/1000);
}
public lockCity(serverId: number, cityId: number) {
@@ -65,18 +63,18 @@ export class CityActivityObject {
// this.guilds.delete(guildCode);
// }
// this.cities.delete(key);
this.sentCity.push(key);
this.data.sentCity.push(key);
}
public hasSent(serverId: number, cityId: number) {
let key = this.getKey(serverId, cityId);
return this.sentCity.indexOf(key) != -1;
return this.data.sentCity.indexOf(key) != -1;
}
public getAllCities() {
let allCities = new Array<{ serverId: number, cityId: number, guildCodes: string[]}>();
let serverlists = new Array<number>();
for(let [key, guildCodes] of this.cities) {
for(let [key, guildCodes] of this.data.cities) {
let { serverId, cityId } = this.decodeKey(key);
if(!this.hasSent(serverId, cityId)) {
allCities.push({ serverId, cityId, guildCodes });
@@ -88,53 +86,53 @@ export class CityActivityObject {
public getGuildsInCity(serverId: number, cityId: number) {
let key = this.getKey(serverId, cityId);
return this.cities.get(key)||[];
return this.data.cities.get(key)||[];
}
public getMembersOfGuild(guildCode: string) {
return this.members.get(guildCode)||[];
return this.data.members.get(guildCode)||[];
}
public async getGateHpAndInc(serverId: number, cityId: number, inc: number = 0) {
let key = this.getKey(serverId, cityId);
let gateHp = this.gateHp.get(key);
if(!this.gateHp.has(key)) {
let gateHp = this.data.gateHp.get(key);
if(!this.data.gateHp.has(key)) {
gateHp = await getCityActivityGateHp(serverId, cityId);
this.gateHp.set(key, gateHp);
this.maxHp.set(key, gateHp);
this.data.gateHp.set(key, gateHp);
this.data.maxHp.set(key, gateHp);
}
if(inc != 0) {
gateHp += inc;
this.gateHp.set(key, gateHp);
this.data.gateHp.set(key, gateHp);
}
if(gateHp <= 0) gateHp = 0;
return { gateHp, maxHp: this.maxHp.get(key)||0 }
return { gateHp, maxHp: this.data.maxHp.get(key)||0 }
}
public pushMembers(guildCode: string, roleId: string, job: number, code: string) {
if(this.members.has(guildCode)) {
let members = this.members.get(guildCode);
if(this.data.members.has(guildCode)) {
let members = this.data.members.get(guildCode);
if(members.findIndex(cur => cur.roleId == roleId) == -1) {
members.push({ roleId, job, code });
}
} else {
let arr = new Array<string>();
arr.push(roleId);
this.members.set(guildCode, [{ roleId, job, code }]);
this.data.members.set(guildCode, [{ roleId, job, code }]);
}
}
public pushGuild(guildCode: string, serverId: number, cityId: number) {
let key = this.getKey(serverId, cityId);
if(!this.cities.has(key)) {
this.cities.set(key, [guildCode]);
if(!this.data.cities.has(key)) {
this.data.cities.set(key, [guildCode]);
} else {
let arr = this.cities.get(key);
let arr = this.data.cities.get(key);
if(!arr.includes(guildCode)) {
arr.push(guildCode);
}
}
this.guilds.set(guildCode, cityId);
this.data.guilds.set(guildCode, cityId);
}
}
game-server/app/services/guildActivity/gateActivityObj.ts
+21 -24
View File
@@ -1,75 +1,72 @@
// 军团活动蛮夷入侵城门血量等数据存储
import { Member, GateMembersRec } from "../../domain/battleField/guildActivity";
import { Member, GateMembersRec, GateActivityData } from "../../domain/battleField/guildActivity";
export class GateActivityObject {
public startTime: number;
private members: Map<string, Array<Member>> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
private membersRecord: Map<string, GateMembersRec> = new Map(); // 每个成员的回合数和敌军数，防刷 recCode => GateMembersRec
private guilds: Map<number, string[]> = new Map(); // 参加的所有军团 server => [guildCode]
data: GateActivityData = new GateActivityData();
public getObj(guildCode: string, serverId: number) {
// console.log(guildCode, serverId)
return {
members: this.members.get(guildCode)||[],
memberesRecord: [...this.membersRecord],
guilds: this.guilds.get(serverId)||[]
members: this.data.members.get(guildCode)||[],
memberesRecord: [...this.data.membersRecord],
guilds: this.data.guilds.get(serverId)||[]
}
}
public startActivity() {
this.startTime = Date.now();
this.data.startTime = Date.now();
}
public getTimeGap() {
return Math.floor((Date.now() - this.startTime)/1000);
return Math.floor((Date.now() - this.data.startTime)/1000);
}
public getGuilds() {
return this.guilds;
return this.data.guilds;
}
public pushMembers(guildCode: string, serverId: number, roleId: string, job: number, code: string) {
let member: Member;
if(this.members.has(guildCode)) {
let members = this.members.get(guildCode);
if(this.data.members.has(guildCode)) {
let members = this.data.members.get(guildCode);
if(members.findIndex(cur => cur.roleId == roleId) == -1) {
member = { roleId, job, code }
members.push(member);
}
} else {
member = { roleId, job, code }
this.members.set(guildCode, [member]);
this.data.members.set(guildCode, [member]);
}
if(this.guilds.has(serverId)) {
let arr = this.guilds.get(serverId);
if(this.data.guilds.has(serverId)) {
let arr = this.data.guilds.get(serverId);
if(!arr.includes(guildCode)) arr.push(guildCode);
this.guilds.set(serverId, arr);
this.data.guilds.set(serverId, arr);
} else {
this.guilds.set(serverId, [guildCode]);
this.data.guilds.set(serverId, [guildCode]);
}
return member;
}
public getMemberRecord(recCode: string, roleId: string) {
return this.membersRecord.get(recCode)||new GateMembersRec(roleId)
return this.data.membersRecord.get(recCode)||new GateMembersRec(roleId)
}
public setMemberRecord(recCode: string, newMemberRecord: GateMembersRec) {
this.membersRecord.set(recCode, newMemberRecord);
this.data.membersRecord.set(recCode, newMemberRecord);
}
public delMemberRecord(recCode: string) {
this.membersRecord.delete(recCode);
this.data.membersRecord.delete(recCode);
}
public delGuildRecord(guildCode: string, serverId: number) {
let guildList = this.guilds.get(serverId);
let guildList = this.data.guilds.get(serverId);
if(guildList) {
let index = guildList.indexOf(guildCode);
guildList.splice(index, 1);
}
this.members.delete(guildCode);
this.data.members.delete(guildCode);
}
}
game-server/app/services/guildActivity/guildActivityService.ts
+3 -36
View File
@@ -15,15 +15,11 @@ import { genAuction, getGuildAuctionBasicNum, getGuildAuctionRewards, getRewardT
import { sendMailByContent } from "../mailService";
import { GuildActivityCityType, GuildActivityCityModel } from "../../db/GuildActivityCity";
import { DicCityActivity } from "../../pubUtils/dictionary/DicCityActivity";
import { CityActivityObject } from "./cityActivityObj";
import { GateActivityObject } from "./gateActivityObj";
import { RaceActivityObject } from "./raceActivityObj";
import { Rank } from "../rankService";
import { BossInstanceModel } from "../../db/BossInstance";
import { UserGuildModel } from "../../db/UserGuild";
import { addActive } from "../guildService";
import { ActivePlayer, GuildRecord, ServerRecordModel } from "../../db/ServerRecords";
import { Attack } from "../../domain/battleField/pvp";
import { getHonourObject } from "../role/rewardService";
import { sendMessageToCityWithSuc, sendMessageToGuildWithSuc, sendMessageToServerWithSuc, sendMessageToUserWithSuc } from "../pushService";
import { saveGuildGateHpLog } from "../../pubUtils/logUtil";
@@ -31,39 +27,10 @@ import { GuildActivityCityDeclareModel } from "../../db/GuildActivityCityDeclare
import { getRandSingleEelm } from "../../pubUtils/util";
import { CounterModel } from "../../db/Counter";
import { setInterval } from "timers";
import { DicRaceActivity } from "../../pubUtils/dictionary/DicRaceActivity";
import { dispatch } from "../../pubUtils/dispatcher";
import { GuildModel } from "../../db/Guild";
import { getCityActivityObj, getGateActivityObj, getRaceActivityObj } from "../memoryCache/guildActivityData";
let gateActivityObj: GateActivityObject;
let cityActivityObj: CityActivityObject;
let raceActivityObj: RaceActivityObject;
export function getGateActivityObj() {
if (!gateActivityObj) {
gateActivityObj = new GateActivityObject();
}
return gateActivityObj;
}
export function getCityActivityObj() {
if (!cityActivityObj) {
cityActivityObj = new CityActivityObject();
}
return cityActivityObj;
}
export function getRaceActivityObj() {
if (!raceActivityObj) {
raceActivityObj = new RaceActivityObject();
}
return raceActivityObj;
}
export function clearActivityObj() {
gateActivityObj = undefined;
cityActivityObj = undefined;
raceActivityObj = undefined;
}
/**
* 定时任务，获得前一天的活跃玩家中位数武将战力
@@ -878,14 +845,14 @@ export function getGAIndexInPinus(aid: number) {
export function getDeclareIndex() {
let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
let obj = getCityActivityObj();
if(obj.guildActivityStatus == GUILD_ACTIVITY_STATUS.START) return index;
if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START) return index;
return index + 1;
}
export function getJoinIndex() {
let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
let obj = getRaceActivityObj();
if(obj.status == GUILD_ACTIVITY_STATUS.START || obj.status == GUILD_ACTIVITY_STATUS.END) return index;
if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START || obj.getStatus() == GUILD_ACTIVITY_STATUS.END) return index;
return index + 1;
}
game-server/app/services/guildActivity/raceActivityObj.ts
+236 -88
View File
@@ -1,63 +1,30 @@
// 军团活动蛮夷入侵城门血量等数据存储
import { Member, GateMembersRec, WoodenHorse, Event, WoodenHorseMember, RaceActivityRankParam } from "../../domain/battleField/guildActivity";
import { RewardInter } from "../../pubUtils/interface";
import { WoodenHorse, Event, WoodenHorseMember, RaceActivityRankParam, RaceActivityData, MemberInfo, GuildInfo } from "../../domain/battleField/guildActivity";
import { getRaceEventItems, gameData } from "../../pubUtils/data";
import { GuildModel } from "../../db/Guild";
import { sendSingleRaceActEndMsg } from "./guildActivityService";
import { REDIS_KEY, RACE_EVENT_TYPE, RACE_EVENT_EFFECT_TYPE, RACE_EVENT, STATUS, PUSH_ROUTE, GUILD_ACTIVITY_STATUS, DEBUG_MAGIC_WORD } from "../../consts";
import { getRandEelm, sortArrRandom, resResult, getRandResultByMember } from "../../pubUtils/util";
import { sendMessageToGuildWithSuc, sendMessageToServerWithSuc, sendMessageToUserWithSuc } from "../pushService";
class MemberInfo extends Member {
isQuit: boolean = false;
constructor(roleId: string, job: number, code: string) {
super();
this.roleId = roleId;
this.job = job;
this.code = code;
}
public quit() {
this.isQuit = true;
}
}
class GuildInfo {
serverId: number;
guildCode: string;
isDissmiss: boolean = false;
constructor(serverId: number, guildCode: string) {
this.serverId = serverId;
this.guildCode = guildCode;
}
dismiss() {
this.isDissmiss = true;
}
}
import { RACE_EVENT_TYPE, RACE_EVENT_EFFECT_TYPE, RACE_EVENT, PUSH_ROUTE, GUILD_ACTIVITY_STATUS, RACE_ACTIVITY_STATUS } from "../../consts";
import { getRandEelm, sortArrRandom, getRandResultByMember } from "../../pubUtils/util";
import { sendMessageToGuildWithSuc, sendMessageToUserWithSuc } from "../pushService";
import { GUILDACTIVITY } from "../../pubUtils/dicParam";
// 粮草先行
export class RaceActivityObject {
public status = GUILD_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束
private allStartTime = 0; // 开启时间，每天晚上8点
private guildList: GuildInfo[] = []; // 所有军团
private members: Map<string, MemberInfo[]> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
private woodenHorses: Map<string, WoodenHorse> = new Map(); // 每个军团的木牛流马 guildCode => WoodenHorse
private events: Map<string, Event[]> = new Map(); // 每个军团遇到的事件
private items: Map<string, RewardInter[]> = new Map(); // 每个玩家的道具 roleId => [{id, count}]
private hasSentGuild: string[] = [];
data: RaceActivityData = new RaceActivityData();
public getStatus() {
return this.data.status;
}
public getItem(roleId: string) {
return this.items.get(roleId)||[]
return this.data.items.get(roleId)||[]
}
// 是否加入过
public getMember(guildCode: string, roleId: string) {
let member = this.members.get(guildCode)||[];
let member = this.data.members.get(guildCode)||[];
return member.find(cur => cur.roleId == roleId);
}
@@ -65,7 +32,11 @@ export class RaceActivityObject {
let member = this.getMember(guildCode, roleId);
if(!member) return member;
let wh = await this.getWoodenHorse(guildCode, serverId);
wh.updateMemberSid(roleId, sid);
let index = wh.members.findIndex(cur => cur.roleId == roleId);
if(index != -1) {
wh.members[index].updateSid(sid);
}
return member
}
@@ -73,7 +44,7 @@ export class RaceActivityObject {
let member = this.getMember(guildCode, roleId);
if(!member) return member;
let wh = await this.getWoodenHorse(guildCode, serverId);
wh.leaveMemberSid(roleId);
this.leaveMemberSid(wh, roleId);
return member
}
@@ -83,42 +54,42 @@ export class RaceActivityObject {
if(!member) return;
member.quit();
let wh = await this.getWoodenHorse(guildCode, serverId);
wh.leaveMemberSid(roleId, true);
this.leaveMemberSid(wh, roleId, true);
}
public dismiss(guildCode: string) {
let guild = this.guildList.find(guild => guild.guildCode == guildCode);
let guild = this.data.guildList.find(guild => guild.guildCode == guildCode);
if(!guild) return;
guild.dismiss();
this.woodenHorses.delete(guildCode);
this.data.woodenHorses.delete(guildCode);
}
// 加入member
private pushMember(guildCode: string, roleId: string, job: number, code: string) {
if(!this.members.has(guildCode)) {
this.members.set(guildCode, []);
if(!this.data.members.has(guildCode)) {
this.data.members.set(guildCode, []);
}
this.members.get(guildCode).push(new MemberInfo(roleId, job, code));
this.data.members.get(guildCode).push(new MemberInfo(roleId, job, code));
}
public getGuilds() {
return this.guildList.filter(cur => !cur.isDissmiss);
return this.data.guildList.filter(cur => !cur.isDissmiss);
}
public getMembersOfGuild(guildCode: string) {
let members = this.members.get(guildCode)||[];
let members = this.data.members.get(guildCode)||[];
return members.filter(cur => !cur.isQuit);
}
public getAllWoodenHorses() {
return this.woodenHorses;
return this.data.woodenHorses;
}
public async getRanks(serverId: number, guildCode?: string) {
let myRank: RaceActivityRankParam = null;
let ranks: RaceActivityRankParam[] = [];
let myIndex = -1;
for(let [_, _wh] of this.woodenHorses) {
for(let [_, _wh] of this.data.woodenHorses) {
if(_wh.serverId == serverId && _wh.status != GUILD_ACTIVITY_STATUS.WAITING) {
let wh = await this.getWoodenHorse(_wh.guildCode, _wh.serverId);
if(wh) {
@@ -152,10 +123,10 @@ export class RaceActivityObject {
public async joinWoodenHorse(guildCode: string, roleId: string, roleName: string, serverId: number, sid: string, job: number, code: string, isDebug = false) {
let woodenHorse = await this.getWoodenHorse(guildCode, serverId, isDebug);
if(!woodenHorse) return false;
woodenHorse.joinMember(roleId, roleName, sid, code)
this.joinMember(woodenHorse, roleId, roleName, sid, code)
this.pushMember(guildCode, roleId, job, code);
if(this.status == GUILD_ACTIVITY_STATUS.START) {
if(this.data.status == GUILD_ACTIVITY_STATUS.START) {
// this.sendRandItemsToMembers([member], woodenHorse, woodenHorse.remainItems);
this.woodenHorseStartRace(woodenHorse);
}
@@ -164,22 +135,22 @@ export class RaceActivityObject {
// 获取某个军团的木马状态
public async getWoodenHorse(guildCode: string, serverId: number, isDebug: boolean = false) {
if(!this.woodenHorses.has(guildCode)) {
if(!this.data.woodenHorses.has(guildCode)) {
this.initEvents(guildCode);
if(isDebug) {
this.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildCode, 0, serverId, this.allStartTime, false));
this.guildList.push(new GuildInfo(serverId, guildCode));
this.data.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildCode, 0, serverId, this.data.allStartTime, false));
this.data.guildList.push(new GuildInfo(serverId, guildCode));
} else {
let guild = await GuildModel.findByCode(guildCode, serverId);
if(!guild) return undefined;
let { name: guildName, guildCe } = guild;
this.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildName, guildCe, serverId, this.allStartTime, false));
this.guildList.push(new GuildInfo(serverId, guildCode));
this.data.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildName, guildCe, serverId, this.data.allStartTime, false));
this.data.guildList.push(new GuildInfo(serverId, guildCode));
}
}
let woodenHorse = this.woodenHorses.get(guildCode);
let events = this.events.get(guildCode)||[];
let needSendEnd = woodenHorse.calCurWoodenHorse(events);
let woodenHorse = this.data.woodenHorses.get(guildCode);
let events = this.data.events.get(guildCode)||[];
let needSendEnd = this.calCurWoodenHorse(woodenHorse, events);
if (needSendEnd) { // 抵达后发送奖励，发送消息，结算
await sendSingleRaceActEndMsg(guildCode, woodenHorse);
}
@@ -194,12 +165,12 @@ export class RaceActivityObject {
if(!rec) return false;
}
let event = new Event(id, fromGuild, toGuild, count);
if(!this.events.has(toGuild)) {
this.events.set(toGuild, [event]);
if(!this.data.events.has(toGuild)) {
this.data.events.set(toGuild, [event]);
} else {
let events = this.events.get(toGuild)||[];
let events = this.data.events.get(toGuild)||[];
events.push(event);
this.events.set(toGuild, events);
this.data.events.set(toGuild, events);
}
let { guildRank, myGuildRank, myIndex } = await this.getRanks(serverId, toGuild);
if(myGuildRank) {
@@ -219,10 +190,10 @@ export class RaceActivityObject {
// 定时任务到，开始比赛，设置开始赛道，发放初始道具
public startRace() {
this.status = GUILD_ACTIVITY_STATUS.START;
if(this.allStartTime == 0) this.allStartTime = Date.now();
this.data.status = GUILD_ACTIVITY_STATUS.START;
if(this.data.allStartTime == 0) this.data.allStartTime = Date.now();
let guildCodes = new Array<string>();
for(let [code, woodenHorse] of this.woodenHorses) {
for(let [code, woodenHorse] of this.data.woodenHorses) {
if(woodenHorse.memberCnt > 0) {
this.woodenHorseStartRace(woodenHorse);
guildCodes.push(code);
@@ -232,14 +203,18 @@ export class RaceActivityObject {
}
public stopRace() {
this.status = GUILD_ACTIVITY_STATUS.END;
for(let [_, woodenHorse] of this.woodenHorses) {
woodenHorse.stopRace();
this.data.status = GUILD_ACTIVITY_STATUS.END;
for(let [_, woodenHorse] of this.data.woodenHorses) {
woodenHorse.status = RACE_ACTIVITY_STATUS.END;
}
}
private woodenHorseStartRace(woodenHorse: WoodenHorse) {
woodenHorse.startRace(this.allStartTime);
woodenHorse.status = RACE_ACTIVITY_STATUS.START;
woodenHorse.time = Date.now();
woodenHorse.startTime = Date.now();
woodenHorse.allStartTime = this.data.allStartTime;
let members = woodenHorse.members;
let normalItems = getRaceEventItems();
this.sendRandItemsToMembers(members, woodenHorse, normalItems);
@@ -262,7 +237,7 @@ export class RaceActivityObject {
addItems.get(member.roleId).items.push({ id, count });
}
}
woodenHorse.setRemainItem(id, randResult.remain, max);
this.setRemainItem(woodenHorse, id, randResult.remain, max);
}
for(let [_roleId, {member, items}] of addItems) {
member.setReceived(true);
@@ -272,8 +247,8 @@ export class RaceActivityObject {
// 初始进入就随机9个灵球事件
public initEvents(guildCode: string) {
if(!this.events.get(guildCode)) {
this.events.set(guildCode, []);
if(!this.data.events.get(guildCode)) {
this.data.events.set(guildCode, []);
}
let dicEncounter = gameData.raceActivityEncounter; // 距离=>事件类型
let goodEventNum = Math.floor(dicEncounter.eventNum/2);
@@ -288,17 +263,17 @@ export class RaceActivityObject {
for(let [distance, type] of dicEncounter.events) {
if(type == RACE_EVENT_TYPE.ITEM) {
let event = new Event(RACE_EVENT.ITEM, guildCode, guildCode, 1, distance);
this.events.get(guildCode).push(event);
this.data.events.get(guildCode).push(event);
} else if (type == RACE_EVENT_TYPE.EVENT) {
let event = new Event(events[index], guildCode, guildCode, 1, distance);
this.events.get(guildCode).push(event);
this.data.events.get(guildCode).push(event);
index ++;
}
}
}
public getEvents(guildCode: string, distance: number) {
let events = this.events.get(guildCode)||[];
let events = this.data.events.get(guildCode)||[];
let result = new Array<Event>();
for(let event of events) {
let { endTime, endDistance } = event;
@@ -323,7 +298,7 @@ export class RaceActivityObject {
}
private handleItems(roleId: string, sid: string, incItems: {id: number, count: number}[]) {
let items = this.items.get(roleId)||[];
let items = this.data.items.get(roleId)||[];
let sendItems = new Array<{id: number, count: number}>();
for(let {id, count: inc} of incItems) {
let curItem = items.find(cur => cur.id == id);
@@ -337,17 +312,17 @@ export class RaceActivityObject {
sendItems.push({ id, count: curItem.count });
}
}
this.items.set(roleId, items);
this.data.items.set(roleId, items);
sendMessageToUserWithSuc(roleId, PUSH_ROUTE.RACE_ITEM_UPDATE, { items: sendItems }, sid);
return items;
}
public send(guildCode: string) {
this.hasSentGuild.push(guildCode);
this.data.hasSentGuild.push(guildCode);
}
public hasSend(guildCode: string) {
return this.hasSentGuild.indexOf(guildCode) != -1;
return this.data.hasSentGuild.indexOf(guildCode) != -1;
}
public async calServerHorses(serverId: number) {
@@ -408,5 +383,178 @@ export class RaceActivityObject {
}
return woodenHorseList
}
/**
* 根据时间计算当前木马速度距离耐久等
* @param events
* @returns {boolean} needSendEnd 是否跑到终点发送结束新号
*/
public calCurWoodenHorse(woodenHorse: WoodenHorse, events: Event[]): boolean {
if(woodenHorse.status == RACE_ACTIVITY_STATUS.END) return false;
if(woodenHorse.status == RACE_ACTIVITY_STATUS.START) {
if(woodenHorse.distance >= GUILDACTIVITY.RACEACTIVITY_LENGTH) {
woodenHorse.distance = GUILDACTIVITY.RACEACTIVITY_LENGTH;
woodenHorse.status = RACE_ACTIVITY_STATUS.END;
woodenHorse.speed = 0;
return true;
}
woodenHorse.distance = Math.floor((woodenHorse.distance + (Date.now() - woodenHorse.time)/1000 * woodenHorse.speed ) * 1000)/1000; // 1位小数点
woodenHorse.time = Date.now();
}
let effectiveEvents = new Array<Event>();
for(let i = 0; i < events.length; i++) {
let event = events[i];
if(event.useDistance() && event.startDistance && woodenHorse.distance > event.startDistance) {
let startTime = Date.now() - Math.floor((woodenHorse.distance - event.startDistance) / woodenHorse.speed);
event.setStartTime(startTime); // 距离生效的事件的实际生效时间，主要用于速度叠加顺序
}
let isEffective = false;
if(event.useTime()) {
if(event.startTime <= Date.now() && event.endTime > Date.now()) {
isEffective = true;
}
if(event.endTime < Date.now()) {
if(event.endTime && event.startTime == event.endTime) {
isEffective = true;
}
let index = events.findIndex(cur => cur.id == event.id);
events.splice(index, 1);
}
}
if(event.useDistance()) {
if(event.startDistance <= woodenHorse.distance && event.endDistance > woodenHorse.distance) {
isEffective = true;
}
if(event.endDistance < woodenHorse.distance) {
if(event.endDistance && event.startDistance == event.endDistance) {
isEffective = true;
}
let index = events.findIndex(cur => cur.id == event.id);
events.splice(index, 1);
}
}
if(isEffective) {
effectiveEvents.push(event);
}
}
effectiveEvents.sort((a, b) => a.startTime - b.startTime);
woodenHorse.speed = GUILDACTIVITY.RACE_INIT_SPEED + woodenHorse.memberCnt * GUILDACTIVITY.RACE_PER_SPEED;
for(let { id, count, endTime } of effectiveEvents) {
this.calEvent(woodenHorse, id, count, endTime);
}
if(woodenHorse.durability <= 0) {
woodenHorse.status = RACE_ACTIVITY_STATUS.BREAK;
woodenHorse.speed = 0;
}
return false;
}
private calEvent(woodenHorse: WoodenHorse, id: number, count: number = 1, endTime?: number) {
let { effect } = gameData.raceActivityEvents.get(id);
switch (id) {
case RACE_EVENT.LIANNU:
if (woodenHorse.shieldTime < Date.now()) {
if (woodenHorse.shield >= count) {
woodenHorse.shield -= count;
} else {
woodenHorse.shield = 0;
woodenHorse.durability -= (count - woodenHorse.shield) * effect[0];
if(woodenHorse.durability > 100) woodenHorse.durability = 100;
if(woodenHorse.durability < 0) woodenHorse.durability = 0;
}
}
break;
case RACE_EVENT.GUISHOUYINFU:
if (woodenHorse.shieldTime < Date.now()) {
woodenHorse.time = endTime;
woodenHorse.speed = effect[1]||0.1;
}
break;
case RACE_EVENT.FENGCHE:
case RACE_EVENT.WUGUIBANYUNFU:
woodenHorse.speed *= Math.pow(1 + effect[0] / 100, count); break;
case RACE_EVENT.LUDUN:
woodenHorse.shield += count * effect[0]; break;
case RACE_EVENT.TIANSHIDUNFU:
woodenHorse.shieldTime = endTime; break;
case RACE_EVENT.JIASU_1:
woodenHorse.speed *= Math.pow(1 + effect[0] / 100, count); break;
case RACE_EVENT.JIASU_2:
woodenHorse.speed += effect[0]; break;
case RACE_EVENT.HUIFU_1:
woodenHorse.durability += effect[0];
if(woodenHorse.durability > 100) woodenHorse.durability = 100;
if(woodenHorse.durability < 0) woodenHorse.durability = 0;
break;
case RACE_EVENT.JIANSU_1:
woodenHorse.speed *= Math.pow(1 - effect[0] / 100, count); break;
case RACE_EVENT.JIANSU_2:
woodenHorse.speed -= effect[0];
if(woodenHorse.speed < 0) woodenHorse.speed = 0;
break;
case RACE_EVENT.SHANGHAI_1:
woodenHorse.durability -= effect[0];
if(woodenHorse.durability > 100) woodenHorse.durability = 100;
if(woodenHorse.durability < 0) woodenHorse.durability = 0;
break;
case RACE_EVENT.ITEM:
let onlineMembers = woodenHorse.members.filter(member => member.isOnline);
let memberCnt = onlineMembers.length;
console.log('##### HANDLE_ITEM', memberCnt, onlineMembers)
let ranMember: WoodenHorseMember[] = getRandEelm(onlineMembers, GUILDACTIVITY.RACEACTIVITY_EVENT_MEMBERCNT);
if(ranMember.length <= 0) ranMember = onlineMembers;
for(let member of ranMember) {
let item = gameData.raceEventItems;
member.addTempItems(item);
}
let normalItems = getRaceEventItems();
for(let [id, {total, max}] of normalItems) {
let randResult = getRandResultByMember(total, max, memberCnt);
for(let i = 0; i < onlineMembers.length; i++) {
let count = randResult.arr[i]||0;
if(count > 0) {
onlineMembers[i].addTempItem({ id, count });
normalItems.get(id).total -= count;
}
}
}
break;
}
}
public joinMember(woodenHorse: WoodenHorse, roleId: string, roleName: string, sid: string, code: string) {
let index = woodenHorse.members.findIndex(cur => cur.roleId == roleId)
if(index == -1) {
let member = new WoodenHorseMember(roleId, roleName, sid, code);
woodenHorse.members.push(member);
woodenHorse.speed++;
woodenHorse.memberCnt++;
return member;
} else {
return woodenHorse.members[index];
}
}
public leaveMemberSid(woodenHorse: WoodenHorse, roleId: string, isQuit = false) {
let index = woodenHorse.members.findIndex(cur => cur.roleId == roleId);
if(index != -1) {
woodenHorse.members[index].leave();
}
if(isQuit) woodenHorse.memberCnt--;
if(woodenHorse.memberCnt < 0) woodenHorse.memberCnt = 0;
}
public setRemainItem(woodenHorse: WoodenHorse, id: number, remain: number, max: number) {
woodenHorse.remainItems.set(id, { total: remain, max });
}
}