演武场和练兵场

game-server/app/services/guildBossService.ts

@@ -0,0 +1,177 @@
+import { BossScriptType, BossScriptModel } from '../db/BossScript';
+import { getTodayZeroPoint, nowSeconds } from '../pubUtils/timeUtil';
+import { lockData } from '../services/redLockService';
+import { findIndex, indexBy, values } from 'underscore';
+import { MailModel, MailType } from '../db/Mail';
+import { getRedis, sismemberAsync, smembersAsync, saddAsync, delAsync, sremAsync } from '../services/redisService';
+import { pinus } from 'pinus';
+import { STATUS } from '../consts/statusCode';
+import { deepCopy, resResult } from '../pubUtils/util';
+import { BattleRecordModel } from '../db/BattleRecord';
+/**
+ * 
+ * @param bossScript 
+ * @param roleId 
+ */
+export async function getBossScriptInfo(bossScript: BossScriptType, roleId:string) {
+    let { warId, ranks,  bossHp, winWarId, winTime, roleIdRecords, guildCode } = bossScript;
+    ranks.sort(function(a, b) {
+        return b.score - a.score + a.time - b.time;
+    });
+    let result:any = {};
+    //1：等待团长开启，2：今日已开启，且boss通关，3：开启中
+    if ( bossScript.bossHp <= 0 ) {
+        if (!!winWarId && winTime > getTodayZeroPoint() && roleIdRecords.indexOf(roleId) == -1) {
+            result = { winWarId };
+            await BossScriptModel.recordRoleIdWhenCheck(guildCode, roleId);
+        }
+        if (bossScript.time < getTodayZeroPoint()) {
+            result.type = 1;
+            return result;
+        } else {
+            result.type = 2;
+            return result;
+        }
+    }
+    let isBattled = false;
+    let myRank = {};
+    
+    ranks.forEach(({roleId: battleRoleId, score, time}, index) => {
+        if (roleId == battleRoleId) {
+            myRank = {roleId, score, rankLv: index + 1};
+            if (time >= getTodayZeroPoint())
+                isBattled = true;
+        }
+        return {roleId, score, rankLv: index + 1};
+    });
+    return {warId, ranks, myRank, bossHp, type: 3, isBattled};
+}
+/**
+ * 战斗结束返回
+ * @param bossScript 
+ * @param roleId 
+ * @param battleNum 
+ */
+export async function getBossScriptWhenEnd(bossScript: BossScriptType, roleId:string, battleNum:number) {
+    let { warId, ranks, bossHp, winWarId, guildCode, recordRanks, winNum } = bossScript;
+    let pushRanks;
+    let result:any = {};
+    if (battleNum == winNum) {
+        pushRanks = deepCopy(recordRanks);
+        result = {warId: winWarId, bossHp: 0, type: 3};
+        await BossScriptModel.recordRoleIdWhenCheck(guildCode, roleId);
+    } else {
+        pushRanks = deepCopy(ranks);
+        result = {warId, bossHp, type: 3};
+    }
+    pushRanks.sort(function(a, b) {
+        return b.score - a.score + a.time - b.time;
+    });
+    let isBattled = false;
+    let myRank = {};
+    pushRanks.forEach(({roleId: battleRoleId, score, time}, index) => {
+        if (roleId == battleRoleId) {
+            myRank = {roleId, score, rankLv: index + 1};
+            if (time >= getTodayZeroPoint())
+                isBattled = true;
+        }
+        return {roleId, score, rankLv: index + 1};
+    });
+    result.myRank = myRank;
+    result.ranks = pushRanks;
+    return result;
+}
+
+/**
+ * 结算战斗
+ * @param code 
+ * @param serverId 
+ * @param dataName 
+ * @param damage 
+ * @param roleId 
+ */
+export async function bossResult(code: string, serverId: string, dataName: string, roleId: string, damage: number) {
+    let res:any = await lockData(serverId, dataName, code);//加锁
+    if (!!res.err) 
+        return true;
+    let {winSettled, ranks, num, warId, bossHp} = await BossScriptModel.findBossScript(code);//锁定关卡信息
+    if (winSettled) {
+        res.releaseCallback();//解锁
+        await BossScriptModel.recordRoleIdWhenCheck(code, roleId);
+        return true;
+    } 
+    let index = findIndex(ranks, {roleId});
+    if (index == -1) {
+        res.releaseCallback();//解锁
+        return false;
+    }
+    ranks[index].score += bossHp; 
+    if (bossHp > damage) {
+        res.releaseCallback();//解锁
+        return true;
+    }
+    let { recordRanks } = await BossScriptModel.updateBossScript(code, { bossHp: 0, winSettled: true, ranks,  recordRanks: ranks, winNum: num, winWarId: warId, roleIdRecords:[roleId]}, );
+    await pushBossHpMessage(code, serverId, 0, true);
+    res.releaseCallback();//数据修改解锁
+    recordRanks.sort(function(a, b) {
+        return b.score - a.score + a.time - b.time;
+    });
+    let mails = new Array<MailType>();
+    let pushMessage = [];
+    recordRanks.forEach(async function({roleId, score}, index){
+        let rankLv = index + 1;
+        const doc = new MailModel();
+        let goods;
+        const mail = Object.assign(doc.toJSON(), {roleId, goods, sendName: '系统', mailId: 1, sendTime: nowSeconds(), content:'恭喜玩家获得演武台第' + rankLv +'名 奖励如下：'});
+        mails.push(mail);
+        let key = 'login_roleId_' + roleId; 
+        let sid = await getRedis(key);
+        if (!!sid) {
+            pushMessage.push({route: 'onMailsAdd', data:[mail], uids: [{uid:roleId, sid}]});
+        }
+    });
+    await MailModel.addMails(mails);
+    pushMessage.forEach(({route, data, uids })=>{
+        pinus.app.channelService.pushMessageByUids(route, resResult(STATUS.SUCCESS, {mails:data}), uids);
+    });
+    return true;
+}
+ 
+export async function addBossScript(code: string, serverId:string, roleId: string) {
+    let loginKey = 'login_roleId_' + roleId; 
+    let sid = await getRedis(loginKey);
+    let key = 'serverId_' + serverId + 'guildCode_' + code;
+    let value = roleId+ '|' + sid;
+    saddAsync(key, [value]);
+}
+
+export async function pushBossHpMessage(code: string, serverId:string, bossHp:number, isDelKey?: boolean ) {
+    let key = 'serverId_' + serverId + 'guildCode_' + code;
+    let members = await smembersAsync(key);
+    members.forEach(member=>{
+        let arr = member.split('|');
+        let uid = arr[0];
+        let sid = arr[1];
+        pinus.app.channelService.pushMessageByUids('onBossHpUpdate', resResult(STATUS.SUCCESS, {bossHp}),  [{uid, sid}]);
+    });
+    if (isDelKey) {
+        delAsync(key);
+    }
+}
+
+export async function checkMemberExists(code: string, serverId:string, roleId: string, battleCode:string ) {
+    let loginKey = 'login_roleId_' + roleId; 
+    let sid = await getRedis(loginKey);
+    let key = 'serverId_' + serverId + 'guildCode_' + code ;
+    let value = roleId+ '|' + sid;
+    let flag = await sismemberAsync(key, value);
+    if (!flag) {
+        const battleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
+        if(!battleRecord || battleRecord.status != 0 || roleId != battleRecord.roleId) {
+            return false;
+        } 
+        addBossScript(code, serverId, roleId);
+        flag = true;
+    }
+    return flag;
+}

