添加主线关卡和每日关卡

game-server/app/servers/battle/handler/battleUtils.ts

@@ -0,0 +1,166 @@
+
+import { ActionPointModel } from '../../../db/ActionPoint';
+import { BattleDropModel } from '../../../db/BattleDrop';
+import { CounterModel } from '../../../db/Counter';
+import { EquipModel } from '../../../db/Equip';
+
+import { getWarById, getGoodById } from '../../../util/gamedata';
+import { decodeStr } from '../../../util/util';
+import { ACTION_POIN, BATTLE_REWARD_TYPE, GOOD_TYPE } from '../../../consts/consts';
+
+export async function getAp(now: number, roleId: string) {
+    let dataAp = await ActionPointModel.getAp(roleId);
+    const maxAp = ACTION_POIN.MAX; // 最大体力值
+    const per = ACTION_POIN.PER; // 恢复时间（ms)
+    let {ap, refTime} = dataAp;
+    if(ap >= maxAp) {
+        // 体力溢出不需要做时间的处理
+        return { ap, maxAp, refTime: now, apRemainTime:0, isOver: true }
+    } else {
+        if(refTime > now) refTime = now; // refTime：每次记录时候最近的一个整的时间点，绝对不会大于now
+        let n = Math.floor((now - refTime)/per); // 上次记录到现在可以增长多少体力
+        ap += n; // 增加上
+        if(ap >= maxAp) { // 加上后溢出了
+            ap = maxAp;
+            return { ap, maxAp, refTime: now, apRemainTime:0, isOver: true }
+        } else {
+            refTime += n * per; // 更新refTime到离现在最近的一个整的时间点
+            let apRemainTime = Math.floor((refTime + per - now)/1000); // 恢复下一点需要多少时间
+            
+            return { ap, maxAp, refTime, apRemainTime, isOver: false }
+        }
+    }
+}
+
+export async function setAp(now: number, roleId: string, changeAp: number) {
+    let ApResult = await getAp(now, roleId);
+    let { ap, maxAp, refTime, apRemainTime, isOver } = ApResult; // 更新ap
+    ap += changeAp;
+    if(ap >= maxAp) { // 溢出
+        refTime = now;
+        apRemainTime = 0;
+    }
+    if(ap < 0) return null // 体力不足
+    await ActionPointModel.saveAp(roleId, ap, refTime);
+
+    if(isOver && ap < maxAp) apRemainTime = Math.floor(ACTION_POIN.PER / 1000); // 特殊处理
+    return {ap, maxAp, refTime, apRemainTime}
+}
+
+export class WarReward {
+    roleId: string;
+    roleName: string;
+    battleId: number;
+    condition: Map<number, boolean>;
+    warInfo: any;
+    isSuccess: boolean;
+    rewards: Array<{type: number, gid: number, count: number}>;
+
+    constructor(roleId: string, roleName: string, battleId: number, isSuccess: boolean) {
+        this.roleId = roleId;
+        this.roleName = roleName;
+        this.battleId = battleId;
+        this.condition = new Map();
+        this.warInfo = getWarById(battleId);
+        this.isSuccess = isSuccess;
+    }
+
+    public setCondition(id: number, isOk: boolean) {
+        this.condition.set(id, isOk);
+    }
+
+    private handleFixReward(num: number) {
+        if(this.isSuccess) { // 成功了才给固定奖励
+            let {fixReward} = this.warInfo;
+            let reward = decodeStr('fixReward', fixReward);
+            for(let obj of reward) this.rewards.push({type: BATTLE_REWARD_TYPE.FIX_REWARD, ...obj, count: obj.count * num});
+        }
+    }
+    private handleConditionReward(num: number) {
+        if(this.isSuccess) {
+            let {conditionReward} = this.warInfo;
+            let reward = decodeStr('conditionReward', conditionReward);
+            for(let obj of reward) {
+                if(this.condition.get(obj.condition)) {
+                    this.rewards.push({type: BATTLE_REWARD_TYPE.CONDITION_REWARD, ...obj, count: obj.count * num});
+                }
+            }
+        }
+    }
+
+    private async handleRandomReward(num: number) {
+        if(this.isSuccess) {
+            let {randomReward} = this.warInfo;
+            let reward = decodeStr('randomReward', randomReward);
+            for(let obj of reward) {
+                let { gid, frequency } = obj;
+                let dropHistory = await BattleDropModel.findByGid(this.roleId, this.battleId, gid);
+                let { getNum = 0, allNum = 0, getSum = 0, allSum = 0 } = dropHistory;
+                for(let i = 0; i < num; i ++) {
+                    let flag = false; // 是否可以获得
+                    if(allNum + 1 > frequency) {
+                        allNum = 0; getNum = 0;
+                    }
+                    allNum++; allSum++;
+                    if(getNum == 0) {
+                        let r = Math.random();
+                        if(r <= 1/frequency*allNum || (allNum >= frequency) ) {
+                            flag = true; // 独立概率随机
+                        }
+                    }
+                    if(flag) {
+                        getNum ++; getSum++;
+                        this.rewards.push({type: BATTLE_REWARD_TYPE.RANDOM_REWARD, ...obj});
+                    }
+                }
+                await BattleDropModel.updateByGid(this.roleId, this.battleId, gid, {
+                    getNum, allNum, getSum, allSum
+                });
+            }
+        }
+    }
+
+    public async saveReward(num: number) {
+        this.rewards = new Array();
+        await this.handleFixReward(num);
+        await this.handleConditionReward(num);
+        await this.handleRandomReward(num);
+
+        let returnGoods = new Array();
+        for(let goods of this.rewards) {
+            let goodInfo = getGoodById(goods.gid);
+            if(goodInfo.good_type == GOOD_TYPE.EQUIP) { // 装备
+                let result = await this.rewardWeapons(goodInfo, {id: goods.gid, cnt: goods.count });
+                for(let obj of result) {
+                    returnGoods.push({dropType: goods.type, ...obj})
+                }
+            }
+        }
+        return returnGoods;
+    }
+
+
+
+    private async rewardWeapons (dicGood: any,  weapon: {id:number,cnt:number }) {
+
+        let weaponsData = [];
+        let cnt = weapon.cnt;
+        while (cnt > 0) {
+            const seqId = await CounterModel.getNewCounter('eid');
+            const equipInfo = {
+                roleId: this.roleId,
+                roleName: this.roleName,
+                eid: weapon.id,
+                eName: dicGood.name,
+                seqId,
+                quality: dicGood.lv,
+                type: dicGood.good_type
+            }
+            const equip = await EquipModel.createEquip(equipInfo);
+            cnt -= 1;
+            weaponsData.push(equip);
+        }
+        return weaponsData;
+    }
+
+}