game-server/app/services/guildTrainService.ts

@@ -0,0 +1,64 @@
+import { UserGuildModel } from '../db/UserGuild';
+import { getJobInfoById } from '../pubUtils/gamedata';
+import { getTodayZeroPoint, nowSeconds } from '../pubUtils/timeUtil';
+import { GUILD_REPORT_NUM } from '../consts/constModules/guildConst';
+import { GuildTrainType, GuildTrainModel } from '../db/GuildTrain';
+import { findWhere } from 'underscore';
+export async function getUserGuild(roleId: string, code: string) {
+    let userGuild = await UserGuildModel.getMyGuild(roleId,'trainCount trainTime trainRewards');
+    if (!userGuild||userGuild.guildCode != code)
+        return;
+    let { trainCount, trainTime} = userGuild;
+    if (trainTime < getTodayZeroPoint()) {
+        trainCount = 0;
+    }
+    userGuild = await UserGuildModel.updateInfo(roleId, {trainCount, trainTime: nowSeconds()});
+    return userGuild;
+}
+
+export async function recordUserGuild(roleId: string, code: string) {
+    let userGuild = await UserGuildModel.getMyGuild(roleId,'trainCount trainTime trainRewards');
+    if (!userGuild||userGuild.guildCode != code)
+        return;
+    let { trainCount, trainTime} = userGuild;
+    if (trainTime < getTodayZeroPoint()) {
+        trainCount = 0;
+    }
+    userGuild = await UserGuildModel.updateInfo(roleId, {trainCount, trainTime: nowSeconds()});
+    return userGuild;
+}
+
+
+export  function getGuildTrainInfo (guildTrains: Array<GuildTrainType>, roleId: string, trainCount:number, trainRewards: Array<number>) {
+    guildTrains.forEach(({trainId, isComplete, trainScripts, ranks, reports})=>{
+        ranks.sort(function(a, b) {
+            return b.score - a.score;
+        });
+        let myRank = {};
+        ranks.forEach(({roleId: rankRoleId, score}, index)=>{
+            if (roleId == rankRoleId)
+                myRank = {roleId: rankRoleId, score, rankLv: index+1};
+            return {roleId: rankRoleId, score, rankLv: index+1};
+        });
+        let guildTrain = findWhere(guildTrains, { trainId: trainId - 1});
+        if (!!guildTrain) {
+            let lenNum = guildTrain.reports.length;
+            if (lenNum < GUILD_REPORT_NUM)
+                reports = [...guildTrain.reports, ...reports]
+            else {
+                let trainReports = guildTrain.reports.splice(lenNum - GUILD_REPORT_NUM - 1, GUILD_REPORT_NUM);
+                reports = [...trainReports, ...reports]
+            }
+        }
+        return {trainId, isComplete, trainScripts, reports, myRank, ranks};
+    });
+    return { list: guildTrains, trainCount, trainRewards};
+}
+
+export async function lockTrain(code: string, trainId: number) {
+    let guildTrain = await GuildTrainModel.findTrainByTrainIdNotLock(code, trainId);
+    if (!!guildTrain) {
+        return;
+    }
+    
+}

game-server/app/services/redLockService.ts

@@ -1,5 +1,11 @@
+import { localrun } from "pinus/lib/master/starter";
+import { setLock, releaseLock } from './redlockCacheService';
 var Redlock = require('redlock');
-var RedisService = module.exports;
+var _redlockCache;
+
+export function initRedlock (redisClient) {
+    _redlockCache = new RedlockService(redisClient);
+}
 
 export class RedlockService {
     _redisClient: any;
@@ -36,8 +42,22 @@ export class RedlockService {
             console.error('A redis error has occurred:', err);
         });
     }
+    
+}
 
-    getWithModify() {
-        
-    }
+export async function lockData(serverId: string, dataName: string, id: string ) {
+    let key = 'serverId_'+serverId+'_'+dataName+'_'+id;
+    let lockKey = 'locks:' + key;
+    console.log(' lockKey = '+ lockKey);
+    _redlockCache.redlock.lock(lockKey, _redlockCache.ttl).then(function(lock) {
+        setLock(lockKey, lock);
+        return {err: null, releaseCallback: releaseCallback.bind(null, lockKey)};
+    }).catch(function(err) {
+        console.error(err);
+        return { err };
+    });
+}
+
+export async function releaseCallback(lockKey: string) {
+    releaseLock(lockKey);
 }

game-server/app/services/redisService.ts

@@ -9,6 +9,7 @@ import { PvpDefenseModel } from '../db/PvpDefense';
 import { SystemConfigModel } from '../db/SystemConfig';
 import { RankParam } from '../pubUtils/interface';
 import { accessSync } from 'fs';
+import { values } from 'underscore';
 /**
  * 在服务重新启动时，将信息存入redis
  */
@@ -250,4 +251,32 @@ export async function resetPvpRanks() {
     }
 }
 
+// 排行榜是否存在
+export async function smembersAsync(key: string) {
+    const client: Redis.RedisClient = pinus.app.get('redis');
+    const result = await client.smembersAsync(key);
+    return result;
+}
+
+export async function saddAsync(key: string, values: Array<string>) {
+    const client: Redis.RedisClient = pinus.app.get('redis');
+    const result = await client.saddAsync(key, values);
+    return result;
+}
+
+export async function sismemberAsync(key: string, value: string) {
+    const client: Redis.RedisClient = pinus.app.get('redis');
+    const result = await client.sismemberAsync(key, value);
+    return result;
+}
+
+export async function delAsync(key:string) {
+    const client: Redis.RedisClient = pinus.app.get('redis');
+    await client.delAsync(key);
+}
+
+export async function sremAsync(key:string, member:string) {
+    const client: Redis.RedisClient = pinus.app.get('redis');
+    await client.sremAsync(key, member);
+}
 /**************** 寻宝相关 end */

game-server/app/services/redlockCacheService.ts

@@ -0,0 +1,36 @@
+import { fromCallback } from 'bluebird';
+import { scheduleJob } from 'node-schedule';
+import { nowSeconds } from '../pubUtils/timeUtil';
+import  { RedlockService } from '../services/redLockService';
+interface UserCache {
+    time: number;
+    lock: any;
+}
+var userCacheMap = new Map<string, UserCache>();
+
+export function init() {
+    scheduleJob("0/5 * * * * *", clearDirtyData, {name:'clearDirtyData'});
+}
+
+export function clearDirtyData() {
+    userCacheMap.forEach(function(userCache, key) {
+        if(nowSeconds() > userCache.time + 10){
+            console.log('show lock =' + JSON.stringify(userCache.lock));
+            userCacheMap.delete(key);
+        }
+    })
+}
+
+export function releaseLock(lockKey: string) {
+    var userCache = userCacheMap.get(lockKey);
+    if (!!userCache && userCache.lock){
+        // unlock your resource when you are done
+        userCache.lock.unlock();
+    }
+    userCacheMap.delete(lockKey);
+}
+
+
+export function setLock(lockKey: string, lock: any){
+    userCacheMap.set(lockKey, {lock, time: nowSeconds()})
+};