game-server/app/servers/battle/handler/dailyBattleHandler.ts

@@ -0,0 +1,107 @@
+import { Application, BackendSession } from 'pinus';
+import { DailyRecordModel } from '../../../db/DailyRecord';
+import { BattleRecordModel } from '../../../db/BattleRecord';
+import { getGamedata } from '../../../util/gamedata';
+import { WAR_TYPE } from '../../../consts/consts';
+
+export default function(app: Application) {
+    return new DailyBattleHandler(app);
+}
+
+export class DailyBattleHandler {
+    constructor(private app: Application) {
+    }
+
+    // 获取关卡列表
+    async getData(msg: { }, session: BackendSession) {
+        let roleId = session.get('roleId');
+
+        const BattleRecord = await BattleRecordModel.getBattleList(roleId, WAR_TYPE.DAILY);
+
+        let dicDaily = getGamedata('dic_daily');
+        let dicDailyWar = getGamedata('dic_daily_war');
+
+        let result = new Array();
+        for(let {type, name, sum} of dicDaily) {
+            let refreshResult = await DailyRecordModel.refreshRecord(roleId, type);
+            let {count} = refreshResult;
+            let wars = new Array();
+            for(let {war_id, daily_type, difficulty, cost, gk_name, previousGk } of dicDailyWar) {
+                if(daily_type == type) {
+                    let status = 0, star = 0;
+                    let curBattle = BattleRecord.find(cur => cur.battleId == war_id);
+                    if(curBattle) {
+                        status = 2;
+                        star = curBattle.star;
+                    } else {
+                        if (previousGk) {
+                            let preBattleRecord = BattleRecord.find(cur => cur.battleId == previousGk);
+                            if(preBattleRecord) {
+                                status = 1;
+                            } else {
+                                status = 0;
+                            }
+                        } else {
+                            status = 1;
+                        }
+                    }
+                    wars.push({
+                        battleId: war_id, difficulty, cost, star, status, name: gk_name 
+                    });
+                }
+            }
+
+            result.push({
+                type, count, sum, name,
+                wars
+            });
+        }
+
+        return { code: 200, data: result }
+    }
+
+
+}
+
+// 检查每日本次数checkBattle使用
+export async function checkDaily(roleId: string, battleId: number, inc: number) {
+    let dicDaily = getGamedata('dic_daily');
+    let dicDailyWar = getGamedata('dic_daily_war');
+    let dailyWar = dicDailyWar.find(cur => cur.war_id == battleId);
+    if(!dailyWar) return { status: -1, msg: '未找到该关卡' };
+    let type = dailyWar.daily_type;
+
+    let curDaily = dicDaily.find(cur => cur.type == type);
+    if(!curDaily) return { status: -1, msg: '未找到该类型' };
+    let dailyRecord = await DailyRecordModel.refreshRecord(roleId, type);
+    let { count } = dailyRecord;
+    if(count + inc > curDaily.sum ) {
+        return { status: -1, msg: '次数不足' }
+    }
+    return {status: 1, type, count, sum: curDaily.sum};
+}
+
+// 检查每日本次数warEnd和warSweep使用
+export async function checkDailyAndIncrease(roleId: string, battleId: number, inc: number, isRef: boolean) {
+    let dicDaily = getGamedata('dic_daily');
+    let dicDailyWar = getGamedata('dic_daily_war');
+    let dailyWar = dicDailyWar.find(cur => cur.war_id == battleId);
+    if(!dailyWar) return { status: -1, msg: '未找到该关卡' };
+    let type = dailyWar.daily_type;
+
+    let curDaily = dicDaily.find(cur => cur.type == type);
+    if(!curDaily) return { status: -1, msg: '未找到该类型' };
+
+    let dailyRecord;
+    if(isRef) {
+        dailyRecord = await DailyRecordModel.refreshRecord(roleId, type);
+    } else {
+        dailyRecord = await DailyRecordModel.getDailyRecordById(roleId, type);
+    }
+    let { count } = dailyRecord;
+    if(count + inc > curDaily.sum ) {
+        return { status: -1, msg: '次数不足' }
+    }
+    let result = await DailyRecordModel.increseDailyCount(roleId, type, inc);
+    return {status: 1, type, count: result.count, sum: curDaily.sum};
+}

game-server/app/servers/battle/handler/normalBattleHandler.ts

@@ -1,10 +1,11 @@
 import { Application, BackendSession } from 'pinus';
 import { BattleRecordModel } from '../../../db/BattleRecord';
+import { BattleSweepRecordModel } from '../../../db/BattleSweepRecord';
 import { getWarById, getGoodById } from '../../../util/gamedata';
-import { CounterModel } from '../../../db/Counter';
-import { HeroModel } from '../../../db/Hero';
-import { EquipModel } from '../../../db/Equip';
 import { genCode } from '../../../util/util';
+import { getAp, setAp, WarReward } from './battleUtils';
+import { WAR_TYPE } from '../../../consts/consts';
+import { checkDaily, checkDailyAndIncrease } from './dailyBattleHandler';
 
 export default function(app: Application) {
     return new NormalBattleHandler(app);
@@ -14,25 +15,44 @@ export class NormalBattleHandler {
     constructor(private app: Application) {
     }
 
-    // 进入关卡前，记录信息，生成唯一标识
+    // 获取关卡列表
     async checkBattle(msg: {battleId: number, heroes: Array<any> }, session: BackendSession) {
         const { battleId, heroes } = msg;
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
         let warInfo = getWarById(battleId);
         if(!warInfo) {
-            return {
+            return { code: 202, data: "缺少关卡信息" }
-                code: 202,
+        }
-                data: "缺少关卡信息"
+        if(!warInfo.hasOwnProperty('cost')) {
-            }
+            warInfo['cost'] = 0;
         }
 
+        let apJson = await getAp(Date.now(), roleId);
+        let {ap} = apJson;
+        if(ap < warInfo.cost) {
+            return { code: 202, data: "体力不足" }
+        }
+
+        // 前置关卡是否挑战过
+        let previousGk = warInfo.previousGk;
+        if(previousGk) {
+            let preBattle = await BattleRecordModel.getBattleRecordByIdAndStatus(roleId, previousGk, 1);
+            if(!preBattle) return {code: 202, data: '需要完成上一关才可以挑战'};
+        }
+
+        let dailyNum = {};
+        if(warInfo.war_type == WAR_TYPE.DAILY) {
+            let checkResult = await checkDaily(roleId, battleId, 1);
+            if(checkResult.status == -1) {
+                return {code: 202, data: checkResult.msg}
+            }
+            dailyNum = { type: checkResult.type, count: checkResult.count, sum: checkResult.sum };
+        }
         const battleCode = genCode(8);
         const BattleRecord = await BattleRecordModel.updateBattleRecordByCode(battleCode, {
             $set: {
-                roleId,
+                roleId, roleName, battleId,
-                roleName,
-                battleId,
                 status: 0,
                 warName: warInfo.gk_name,
                 warType: warInfo.war_type,
@@ -42,28 +62,49 @@ export class NormalBattleHandler {
 
         let {status} = BattleRecord;
 
+
         return {
             code: 200,
             data: {
-                battleId, battleCode, status
+                battleId, battleCode, status, apJson, dailyNum
             }
         }
     }
 
-    // 关卡结算，记录使用的武将，获得奖励
+    // 关卡列表
-    async battleEnd(msg: {battleCode: string, battleId: number, isSuccess: boolean, heroes: Array<any>, }, session: BackendSession) {
+    async getBattleList(msg: {type: number }, session: BackendSession) {
+        const { type } = msg;
+        let roleId = session.get('roleId');
 
-        const { battleCode, battleId, isSuccess, heroes } = msg;
+        const BattleRecord = await BattleRecordModel.getBattleList(roleId, type);
+        let result = []; // 去重
+        for(let br of BattleRecord) {
+            let index = result.findIndex(cur => cur.battleId == br.battleId);
+            if(index == -1) {
+                result.push(br);
+            }
+        }
+
+        return { code: 200, data: result }
+    }
+
+    // 关卡结算，记录使用的武将，获得奖励
+    async battleEnd(msg: {battleCode: string, battleId: number, isSuccess: boolean, star: number, heroes: Array<any>, }, session: BackendSession) {
+
+        const { battleCode, battleId, isSuccess, heroes, star } = msg;
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
         let warInfo = getWarById(battleId);
+        if(!warInfo) {
+            return { code: 202, data: "缺少关卡信息" }
+        }
+        if(!warInfo.hasOwnProperty('cost')) {
+            warInfo['cost'] = 0;
+        }
 
         const BattleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
         if(!BattleRecord || BattleRecord.status != 0) {
-            return {
+            return { code: 202, data: '关卡状态错误' }
-                code: 202,
-                data: '关卡状态错误'
-            }
         }
 
         let flag = 1; // 对比hero信息
@@ -72,21 +113,44 @@ export class NormalBattleHandler {
             if(dbHeroes.indexOf(hid) == -1) flag = 0;
         }
         if(!flag) {
-            return {
+            return { code: 202, data: '关卡信息不同' }
-                code: 202,
-                data: '关卡信息不同'
-            }
         }
 
-        let params = {}, reward: Array<any>;
+        const now = Date.now(); // 当前时间戳
+        let apJson = await setAp(now, roleId, -1 * warInfo.cost); // 扣除体力
+        if(!apJson) {
+            return { code: 202, data: '体力不足' }
+        }
+
+        let dailyNum = {};
+        if(warInfo.war_type == WAR_TYPE.DAILY) {
+            let checkResult = await checkDailyAndIncrease(roleId, battleId, 1, false);
+            if(checkResult.status == -1) {
+                return {code: 202, data: checkResult.msg}
+            }
+            dailyNum = { type: checkResult.type, count: checkResult.count, sum: checkResult.sum };
+        }
+
+        let warReward = new WarReward(roleId, roleName, battleId, isSuccess);
+        let params = {};
         if(isSuccess) { // 挑战胜利
             params = {
                 $set: {
                     status: 1,
+                    star,
                     record: { heroes }
                 }
             }
-            reward = await this.handleReward(roleId, roleName, warInfo.reward);
+
+            // 是否首通
+            let condition1 = await BattleRecordModel.getBattleRecordByIdAndStatus(roleId, battleId, 1);
+            if(!condition1) warReward.setCondition(0, true);
+            // 是否首次3星
+            if(star == 3) {
+                let condition2 = await BattleRecordModel.getBattleRecordByIdAndStar(roleId, battleId, 3);
+                if(!condition2) warReward.setCondition(1, true);
+            }
+
         } else { // 挑战失败
             params = {
                 $set: {
@@ -94,9 +158,10 @@ export class NormalBattleHandler {
                     record: { heroes }
                 }
             }
-            reward = [];
         }
 
+        let reward = await warReward.saveReward(1);
+
         const updateResult = await BattleRecordModel.updateBattleRecordByCode(battleCode, params, true);
         let { status } = updateResult;
 
@@ -104,78 +169,71 @@ export class NormalBattleHandler {
             code: 200,
             data: {
                 battleCode, battleId, status,
-                goods: reward
+                goods: reward,
+                apJson,
+                dailyNum
             }
         }
     }
 
-    private async handleReward(roleId: string, roleName: string, rewardStr:string) {
+    async battleSweep(msg: {battleId: number, count: number }, session: BackendSession) {
-        let {weapons, armors, items, souls} = this.decodeReward(rewardStr);
+        
-        let addWeapons = await this.rewardWeapons(roleId, roleName, weapons);
+        const { battleId, count } = msg;
-        // 暂时只处理装备
+        let roleId = session.get('roleId');
-        // let addArmors = await this.rewardArmors(roleId, roleName, armors);
+        let roleName = session.get('roleName');
-        // let addItems = await this.rewardItems(roleId, roleName, items);
+        let warInfo = getWarById(battleId);
-        // let addSouls = await this.rewardSouls(roleId, roleName, souls);
+        if(!warInfo) {
-
+            return { code: 202, data: "缺少关卡信息" }
-        let result = [].concat(addWeapons);
+        }
-        return result;
+        // 校验是否三星通关过
-    }
+        let condition1 = await BattleRecordModel.getBattleRecordByIdAndStar(roleId, battleId, 3);
-
+        if(!condition1) {
-    private async rewardWeapons (roleId: string, roleName:string,  weapons: Array<{id:number,cnt:number, type: number}>) {
+            return { code: 202, data: "需要3星通过关卡才可以扫荡" }
-
-        let weaponsData = [];
-        for (let weapon of weapons) {
-            let cnt = weapon.cnt;
-            let g = getGoodById(weapon.id);
-            while (cnt > 0) {
-                const seqId = await CounterModel.getNewCounter('eid');
-                const equipInfo = {
-                    roleId,
-                    roleName,
-                    eid: weapon.id,
-                    eName: g.name,
-                    seqId,
-                    type: weapon.type,
-                    lv: g.lv
-                }
-                const equip = await EquipModel.createEquip(equipInfo);
-                cnt -= 1;
-                weaponsData.push(equip);
-            }
         }
-        return weaponsData;
-    }
 
-    private decodeReward(rewardStr: string, multiple=1) {
+        // 扣体力
-        let weapons = [];
+        if(!warInfo.hasOwnProperty('cost')) {
-        let armors = [];
+            warInfo['cost'] = 0;
-        let items = [];
+        }
-        let souls = [];
+        const now = Date.now(); // 当前时间戳
-        rewardStr.split('|').forEach((rStr) => {
+        let apJson = await setAp(now, roleId, -1 * warInfo.cost * count); // 扣除体力
-            // r[0]: type, r[1]: id, r[2]: count
+        if(!apJson) {
-            let r = rStr.split('&');
+            return { code: 202, data: '体力不足' }
-            let type = parseInt(r[0] || '')||0;
+        }
-            let id = parseInt(r[1] || '') || 0;
+
-            let cnt = (parseInt(r[2] || '') || 0) * multiple;
+        // 扫荡次数
-            if (id !== 0 && cnt !== 0) {
+        let dailyNum = {};
-                switch (r[0]) {
+        if(warInfo.war_type == WAR_TYPE.DAILY) {
-                case '0':
+            let checkResult = await checkDailyAndIncrease(roleId, battleId, count, true);
-                    items.push({id, cnt, type});
+            if(checkResult.status == -1) {
-                    break;
+                return {code: 202, data: checkResult.msg}
-                case '1':
-                    weapons.push({id, cnt, type});
-                    break;
-                case '2':
-                    armors.push({id, cnt, type});
-                    break;
-                case '3':
-                    souls.push({id, cnt, type});
-                    break;
-                default:
-                    break;
-                }
             }
+            dailyNum = { type: checkResult.type, count: checkResult.count, sum: checkResult.sum };
+        }
+
+        // 发奖励
+        let warReward = new WarReward(roleId, roleName, battleId, true);
+        let result = await warReward.saveReward(count);
+
+        // 扫荡记录
+        await BattleSweepRecordModel.saveBattleSweepRecordById(roleId, battleId, {
+            $set: {
+                roleName, 
+                warName: warInfo.gk_name,
+                warType: warInfo.war_type
+            },
+            $inc: { count }
         });
-        return {weapons, armors, items, souls};
+
+        return {
+            code: 200,
+            data: {
+                battleId, count,
+                goods: result,
+                apJson,
+                dailyNum
+            }
+        }
     }
+
 }

game-server/app/util/gamedata.ts

@@ -29,15 +29,23 @@ export function getGamedata(key) {
 }
 
 export function getWarById(warid) {
-    let warInfo = gamedata['dic_zyz_gk']||[];
+    const wars = ['dic_zyz_gk', 'dic_daily_war', 'dic_event_war']; // 关卡相关的表
-    return warInfo.find(cur => {
+    let result;
-        return cur.war_id == warid
+    for(let filename of wars) {
-    });
+        let warInfo = gamedata[filename]||[];
+        for(let war of warInfo) {
+            if(war.war_id == warid) {
+                result = war; break;
+            }
+        }
+        if(result) break;
+    }
+    return result||[];
 }
 
 export function getGoodById(gid) {
     console.log(gid)
-    let goodsInfo = gamedata['goods']||[];
+    let goodsInfo = gamedata['dic_goods']||[];
     return goodsInfo.find(cur => {
         return cur.good_id == gid
     });

game-server/app/util/util.ts

@@ -1,4 +1,5 @@
 
+  
   export function genCode(len) {
     const chars = '123456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijklmnopqrstuvwxyz';
     const charArr = chars.split('');
@@ -7,4 +8,29 @@
       code += charArr[Math.floor(Math.random() * charArr.length)];
     }
     return code;
+  }
+
+  export function decodeStr(type, str) {
+    if(str == '&') str = '';
+    return str.split('|').map(cur => {
+      let arr = cur.split('&');
+      let result = {};
+      switch (type) {
+        case 'fixReward': {
+          let [gid, count] = arr;
+          result = { gid: parseInt(gid), count: parseInt(count)};
+          break;
+        }
+        case 'conditionReward': {
+          let [gid, count, condition] = arr;
+          result = { gid: parseInt(gid), count: parseInt(count), condition: parseInt(condition) };
+          break;
+        }
+        case 'randomReward': {
+          let [gid, count, frequency] = arr;
+          result = { gid: parseInt(gid), count: parseInt(count), frequency: parseInt(frequency) };
+        }
+      }
+      return result;
+    });
   }

shared/consts/consts.ts

@@ -13,3 +13,24 @@ export const COUNTER = {
   API: 'api',
   GM_GROUP: 'gmgroup'
 };
+
+export const ACTION_POIN = {
+  MAX: 100,
+  PER: 6 * 60 * 1000
+};
+
+export const BATTLE_REWARD_TYPE = {
+  FIX_REWARD: 1,
+  CONDITION_REWARD: 2,
+  RANDOM_REWARD: 3
+};
+
+export const GOOD_TYPE = {
+  EQUIP: 1,
+  ITEM: 2
+};
+
+export const WAR_TYPE = {
+  NORMAL: 1,
+  DAILY: 2
+};

shared/db/ActionPoint.ts

@@ -0,0 +1,32 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop } from '@typegoose/typegoose';
+
+/**
+  * 体力系统 
+*/
+@index({ roleId: 1 })
+
+export default class ActionPoint extends BaseModel {
+    @prop({ required: true })
+    roleId: string;					// 角色 id
+
+    @prop({ required: true })
+    refTime: number;                // 刷新时间，时间戳
+    @prop({ required: true })
+    ap: number;                     // 当前体力
+
+    public static async getAp(roleId: string, lean = true) {
+        let result = await ActionPointModel.findOne({roleId}).select('ap refTime').lean(lean);
+        if(!result) {
+            result = await ActionPointModel.findOneAndUpdate({roleId}, { ap: 0, refTime: 0 }, {new: true, upsert: true}).lean(lean)
+        }
+        return result;
+    }
+  
+    public static async saveAp(roleId: string, ap: number, refTime: number, lean = true) {
+        let result = await ActionPointModel.findOneAndUpdate({roleId}, { ap, refTime }, {upsert: true, new: true}).lean(lean);
+        return result||{};
+    }
+}
+
+export const ActionPointModel = getModelForClass(ActionPoint);

shared/db/BattleDrop.ts

@@ -0,0 +1,38 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop } from '@typegoose/typegoose';
+
+/**
+  * 战斗记录接口
+  */
+@index({ roleId: 1, battleId: 1 })
+
+export default class BattleDrop extends BaseModel {
+  @prop({ required: true })
+  roleId: string;					// 角色 id
+  @prop({ required: true })
+  battleId: number;						// 关卡 id
+  @prop({ required: true })
+  gid: number;						// 关卡 id
+  
+  @prop({ required: true, default: 0 })
+  getNum: number;						// 获取次数，当allNum超过配置次数重置
+  @prop({ required: true, default: 0 })
+  allNum: number;						// 全部次数，当超过配置次数重置
+  @prop({ required: true, default: 0 })
+  getSum: number;						// 获取道具的全部次数
+  @prop({ required: true, default: 0 })
+  allSum: number;						// 全部全部次数，不重置
+
+
+  public static async findByGid(roleId: string, battleId: number, gid: number, lean = true) {
+    const result = await BattleDropModel.findOneAndUpdate({ roleId,  battleId, gid}, {}, {new: true, upsert: true}).lean(lean);
+    return result;
+  }
+
+  public static async updateByGid(roleId: string, battleId: number, gid: number, params: {getNum: number, allNum: number, getSum: number, allSum: number}, lean = true) {
+    const result = await BattleDropModel.findOneAndUpdate({roleId, battleId, gid}, {$set: params}).lean(lean);
+    return result;
+  }
+}
+
+export const BattleDropModel = getModelForClass(BattleDrop);

shared/db/BattleRecord.ts

@@ -21,24 +21,57 @@ export default class BattleRecord extends BaseModel {
   warName: string;						// 关卡 名
   @prop({ required: true })
   warType: number;						// 关卡 类型
-  @prop({ required: true })
+
+  @prop({ required: true, default: 0 })
   status: number;						// 关卡状态 0-挑战中 1-挑战成功 2-挑战失败
+  @prop({ required: true, default: 0 })
+  star: number;						// 关卡状态 0-挑战中 1-挑战成功 2-挑战失败
   @prop({ required: true })
   record: {		              // 使用的武将等记录
     heroes: Array <number>; // 武将id
   };
 
-
   public static async getBattleRecordByCode(battleCode: string, lean = true) {
     const result = await BattleRecordModel.findOne({ battleCode }).lean(lean);
     return result;
   }
 
+  public static async getBattleRecordByIdAndStatus(roleId: string, battleId: number, status: number, lean = true) {
+    const result = await BattleRecordModel.findOne({ roleId, battleId, status }).lean(lean);
+    return result;
+  }
+
+  public static async getBattleRecordByIdAndStar(roleId: string, battleId: number, star: number, lean = true) {
+    const result = await BattleRecordModel.findOne({ roleId, battleId, star: {$lte: star} }).lean(lean);
+    return result;
+  }
+
   public static async updateBattleRecordByCode( battleCode: string, params: object, lean = true) {
     const result = await BattleRecordModel.findOneAndUpdate({ battleCode }, params, {new: true, upsert: true}).lean(lean);
     return result;
   }
 
+  public static async getBattleList( roleId: string, warType: number, lean = true) {
+    const searchObj = { roleId, warType, status: 1 };
+    const count = await BattleRecordModel.countDocuments(searchObj);
+    console.log(roleId, warType, count);
+    const limit = 1000;
+    const page = Math.ceil(count/limit);
+    let result = new Array();
+    for(let i = 0; i < page; i++) {
+      const battleRecords = await BattleRecordModel.find(searchObj)
+      .select('battleId battleCode warType star status')
+      .limit(1000)
+      .skip(1000 * i)
+      .sort({battleId: 1, star: -1, createdAt: -1})
+      .lean(lean);
+      for(let battleRecord of battleRecords) {
+        result.push(battleRecord);
+      }
+    }
+    return result;
+  }
+
 }
 
 export const BattleRecordModel = getModelForClass(BattleRecord);

shared/db/BattleSweepRecord.ts

@@ -0,0 +1,32 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop } from '@typegoose/typegoose';
+
+/**
+  * 战斗记录接口
+  */
+@index({ roleId: 1, battleId: 1 })
+
+export default class BattleSweepRecord extends BaseModel {
+  @prop({ required: true })
+  roleId: string;					// 角色 id
+  @prop({ required: true })
+  roleName: string;				// 角色名称
+
+  @prop({ required: true })
+  battleId: number;						// 关卡 id
+  @prop({ required: true })
+  warName: string;						// 关卡 名
+  @prop({ required: true })
+  warType: number;						// 关卡 类型
+
+  @prop({ required: true, default: 0 })
+  count: number;						// 扫荡次数
+
+  public static async saveBattleSweepRecordById(roleId: string, battleId: number, params: any, lean = true) {
+    const result = await BattleSweepRecordModel.findOneAndUpdate({ roleId, battleId }, params, {new: true, upsert: true}).lean(lean);
+    return result;
+  }
+
+}
+
+export const BattleSweepRecordModel = getModelForClass(BattleSweepRecord);

shared/db/DailyRecord.ts

@@ -0,0 +1,43 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop } from '@typegoose/typegoose';
+
+/**
+  * 战斗记录接口
+  */
+@index({ roleId: 1, type: 1 })
+
+export default class DailyRecord extends BaseModel {
+  @prop({ required: true })
+  roleId: string;					// 角色 id
+  @prop({ required: true })
+  type: number;						// 每日类型
+  @prop({ required: true, default: 0 })
+  count: number;          // 挑战次数
+  @prop({ required: true, default: 0 })
+  refTime: number;				// 刷新时间
+
+  public static async getDailyRecordById(roleId: string, type: number, lean = true) {
+    const result = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {}, {new: true, upsert: true}).select('count refTime').lean(lean);
+    return result;
+  }
+
+  public static async refreshRecord(roleId: string, type: number, lean = true) {
+    const dailyRecord = await DailyRecordModel.findOne({ roleId, type }).lean(lean);
+    let {count = 0, refTime = 0} = dailyRecord||{};
+    let now = new Date();
+    let today = now.setHours(0, 0, 0, 0);
+    if(today > refTime) {
+        refTime = today;
+        count = 0;
+    }
+    let result = await DailyRecordModel.findOneAndUpdate({roleId, type}, {$set: {refTime, count}}, {new: true, upsert: true});
+    return result;
+  }
+
+  public static async increseDailyCount(roleId: string, type: number, count: number, lean = true) {
+    const result = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {$inc: { count } }, {new: true, upsert: true}).lean(lean);
+    return result;
+  }
+}
+
+export const DailyRecordModel = getModelForClass(DailyRecord);

shared/db/Equip.ts

@@ -21,6 +21,8 @@ export default class Equip extends BaseModel {
   @prop({ required: false })
   hid: number;						// 装备此装备的武将 id
 
+  @prop({ required: true, default: 1 })
+  quality: number;				// 品质
   @prop({ required: true, default: 1 })
   lv: number;							// 强化等级
   @prop({ required: false, default: [] })

shared/resource/dic_daily.json

@@ -0,0 +1,7 @@
+[
+    {
+        "type": 1,
+        "name": "资源本",
+        "sum": 3
+    }
+]

shared/resource/dic_daily_war.json

@@ -0,0 +1,24 @@
+[
+    {
+        "war_id": 1000,
+        "war_type": 2,
+        "daily_type": 1,
+        "difficulty": 1,
+        "gk_name": "每日资源本A",
+        "cost": 1,
+        "fixReward": "1&1",
+        "conditionReward": "2&1&1|1&1&0",
+        "randomReward": "3&1&2"
+    },
+    {
+        "war_id": 1001,
+        "war_type": 2,
+        "daily_type": 1,
+        "difficulty": 2,
+        "gk_name": "每日资源本B",
+        "cost": 1,
+        "fixReward": "1&50",
+        "conditionReward": "2&1&1|1&1&0",
+        "randomReward": "3&1&2"
+    }
+]

shared/resource/dic_event.json

@@ -0,0 +1,8 @@
+[
+    {
+        "event_id": 1,
+        "type": 1,
+        "quality": 1,
+        "war_id": 2000
+    }
+]

shared/resource/dic_event_war.json

@@ -0,0 +1,10 @@
+[
+    {
+        "war_id": 2000,
+        "war_type": 3,
+        "gk_name": "奇遇",
+        "fixReward": "1&50",
+        "conditionReward": "2&10&1|1&10&0",
+        "randomReward": "3&10&2"
+    }
+]

shared/resource/dic_goods.json

@@ -0,0 +1,20 @@
+[
+    {
+        "good_id": 1,
+        "name": "青铜短剑",
+        "lv": 1,
+        "good_type": 1
+    },
+    {
+        "good_id": 2,
+        "name": "黑铁剑",
+        "lv": 2,
+        "good_type": 1
+    },
+    {
+        "good_id": 3,
+        "name": "饿狼长剑",
+        "lv": 3,
+        "good_type": 1
+    }
+]