形象：头像相框形象字段

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

@@ -22,7 +22,7 @@ import { roleLevelup } from '../../../services/normalBattleService';
 import { addUserToChannel } from '../../../services/roleService';
 import { ChannelUser } from '../../../domain/ChannelUser';
 import { pushComBtlTeamMsg, pushNormalEquipMsg, pushTeamInviteMsg } from '../../../services/chatService';
-
+import { FIGURE } from '../../../pubUtils/dicParam';
 export default function(app: Application) {
     return new ComBattleHandler(app);
 }
@@ -173,7 +173,7 @@ export class ComBattleHandler {
         if (!teamStatus || teamStatus.status !== COM_TEAM_STATUS.DEFAULT) return resResult(STATUS.COM_BATTLE_TEAM_INVALID);
         if (teamIsFullToStart(teamStatus)) return resResult(STATUS.COM_BATTLE_MEMBER_LIMIT);
         if (teamStatus.roleIds.indexOf(roleId) !== -1) return resResult(STATUS.COM_BATTLE_DUP_ENTER);
-        let { lv = 1, headHid = 19, topLineupCe = 0, sHid = 19 } = await Role.findByRoleId(roleId, null, true);
+        let { lv = 1, head = FIGURE.DEFAULT_HEAD, topLineupCe = 0, frame = FIGURE.DEFAULT_FRAME, spine = FIGURE.DEFAULT_SPINE } = await Role.findByRoleId(roleId, null, true);
 
         let { quality } = getGoodById(teamStatus.blueprtId);
         if (lv < COM_BTL_CONST.ENABLE_LV) {
@@ -190,7 +190,7 @@ export class ComBattleHandler {
 
         // 加入队伍
         if (!validToJoin(teamStatus, roleId)) return resResult(STATUS.COM_BATTLE_TEAM_INVALID);
-        let roleStatus = new RoleStatus(roleId, roleName, false, isFrd, headHid, sHid, topLineupCe, lv);
+        let roleStatus = new RoleStatus(roleId, roleName, false, isFrd, head, frame, spine, topLineupCe, lv);
         const team = await ComBattleTeamModel.addRole(teamCode, roleStatus);
         if (!team) {
             return resResult(STATUS.COM_BATTLE_JOIN_ERR);

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

@@ -62,7 +62,7 @@ export class PvpHandler {
         const role = await RoleModel.findByRoleId(roleId);
 
         // 加入排行榜
-        let params = new RankParam(roleName, role.lv, role.vLv, role.headHid, role.sHid, role.title);
+        let params = new RankParam(roleName, role.lv, role.vLv, role.head, role.frame, role.spine, role.title);
         await setRank(REDIS_KEY.PVP_RANK, 0, roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
         return resResult(STATUS.SUCCESS, {score, hisScore, heroScores});
     }
@@ -284,7 +284,7 @@ export class PvpHandler {
         let result = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
 
         // 加入排行榜
-        let params = new RankParam(roleName, role.lv, role.vLv, role.headHid, role.sHid, role.title);
+        let params = new RankParam(roleName, role.lv, role.vLv, role.head, role.frame, role.spine,role.title);
         await setRank(REDIS_KEY.PVP_RANK, 0, roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
         let myRank = await getMyRank(REDIS_KEY.PVP_RANK, 0, roleId);
         
@@ -376,8 +376,8 @@ export class PvpHandler {
         if(!myRank) {
             let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
             let role = await RoleModel.findByRoleId(roleId);
-            let { lv, vLv, headHid, sHid, title} = role;
+            let { lv, vLv, head, frame, spine, title} = role;
-            let rankRank = new RankParam(roleName, lv, vLv, headHid, sHid, title);
+            let rankRank = new RankParam(roleName, lv, vLv, head, frame, spine, title);
             myRank = {
                 rank: 0, roleId, ...rankRank, num: pvpDefense.score, str: ''
             }

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

@@ -35,8 +35,8 @@ export class TowerBattleHandler {
             towerLv = 1;
             let role = await RoleModel.towerLvUp(roleId);
             // 更新redis
-            let { roleName, towerUpTime, lv, vLv, headHid, sHid, title } = role;
+            let { roleName, towerUpTime, lv, vLv, head, frame, spine, title } = role;
-            let rankRank = new RankParam(roleName, lv, vLv, headHid, sHid, title);
+            let rankRank = new RankParam(roleName, lv, vLv, head, frame, spine, title);
             await setRank(REDIS_KEY.TOWER_RANK, serverId, roleId, towerLv, towerUpTime.getTime(), rankRank);
 
         }
@@ -322,9 +322,9 @@ export class TowerBattleHandler {
         let {ranks, myRank} = await getRank(REDIS_KEY.TOWER_RANK, serverId, roleId);
         if(!myRank) {
             let role = await RoleModel.findByRoleId(roleId);
-            let {towerLv, lv, vLv} = role;
+            let {towerLv, lv, vLv, head, frame, spine } = role;
             myRank = {
-                rank: 0, roleId, roleName, lv, vLv,guildName: "", head: "zhaoyun", num: towerLv, str: ''
+                rank: 0, roleId, roleName, lv, vLv,guildName: "", head, frame, spine, num: towerLv, str: ''
             }
         }
 

game-server/app/servers/chat/remote/guildRemote.ts

@@ -186,8 +186,8 @@ export class GuildRemote {
      * @param oldLeaderId 旧团长
      */
     public changeLeader (guildCode: string, managerCnt: number, newLeader: RoleType, oldLeaderId: string) {
-        let { roleId, roleName, sHid, headHid, lv, quitTime } = newLeader;
+        let { roleId, roleName, frame, head, spine, lv, quitTime } = newLeader;
-        this.updateInfo(guildCode, {managerCnt, leader: { roleId, roleName, sHid, headHid, lv, quitTime }});
+        this.updateInfo(guildCode, {managerCnt, leader: { roleId, roleName, frame, head, spine, lv, quitTime }});
         this.demotion(guildCode, oldLeaderId);
         this.promotion(guildCode, roleId);
     }

game-server/app/servers/connector/handler/entryHandler.ts

@@ -46,6 +46,7 @@ export class EntryHandler {
         }
 
         let role = await RoleModel.findByUid(user.uid, serverId, ROLE_SELECT.ENTRY, true);
+        console.log('****', role.heads, role.head)
         if (!role) {
             return resResult(STATUS.ROLE_NOT_FOUND);
         }

game-server/app/servers/role/handler/roleHandler.ts

@@ -5,7 +5,7 @@ import { resResult, decodeIdCntArrayStr, parseGoodStr } from '../../../pubUtils/
 import {Application, BackendSession, pinus} from 'pinus';
 import { handleCost } from '../../../services/rewardService';
 import { getTitle, getTeraph, gameData, getScollByStar, getFriendLvByExp } from '../../../pubUtils/data';
-import { SCHOOL, SCROLL } from '../../../pubUtils/dicParam';
+import { SCHOOL, SCROLL, FIGURE } from '../../../pubUtils/dicParam';
 import { getAtrrNameById } from '../../../consts/constModules/abilityConst'
 import { findIndex } from 'underscore';
 import { SclResultInter, SclPosInter } from '../../../pubUtils/interface';
@@ -72,8 +72,8 @@ export class RoleHandler {
 
     async getRoleInfo(msg: {targetRoleId: string}, session: BackendSession) {
         let { targetRoleId } = msg;
-        let { roleId, roleName, headHid = 1, ce = 0, topLineup, topLineupCe = 0 } = await RoleModel.findByRoleId(targetRoleId);
+        let { roleId, roleName, head = FIGURE.DEFAULT_HEAD, frame = FIGURE.DEFAULT_FRAME, spine = FIGURE.DEFAULT_SPINE, ce = 0, topLineup, topLineupCe = 0 } = await RoleModel.findByRoleId(targetRoleId);
-        return resResult(STATUS.SUCCESS, { roleId, roleName, headHid, ce, topLineup, topLineupCe });
+        return resResult(STATUS.SUCCESS, { roleId, roleName, head, frame, spine, ce, topLineup, topLineupCe });
     }
 
     //爵位

game-server/app/services/battleService.ts

@@ -73,8 +73,8 @@ export async function towerBattleEnd(sid: string, roleId: string, serverId: numb
         if (inc === 1) {
             let role = await RoleModel.towerLvUp(roleId);
             // 更新redis
-            let { roleName, towerLv, towerUpTime, lv, vLv, headHid, sHid, title } = role;
+            let { roleName, towerLv, towerUpTime, lv, vLv, head, frame, spine, title } = role;
-            let rankRank = new RankParam(roleName, lv, vLv, headHid, sHid, title);
+            let rankRank = new RankParam(roleName, lv, vLv, head, frame, spine, title);
             await setRank(REDIS_KEY.TOWER_RANK, serverId, roleId, towerLv, towerUpTime.getTime(), rankRank);
 
             const nextTowerInfo = getTowerDataByLv(towerLv + 1);

game-server/app/services/comBattleService.ts

@@ -14,7 +14,7 @@ import { getRandEelm, getRandValue, resResult, ratioReward, getRandValueByMinMax
 import { getRandRobot, transBossHpArr } from "./battleService";
 import { difference, omit } from 'underscore';
 import { Channel, ChannelService } from 'pinus';
-import { TREASURE } from '../pubUtils/dicParam';
+import { TREASURE, FIGURE } from '../pubUtils/dicParam';
 import { decreaseItems } from './rewardService';
 import { getFriendLvAdd } from './friendService';
 import { getRoleIds } from '../pubUtils/friendUtil';
@@ -56,9 +56,9 @@ export function getRandComBtlRobots(topLineupCe: number, ceLimit: number, lv: nu
                 robotCe = getRandValue(topLineupCe || 0, COM_BTL_CONST.ROBOT_CE_RATIO, 0);
             }
             const robotLv = getRandValue(lv, COM_BTL_CONST.ROBOT_CE_RATIO, 0);
-            const imgHid = robot[Math.floor(Math.random() * robot.length)];
+            // const imgHid = robot[Math.floor(Math.random() * robot.length)];
             const { robotRoleId, robotRoleName } = robotInfos[idx];
-            let robotStatus = new RoleStatus(robotRoleId, robotRoleName, false, false, imgHid, imgHid, robotCe, robotLv, robot, true);
+            let robotStatus = new RoleStatus(robotRoleId, robotRoleName, false, false, FIGURE.DEFAULT_HEAD, FIGURE.DEFAULT_FRAME, FIGURE.DEFAULT_SPINE, robotCe, robotLv, robot, true);
             robotStArr.push(robotStatus);
             robotIdArr.push(robotRoleId);
         });
@@ -490,12 +490,13 @@ async function teammateValid(roleInfo: Partial<RoleType>, roleId: string, roleId
  */
 export async function getValidTeammateRoleSt(roleId: string, roleIds: string[], ceLimit: number, quality: number) {
     let roleInfo = await RoleModel.findByRoleId(roleId, null, true);
-    let { roleName, headHid = 19, sHid = 19, topLineupCe, lv } = roleInfo;
+    let { roleName, head = FIGURE.DEFAULT_HEAD, frame = FIGURE.DEFAULT_FRAME, spine = FIGURE.DEFAULT_SPINE, topLineupCe, lv } = roleInfo;
+
     const valid = await teammateValid(roleInfo, roleId, roleIds, ceLimit);
     if (!valid) return null;
 
     let isFrd = await getFrd(roleId, quality);
-    const result = new RoleStatus(roleId, roleName, false, isFrd, headHid, sHid, topLineupCe, lv);
+    const result = new RoleStatus(roleId, roleName, false, isFrd, head, frame, spine, topLineupCe, lv);
     return result;
 }
 
@@ -573,9 +574,9 @@ export async function hasEnoughBlueprt(roleId: string, blueprtId: number) {
  * @param {boolean} isFrd
  */
 export function addRoleToTeam(comTeam: MemComBtlTeam, roleInfo: RoleType, isCap: boolean, isFrd: boolean) {
-    const { roleId, roleName, headHid = 19, sHid = 19, lv } = roleInfo;
+    const { roleId, roleName, head = FIGURE.DEFAULT_HEAD, frame = FIGURE.DEFAULT_FRAME, spine = FIGURE.DEFAULT_SPINE, lv } = roleInfo;
     let { topLineupCe = 1000 } = roleInfo;
-    const roleSt = new RoleStatus(roleId, roleName, isCap, isFrd, headHid, sHid, topLineupCe, lv);
+    const roleSt = new RoleStatus(roleId, roleName, isCap, isFrd, head, frame, spine, topLineupCe, lv);
     addRoleStToTeam(comTeam, roleSt);
 }
 

game-server/app/services/pvpService.ts

@@ -44,8 +44,8 @@ export async function initPvpInfo(role: RoleType) {
     let result = await PvpDefenseModel.createPvpDefense({ roleId: role.roleId, roleName: role.roleName, role: role._id, heroes, oppPlayers, defCe, seasonNum, challengeCnt });
 
     //加入排行榜 
-    let { roleId, roleName, lv, vLv, headHid, sHid, title  } = role;
+    let { roleId, roleName, lv, vLv, head, frame,spine, title  } = role;
-    let params = new RankParam(roleName, lv, vLv, headHid, sHid, title);
+    let params = new RankParam(roleName, lv, vLv, head, frame, spine, title);
     await setRank(REDIS_KEY.PVP_RANK, 0, roleId, result.score, result.updatedAt.getTime(), params);
 
     return result;
@@ -70,7 +70,7 @@ export async function getEnemies(oppPlayers: OppPlayers[], winStreakNum: number)
     let result = new Array<oppPlayersInter>();
     for(let oppPlayer of oppPlayers) {
         let dicOpponent = dicPvpOpponent.get(oppPlayer.pos);
-        let oppDef = <PvpHistoryOppType>oppPlayer.oppDef; // select 'oppRoleId pos roleName headHid sHid rankLv pLv defCe'
+        let oppDef = <PvpHistoryOppType>oppPlayer.oppDef; // select 'oppRoleId pos roleName head frame spine rankLv pLv defCe'
         delete oppDef.heroes;
         result.push({
             ...oppDef,
@@ -573,8 +573,9 @@ export async function generMyRecInfo(heroScores: HeroScores[], winStreakNum: num
         roleId,
         roleName,
         lv: role.lv,
-        sHid: role.sHid,
+        head: role.head,
-        headHid: role.headHid,
+        frame: role.frame,
+        spine: role.spine,
         title: role.title,
         ce: reduceCe(role.topLineupCe),
         heroes: myHeroRecords,
@@ -601,8 +602,9 @@ export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayers,
         roleId: robotIdComBack(oppRole.oppRoleId),
         roleName: oppRole.roleName,
         lv: oppRole.lv,
-        sHid: oppRole.sHid,
+        head: oppRole.head,
-        headHid: oppRole.headHid,
+        frame: oppRole.frame,
+        spine: oppRole.spine,
         title: oppRole.title,
         ce: reduceCe(oppRole.defCe),
         heroes: oppHeroRecords,

game-server/app/services/redisService.ts

@@ -77,20 +77,20 @@ export async function initSingleRankWithServer(key: string, serverId: number) {
  */
 async function setRankRedisFromDb(type: string, serverId: number) {
     if(type == REDIS_KEY.TOWER_RANK) {
-        let ranks = await RoleModel.getRank('tower', serverId, ['roleId', 'roleName', 'towerLv', 'lv', 'vLv', 'headHid', 'sHid', 'title', 'updatedAt']);
+        let ranks = await RoleModel.getRank('tower', serverId, ['roleId', 'roleName', 'towerLv', 'lv', 'vLv', 'head', 'frame', 'spine','title', 'updatedAt']);
-        for(let {towerLv, roleId, roleName, lv, vLv, towerUpTime, headHid, sHid, title} of ranks) {
+        for(let {towerLv, roleId, roleName, lv, vLv, towerUpTime, head, frame, spine, title} of ranks) {
             // console.log(roleId);
             await redisClient().zaddAsync(getKeyName(REDIS_KEY.TOWER_RANK, serverId), encodeScoreWithTime(towerLv, towerUpTime?towerUpTime.getTime():0), roleId);
-            let rankPram = new RankParam(roleName, lv, vLv, headHid, sHid, title);
+            let rankPram = new RankParam(roleName, lv, vLv, head, frame, spine, title);
             await redisUserInfoAdd(REDIS_KEY.USER_INFO, roleId, rankPram);
         }
     } else if (type == REDIS_KEY.GUILD_ACTIVE_RANK) {
         let ranks = await GuildModel.getRank(serverId);
         for(let { code, icon, name, lv, leader, activeWeekly = 0, activeUpdateTime = 0 } of ranks) {
             let _leader = <RoleType>leader;
-            let { roleName, title, sHid, headHid, lv: leaderLv } = _leader;
+            let { roleName, title, head, frame, spine, lv: leaderLv } = _leader;
             await redisClient().zaddAsync(getKeyName(REDIS_KEY.GUILD_ACTIVE_RANK, serverId), encodeScoreWithTime(activeWeekly, activeUpdateTime * 1000 ), code);
-            let rankParam = new GuildRankParam(icon, name, lv, { roleName, title, sHid, headHid, lv: leaderLv });
+            let rankParam = new GuildRankParam(icon, name, lv, { roleName, title, head, frame, spine, lv: leaderLv });
             await redisUserInfoAdd(REDIS_KEY.GUILD_INFO, code, rankParam);
         }
     }
@@ -444,12 +444,12 @@ export async function resetPvpRanks() {
         if (!role) {
             continue;
         }
-        let { roleName, headHid, sHid, title, lv, vLv } = role;
+        let { roleName, head, frame, spine, title, lv, vLv } = role;
         await redisClient().zaddAsync(getKeyName(REDIS_KEY.PVP_RANK), encodeScoreWithTime(score, updatedAt?updatedAt.getTime():0), roleId);
         
         const hasCurUser = await redisClient().hexistsAsync(REDIS_KEY.USER_INFO, roleId);
         if(!hasCurUser) {
-            let rankPram = new RankParam(roleName, lv, vLv, headHid, sHid, title);
+            let rankPram = new RankParam(roleName, lv, vLv, head, frame, spine, title);
             await redisUserInfoAdd(REDIS_KEY.USER_INFO, roleId, rankPram);
         }
     }

game-server/app/services/rewardService.ts

@@ -131,7 +131,7 @@ export async function addItems(roleId: string, roleName: string, sid: string, go
                 currencysMap[key] += role[key];
             }
         }
-        RoleModel.updateRoleInfo(roleId, currencysMap);
+        await RoleModel.updateRoleInfo(roleId, currencysMap);
         pinus.app.get('channelService').pushMessageByUids('onPlayerDataChange', resResult(STATUS.SUCCESS, currencysMap), uids);
     }
 

game-server/app/services/timeTaskService.ts

@@ -184,8 +184,8 @@ export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: num
     let rankLv = resultMaxRank.min;   //最大排名挡位结算
     let {score, pLv, heroScores, challengeCnt, challengeRefTime, rankGoods, heroGoods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime, rankLv);
     pvpDefense = await PvpDefenseModel.updateInfoAndInclude(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime});
-    let { roleName, lv, vLv, headHid, sHid, title , roleId } = role;
+    let { roleName, lv, vLv, head, frame, spine, title, roleId } = role;
-    let params = new RankParam(roleName, lv, vLv, headHid, sHid, title);
+    let params = new RankParam(roleName, lv, vLv, head, frame, spine, title);
     setRank(REDIS_KEY.PVP_RANK, 0, roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
     //下发邮件
     if (!!rankGoods.length) 

game-server/test/comBattle.test.ts

@@ -89,7 +89,7 @@ describe('寻宝创建队伍', function() {
       expect(res.data.teamCode).to.be.a('string');
       expect(res.data.roleStatus).to.be.an('array');
       res.data.roleStatus.forEach(roleSt => {
-        expect(roleSt).to.have.all.keys('roleId', 'roleName', 'isCap', 'isFrd', 'headHid', 'sHid', 'topLineupCe', 'lv', 'isRobot', 'heroes', 'killed', 'totalDmg', 'frdRatio');
+        expect(roleSt).to.have.all.keys('roleId', 'roleName', 'isCap', 'isFrd', 'head', 'frame', 'spine', 'topLineupCe', 'lv', 'isRobot', 'heroes', 'killed', 'totalDmg', 'frdRatio');
       });
       pinusClientT.request('battle.comBattleHandler.searchTeam', searchTeamParms, (searchRes) => {
         // console.log('searchRes:', searchRes);
@@ -125,7 +125,7 @@ describe('寻宝创建队伍', function() {
           expect(res.data.teamCode).to.be.a('string');
           expect(res.data.roleStatus).to.be.an('array');
           res.data.roleStatus.forEach(roleSt => {
-            expect(roleSt).to.have.all.keys('roleId', 'roleName', 'isCap', 'isFrd', 'headHid', 'sHid', 'topLineupCe', 'lv', 'isRobot', 'heroes', 'killed', 'totalDmg', 'frdRatio');
+            expect(roleSt).to.have.all.keys('roleId', 'roleName', 'isCap', 'isFrd', 'head', 'frame', 'spine', 'topLineupCe', 'lv', 'isRobot', 'heroes', 'killed', 'totalDmg', 'frdRatio');
           });
           const roleIds = res.data.roleStatus.map(roleSt => { return roleSt.roleId });
           if (roleIds.indexOf(roleInfoT.roleId) === -1) {
@@ -147,7 +147,7 @@ describe('寻宝创建队伍', function() {
       expect(res.data.teamCode).to.be.a('string');
       expect(res.data.roleStatus).to.be.an('array');
       res.data.roleStatus.forEach(roleSt => {
-        expect(roleSt).to.have.all.keys('roleId', 'roleName', 'isCap', 'isFrd', 'headHid', 'sHid', 'topLineupCe', 'lv', 'isRobot', 'heroes', 'killed', 'totalDmg', 'frdRatio');
+        expect(roleSt).to.have.all.keys('roleId', 'roleName', 'isCap', 'isFrd', 'head', 'frame', 'spine', 'topLineupCe', 'lv', 'isRobot', 'heroes', 'killed', 'totalDmg', 'frdRatio');
       });
       pinusClient.request('battle.comBattleHandler.dismiss', {teamCode: res.data.teamCode}, (dismissRes) => {
         expect(dismissRes).to.be.an('object');

game-server/test/guild.test.ts

@@ -69,8 +69,8 @@ describe('军团测试', function() {
         
         expect(res.data).to.have.deep.property('leader').that.is.an('object');
         expect(res.data.leader).to.have.deep.property('roleName').that.is.an('string');
-        expect(res.data.leader).to.have.deep.property('sHid').that.is.an('number');
+        expect(res.data.leader).to.have.deep.property('frame').that.is.an('number');
-        expect(res.data.leader).to.have.deep.property('headHid').that.is.an('number');
+        expect(res.data.leader).to.have.deep.property('head').that.is.an('number');
         expect(res.data.leader).to.have.deep.property('lv').that.is.an('number');
         expect(res.data.leader).to.have.deep.property('ce').that.is.an('number');
         // expect(res.data.leader).to.have.deep.property('loginTime').that.is.an('number');
@@ -100,8 +100,8 @@ describe('军团测试', function() {
         expect(list).to.have.deep.property('roleId').that.is.a('string');
         expect(list).to.have.deep.property('roleName').that.is.a('string');
         expect(list).to.have.deep.property('ce').that.is.a('number');
-        expect(list).to.have.deep.property('headHid').that.is.a('number');
+        expect(list).to.have.deep.property('head').that.is.a('number');
-        expect(list).to.have.deep.property('sHid').that.is.a('number');
+        expect(list).to.have.deep.property('frame').that.is.a('number');
         expect(list).to.have.deep.property('lv').that.is.a('number');
         expect(list).to.have.deep.property('title').that.is.a('number');
         expect(list).to.have.deep.property('loginTime').that.is.a('number');
@@ -119,8 +119,8 @@ describe('军团测试', function() {
         expect(list).to.have.deep.property('roleId').that.is.a('string');
         expect(list).to.have.deep.property('roleName').that.is.a('string');
         expect(list).to.have.deep.property('ce').that.is.a('number');
-        expect(list).to.have.deep.property('headHid').that.is.a('number');
+        expect(list).to.have.deep.property('head').that.is.a('number');
-        expect(list).to.have.deep.property('sHid').that.is.a('number');
+        expect(list).to.have.deep.property('frame').that.is.a('number');
         expect(list).to.have.deep.property('lv').that.is.a('number');
         expect(list).to.have.deep.property('title').that.is.a('number');
         // expect(list).to.have.deep.property('loginTime').that.is.a('number');
@@ -142,8 +142,8 @@ describe('军团测试', function() {
           expect(list).to.have.deep.property('roleId').that.is.a('string');
           expect(list).to.have.deep.property('roleName').that.is.a('string');
           expect(list).to.have.deep.property('ce').that.is.a('number');
-          expect(list).to.have.deep.property('headHid').that.is.a('number');
+          expect(list).to.have.deep.property('head').that.is.a('number');
-          expect(list).to.have.deep.property('sHid').that.is.a('number');
+          expect(list).to.have.deep.property('frame').that.is.a('number');
           expect(list).to.have.deep.property('lv').that.is.a('number');
           expect(list).to.have.deep.property('title').that.is.a('number');
           // expect(list).to.have.deep.property('loginTime').that.is.a('number');

shared/consts/constModules/selectConst.ts

@@ -1,17 +1,17 @@
 
 export enum ROLE_SELECT {
    // 初始登录数据
-   ENTRY = 'serverId userInfo.uid userInfo.tel userInfo.serverType ce topLineupCe teraphs roleId roleName tili lv exp gold coin vLv title hasGuild funcs eventStatus guildCode',
+   ENTRY = 'serverId userInfo.uid userInfo.tel userInfo.serverType ce topLineupCe teraphs roleId roleName tili lv exp gold coin vLv title hasGuild funcs eventStatus heads head frames frame spine guildCode',
    // 玩家列表显示基础数据
-   SHOW_SIMPLE = 'roleId roleName ce headHid sHid lv title job quitTime vLv guildName serverId userInfo.serverType',
+   SHOW_SIMPLE = 'roleId roleName ce head frame spine lv title job quitTime vLv guildName serverId userInfo.serverType',
    // 显示申请需要的信息
-   SHOW_FRIEND_APPLY_LIST = 'roleId roleName ce headHid sHid lv title job quitTime vLv guildName friendCnt recFrdApplyCnt serverId userInfo.serverType',
+   SHOW_FRIEND_APPLY_LIST = 'roleId roleName ce head frame spine lv title job quitTime vLv guildName friendCnt recFrdApplyCnt serverId userInfo.serverType',
    HANDLE_APPLY = 'roleId friendCnt lv',
    ATTR = 'attr',
    GET_LV = 'lv',
    GET_ROLE_ID = 'roleId',
    GET_MY_SERVER = 'lv serverId userInfo.serverType',
-   COM_BATTLE = 'lv headHid sHid topLineupCe'
+   COM_BATTLE = 'lv head frame spine topLineupCe'
 };
 
 export enum HERO_SELECT {

shared/db/ComBattleTeam.ts

@@ -1,5 +1,6 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+import { FIGURE } from '../pubUtils/dicParam';
 
 export class RoleStatus {
     @prop({ required: true })
@@ -26,11 +27,14 @@ export class RoleStatus {
     @prop({ required: false, default: false })
     isFrd: boolean;
     // 头像
-    @prop({ required: true, default: 19 })
+    @prop({ required: true, default: FIGURE.DEFAULT_HEAD })
-    headHid: number;
+    head: number;
+    // 相框
+    @prop({ required: true, default: FIGURE.DEFAULT_FRAME })
+    frame: number;
     // 形象
-    @prop({ required: true, default: 19 })
+    @prop({ required: true, default: FIGURE.DEFAULT_SPINE })
-    sHid: number;
+    spine: number;
     // 前五战力
     @prop({ required: true, default: 0 })
     topLineupCe: number;
@@ -50,14 +54,15 @@ export class RoleStatus {
     @prop({ required: true, default: 0 })
     frdRatio: number = 0;
 
-    constructor(roleId: string, roleName: string, isCap: boolean, isFrd: boolean, headHid: number, sHid: number, topLineupCe: number, lv: number, heroes = [], isRobot = false) {
+    constructor(roleId: string, roleName: string, isCap: boolean, isFrd: boolean, head: number, frame: number, spine: number, topLineupCe: number, lv: number, heroes = [], isRobot = false) {
         this.roleId = roleId;
         this.roleName = roleName;
         this.isCap = isCap;
         this.totalDmg = 0;
         this.isFrd = isFrd;
-        this.headHid = headHid;
+        this.head = head;
-        this.sHid = sHid;
+        this.frame = frame;
+        this.spine = spine;
         this.topLineupCe = topLineupCe;
         this.lv = lv;
         this.heroes = heroes;

shared/db/FriendApply.ts

@@ -38,7 +38,7 @@ export default class FriendApply extends BaseModel {
         const list: FriendApplyType[] = await FriendApplyModel.find({ roleId }, { _id: 0 })
             // .select(select)
             .populate('friend', ROLE_SELECT.SHOW_FRIEND_APPLY_LIST, 'Role')
-            .lean({ getters: true });
+            .lean({ getters: true, virtuals: true });
         return list;
     }
 
@@ -54,7 +54,7 @@ export default class FriendApply extends BaseModel {
         const list: FriendApplyType[] = await FriendApplyModel.find({ applyCode: { $in: applyCodeList } }, { _id: 0 })
             // .select(select)
             .populate('friend', ROLE_SELECT.SHOW_FRIEND_APPLY_LIST, 'Role')
-            .lean({ getters: true });
+            .lean({ getters: true, virtuals: true });
         return list;
     }
 

shared/db/Guild.ts

@@ -103,8 +103,8 @@ export default class Guild extends BaseModel {
         const code = genCode(6);
         const result: GuildType = await GuildModel.findOneAndUpdate({ code }, update, { upsert: true, new: true })
         .select({ _id: 0, __v: 0, createdAt: 0, updatedAt: 0 })
-        .populate('leader', { roleId: 1, roleName: 1, sHid: 1, headHid: 1, lv: 1, quitTime: 1, ce: 1, title: 1, _id: 0 }, 'Role')
+        .populate('leader', { roleId: 1, roleName: 1, head: 1, frame: 1, spine: 1, lv: 1, quitTime: 1, ce: 1, title: 1, _id: 0 }, 'Role')
-        .lean({ getters: true });
+        .lean({ getters: true, virtuals: true });
         
         return result;
     }
@@ -127,7 +127,7 @@ export default class Guild extends BaseModel {
         .limit(GUILD_PER_PAGE).skip((page - 1) * GUILD_PER_PAGE)
         .select('code icon name lv memberCnt leader ceLimit isAuto')
         .populate('leader', { roleName: 1, _id: 0 }, 'Role')
-        .lean({ getters: true });
+        .lean({ getters: true, virtuals: true });
         return guildList;
     }
 
@@ -138,8 +138,8 @@ export default class Guild extends BaseModel {
         .sort({ activeWeekly: -1, activeUpdateTime: -1 })
         .limit(100).skip((page - 1) * 100)
         .select('code icon name lv leader activeWeekly activeUpdateTime')
-        .populate('leader', {roleName: 1, title: 1, sHid: 1, headHid: 1, lv: 1, _id: 0}, 'Role')
+        .populate('leader', {roleName: 1, title: 1, frame: 1, head: 1, spine: 1, lv: 1, _id: 0}, 'Role')
-        .lean();
+        .lean({ virtuals: true });
         return guildList;
     }
 
@@ -151,8 +151,8 @@ export default class Guild extends BaseModel {
     public static async findByCode(code: string, serverId: number, select?: string) {
         const result: GuildType = await GuildModel.findOne({ code, status: GUILD_STATUS.RUNNING, serverId })
         .select(select)
-        .populate('leader', {roleId: 1, roleName: 1, sHid: 1, headHid: 1, lv: 1, quitTime: 1, ce: 1, title: 1, _id: 0}, 'Role')
+        .populate('leader', {roleId: 1, roleName: 1, frame: 1, head: 1, spine: 1, lv: 1, quitTime: 1, ce: 1, title: 1, _id: 0}, 'Role')
-        .lean({ getters: true });
+        .lean({ getters: true, virtuals: true });
         return result;
     }
 
@@ -182,8 +182,8 @@ export default class Guild extends BaseModel {
 
     public static async updateInfoWithLeader(code: string, update: GuildUpdateParam, incParam?: { managerCnt?: number, fund?: number, activeDaily?: number, activeWeekly?: number }, select?: string) {
         const result: GuildType = await GuildModel.findOneAndUpdate({ code }, { $set: update, $inc: incParam }, { new: true })
-        .populate('leader', {roleId: 1, roleName: 1, sHid: 1, headHid: 1, lv: 1, quitTime: 1, ce: 1, title: 1, _id: 0}, 'Role')
+        .populate('leader', {roleId: 1, roleName: 1, frame: 1, head: 1, lv: 1, spine: 1, quitTime: 1, ce: 1, title: 1, _id: 0}, 'Role')
-        .select(select).lean();
+        .select(select).lean({ virtuals: true });
         return result;
     }
 

shared/db/PvpDefense.ts

@@ -107,9 +107,9 @@ export default class PvpDefense extends BaseModel {
     
     public static async findByScale(roleId: string, min: number, max: number) {
         const result: PvpDefenseType[] = await PvpDefenseModel.find({ roleId: { $ne: roleId }, defCe: { $lte: max, $gte: min } })
-        .populate('role', 'headHid sHid topLineupCe roleId roleName lv globalCeAttr')
+        .populate('role', 'head frame spine topLineupCe roleId roleName lv globalCeAttr')
         .populate('heroes.hero')
-        .sort({ updatedAt: -1 }).limit(100).lean({ getters: true });
+        .sort({ updatedAt: -1 }).limit(100).lean({ getters: true, virtuals: true });
         return result;
     }
 
@@ -151,26 +151,26 @@ export default class PvpDefense extends BaseModel {
 
     public static async findByRoleIdIncludeAll(roleId: string) {
         const result: PvpDefenseType = await PvpDefenseModel.findOne({ roleId })
-        .populate('role', 'headHid sHid topLineupCe roleId roleName lv globalCeAttr')
+        .populate('role', 'head frame spine topLineupCe roleId roleName lv globalCeAttr')
         .populate('heroes.hero')
-        .populate('oppPlayers.oppDef', 'oppRoleId pos roleName headHid sHid rankLv title lv pLv defCe heroes').lean({ getters: true });
+        .populate('oppPlayers.oppDef', 'oppRoleId pos roleName head frame spine rankLv title lv pLv defCe heroes').lean({ getters: true, virtuals: true });
         return result;
     }
 
     public static async findByTeamLv(min: number, max: number) {
         const result: PvpDefenseType[] = await PvpDefenseModel.find({ pLv: { $gte: min, $lte: max } })
-        .populate('role', 'headHid sHid topLineupCe roleId roleName lv globalCeAttr')
+        .populate('role', 'head frame spine topLineupCe roleId roleName lv globalCeAttr')
         .populate('heroes.hero')
-        .populate('oppPlayers.oppDef', 'oppRoleId pos roleName headHid sHid rankLv pLv title lv defCe heroes')
+        .populate('oppPlayers.oppDef', 'oppRoleId pos roleName head frame spine rankLv pLv title lv defCe heroes')
-        .lean({ getters: true });
+        .lean({ getters: true, virtuals: true });
         return result;
     }
 
     public static async updateInfoAndInclude(roleId: string, update: pvpUpdateInter) {
         delete update._id;
         let result: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({roleId}, {$set:update}, {new: true})
-        .populate('role', 'headHid sHid topLineupCe roleId roleName lv')
+        .populate('role', 'head frame spine topLineupCe roleId roleName lv')
-        .populate('oppPlayers.oppDef', 'oppRoleId pos roleName headHid sHid rankLv pLv title lv defCe heroes').lean({ getters: true });
+        .populate('oppPlayers.oppDef', 'oppRoleId pos roleName head frame spine rankLv pLv title lv defCe heroes').lean({ getters: true, virtuals: true });
         return result;
     }
     public static async updateInfo(roleId: string, update: pvpUpdateInter, lean = true) {
@@ -186,8 +186,8 @@ export default class PvpDefense extends BaseModel {
     public static async getRank(seasonNum: number, page = 1, limit = 1000) {
         let sortBy = { score: -1, updatedAt: 1 };
         const ranks: PvpDefenseType[] = await PvpDefenseModel.find({seasonNum}).select('roleId role score updatedAt')
-        .populate('role', 'roleId roleName headHid sHid title lv vLv')
+        .populate('role', 'roleId roleName head frame spine title lv vLv')
-        .sort(sortBy).limit(limit).skip((page - 1) * limit).lean({ getters: true });
+        .sort(sortBy).limit(limit).skip((page - 1) * limit).lean({ getters: true, virtuals: true });
         return ranks;
     }
 

shared/db/PvpHistoryOpp.ts

@@ -2,6 +2,7 @@ import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 import { PvpEnemies, PvpOtherHeroes } from '../domain/dbGeneral';
+import { FIGURE } from '../pubUtils/dicParam';
 
 export class HeroScores {
     @prop({ required: true })
@@ -20,10 +21,12 @@ export default class PvpHistoryOpp extends BaseModel {
     oppRoleId: string;		    	// 对手角色 id
     @prop({ required: true })
     roleName: string;				// 角色名称
-    @prop({ required: true, default: 19 })
+    @prop({ required: true, default: FIGURE.DEFAULT_HEAD })
-    headHid: number;                // 对手头像
+    head: number;                // 对手头像
-    @prop({ required: true, default: 19 })
+    @prop({ required: true, default: FIGURE.DEFAULT_FRAME })
-    sHid: number;                   // 对手形象
+    frame: number;                   // 对手相框
+    @prop({ required: true, default: FIGURE.DEFAULT_SPINE })
+    spine: number;                   // 对手形象
     @prop({ required: true, default: 0 })
     score: number;                  // 对手军功
     @prop({ required: true, default: 1 })

shared/db/PvpRecord.ts

@@ -3,6 +3,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 import { getBeforeDayDate } from '../pubUtils/timeUtil';
 import { genCode } from '../pubUtils/util';
 import { PvpHeroInfo } from '../domain/dbGeneral';
+import { FIGURE } from '../pubUtils/dicParam';
 
 export class HeroesRecord {
     @prop({ required: true, default: 0 })
@@ -41,10 +42,12 @@ export class PlayerInfo {
     roleName: string;					// 角色 名
     @prop({ required: true, default: 0 })
     lv: number;               // 等级
-    @prop({ required: true, default: 0 })
+    @prop({ required: true, default: FIGURE.DEFAULT_HEAD })
-    sHid: number;             // 形象
+    head: number;          // 头像
-    @prop({ required: true, default: 0 })
+    @prop({ required: true, default: FIGURE.DEFAULT_FRAME })
-    headHid: number;          // 头像
+    frame: number;          // 相框
+    @prop({ required: true, default: FIGURE.DEFAULT_SPINE })
+    spine: number;             // 形象
     @prop({ required: true, default: 0 })
     title: number;            // 爵位
     @prop({ required: true, default: 0 })

shared/db/Role.ts

@@ -4,8 +4,10 @@ import { index, getModelForClass, prop, DocumentType, Ref, mongoose } from '@typ
 import User from './User';
 import { shouldRefresh, reduceCe } from '../pubUtils/util';
 import { initRoleAtrr } from '../pubUtils/playerCe';
-import Hero,{} from '../db/Hero';
 import { nowSeconds } from '../pubUtils/timeUtil';
+import { Head, Frame } from '../domain/dbGeneral';
+import { FIGURE } from '../pubUtils/dicParam';
+import Hero from './Hero';
 
 // role表属性格式
 export class CeAttrDataRole {
@@ -22,20 +24,20 @@ export class CeAttrDataRole {
 }
 
 class TopHero {
-  @prop({ required: true })
+    @prop({ required: true })
-  hid: number; // 武将id
+    hid: number; // 武将id
-  @prop({ required: true })
+    @prop({ required: true })
-  ce: number; // 战力
+    ce: number; // 战力
-  @prop({ ref: Hero, type: mongoose.Schema.Types.ObjectId })
+    @prop({ ref: Hero, type: mongoose.Schema.Types.ObjectId })
-  hero: Ref<Hero>;
+    hero: Ref<Hero>;
 }
 
 
 class DungeonHero {
-  @prop({ required: true })
+    @prop({ required: true })
-  battleId: number; // 关卡id
+    battleId: number; // 关卡id
-  @prop({ required: true, type: Number, default:[] })
+    @prop({ required: true, type: Number, default:[] })
-  heroes: Array<number>; // 武将id
+    heroes: Array<number>; // 武将id
 }
 
 class PayRecord {
@@ -90,15 +92,7 @@ export class Teraph{
         });
     }
 }
-// 初始化
+ 
-function getInitialTeraph() {
-    let teraphs = new Array<Teraph>();
-    for(let i = ROLE_TERAPH.START; i <= ROLE_TERAPH.END; i++) {
-        let p = new Teraph(i);
-        teraphs.push(p);
-    }
-    return teraphs;
-}
 /**
   * 角色字段接口
 */
@@ -126,10 +120,26 @@ export default class Role extends BaseModel {
     blocked: boolean;				// 是否屏蔽
     @prop({ required: true })
     code: string;						// 邀请码
-    @prop({ required: true, default: 19 })
+
-    headHid: number;     // 头像所用武将 Id，默认赵云
+    @prop({ required: true, type: Number, default: [] })
-    @prop({ required: true, default: 19 })
+    showLineup: number[];			    	// 展示阵容
-    sHid: number;         // 形象所用武将 Id，默认赵云
+
+    @prop({ required: true, type: Head, default: [] })
+    heads: Head[];                     // 拥有头像列表
+    @prop({ required: true, type: Head, default: [] })
+    frames: Frame[];                   // 拥有相框列表
+    @prop({ required: true, default: FIGURE.DEFAULT_SPINE })
+    spine: number;                     // 显示形象
+
+    public get head () {               // 虚拟字段head 当前头像
+        let curHead = this.heads?.find(cur => cur.enable && cur.time > nowSeconds());
+        return curHead?curHead.id: FIGURE.DEFAULT_HEAD;
+    }
+    
+    public get frame () {              // 虚拟字段frame 当前相框
+        let curFrame = this.frames?.find(cur => cur.enable && cur.time > nowSeconds());
+        return curFrame?curFrame.id: FIGURE.DEFAULT_FRAME;
+    }
 
     @prop({ required: true, default: 0 })
     exp: number;						// 经验值
@@ -221,14 +231,14 @@ export default class Role extends BaseModel {
     @prop({ required: true, default: new Date() })
     dungeonRefTime: Date;		// 秘境刷新时间
     @prop({ required: true, type: DungeonHero, default: [], _id: false })
-    dungeonHeroes: Array<DungeonHero>;		// 秘境首通使用的武将
+    dungeonHeroes: DungeonHero[];		// 秘境首通使用的武将
     
     // 全局养成
     @prop({ required: true, default: 1 })
     title: number;		//爵位
     //神像
     @prop({ required: true, type: Teraph, default: getInitialTeraph(), _id: false })
-    teraphs:Array<Teraph>;	
+    teraphs: Teraph[];	
     
     // 公会
     @prop({ required: true, default: false })
@@ -255,7 +265,7 @@ export default class Role extends BaseModel {
     }
 
     public static async findByUid(uid: number, serverId: number, select?: string, getters = false) {
-        const role: RoleType = await RoleModel.findOneAndUpdate({ 'userInfo.uid': uid, serverId }, { loginTime: nowSeconds(), quitTime: nowSeconds() }, { new: true }).select(select).lean({ getters });
+        const role: RoleType = await RoleModel.findOneAndUpdate({ 'userInfo.uid': uid, serverId }, { loginTime: nowSeconds(), quitTime: nowSeconds() }, { new: true }).select(select).lean({ getters, virtuals: true });
         return role;
     }
 
@@ -288,7 +298,7 @@ export default class Role extends BaseModel {
             };
         }
 
-        const user: RoleType[] = await RoleModel.find(searchObj).select(select).lean({ getters });
+        const user: RoleType[] = await RoleModel.find(searchObj).select(select).lean({ getters, virtuals: true });
         return user;
     }
 
@@ -298,8 +308,8 @@ export default class Role extends BaseModel {
         return role;
     }
     
-    public static async towerLvUp(roleId: string, lean = true) {
+    public static async towerLvUp(roleId: string) {
-        let role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerLv: 1}, towerUpTime: new Date()}, {new: true}).lean(lean);
+        let role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerLv: 1}, towerUpTime: new Date()}, {new: true}).lean({ virtuals: true });
         return role;
     }
 
@@ -420,18 +430,18 @@ export default class Role extends BaseModel {
     }
 
     // 获取排行榜
-    public static async getRank(type: string, serverId: number, fields: Array<string>, page = 1, limit = 100, lean = true) {
+    public static async getRank(type: string, serverId: number, fields: string[], page = 1, limit = 100) {
         let sortBy = {};
         if(type == 'tower') {
         sortBy['towerLv'] = -1;
         sortBy['towerUpTime'] = 1;
         }
-        const ranks: RoleType[] = await RoleModel.find({serverId}).select(fields.join(' ')).sort(sortBy).limit(limit).skip((page - 1) * limit).lean(lean);
+        const ranks: RoleType[] = await RoleModel.find({serverId}).select(fields.join(' ')).sort(sortBy).limit(limit).skip((page - 1) * limit).lean({ virtuals: true });
         return ranks;
     }
 
     // 保存秘境首通队伍
-    public static async saveDungeonHero(roleId: string, battleId: number, heroes: Array<number>, isSuccess: boolean) {
+    public static async saveDungeonHero(roleId: string, battleId: number, heroes: number[], isSuccess: boolean) {
         if(isSuccess) {
             let role = await Role.findByRoleId(roleId);
             let dungeonHeroes = role && role.dungeonHeroes;
@@ -444,7 +454,7 @@ export default class Role extends BaseModel {
     }
 
     // 保存开启功能
-    public static async pushFuncs(roleId: string, funcs: Array<number>, lean = true) {
+    public static async pushFuncs(roleId: string, funcs: number[], lean = true) {
         const recs: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$push: {funcs: {$each: funcs}}}, {new: true}).lean(lean);
         return recs
     }
@@ -469,9 +479,9 @@ export default class Role extends BaseModel {
      */
     public static async getInviteList(time: number, serverId: number) {
         const result = await RoleModel.find({ loginTime: { $gt: time }, hasGuild: false, serverId })
-        .select({roleId: 1, roleName: 1,ce: 1,headHid: 1,sHid: 1,lv: 1,title: 1,job: 1,quitTime: 1, _id: 0})
+        .select({roleId: 1, roleName: 1,ce: 1, head: 1, frame: 1, lv: 1,title: 1,job: 1,quitTime: 1, _id: 0})
         .sort({quitTime: -1, lv: -1, ce: -1})
-        .limit(100).lean({getters: true});
+        .limit(100).lean({getters: true, virtuals: true});
         return result;
     }
 
@@ -480,7 +490,7 @@ export default class Role extends BaseModel {
         const result = await RoleModel.find({ loginTime: { $gt: time }, lv: { $gte: minLv, $lte: maxLv } }, { _id: 0 })
         .select(ROLE_SELECT.SHOW_FRIEND_APPLY_LIST)
         .sort({quitTime: -1, lv: -1, ce: -1})
-        .limit(200).lean({ getters: true });
+        .limit(200).lean({ getters: true, virtuals: true });
         return result;
     }
 
@@ -494,7 +504,7 @@ export default class Role extends BaseModel {
          }, { _id: 0 })
         .select(ROLE_SELECT.SHOW_FRIEND_APPLY_LIST)
         .sort({quitTime: -1, lv: -1, ce: -1})
-        .limit(200).lean({ getters: true });
+        .limit(200).lean({ getters: true, virtuals: true });
         return result;
     }
 
@@ -542,3 +552,13 @@ export const RoleModel = getModelForClass(Role);
 
 export interface RoleType extends Pick<DocumentType<Role>, keyof Role>{};
 export type RoleUpdate = Partial<RoleType>; // 将所有字段变成可选项
+
+// 初始化
+function getInitialTeraph() {
+    let teraphs = new Array<Teraph>();
+    for(let i = ROLE_TERAPH.START; i <= ROLE_TERAPH.END; i++) {
+        let p = new Teraph(i);
+        teraphs.push(p);
+    }
+    return teraphs;
+}

shared/db/UserGuild.ts

@@ -119,8 +119,8 @@ export default class UserGuild extends BaseModel {
         const userGuilds: UserGuildType[] = await UserGuildModel.find({ guildCode, status: USER_GUILD_STATUS.ON })
         .select(select)
         .sort(sort)
-        .populate('role', 'roleId roleName ce headHid sHid lv title quitTime', 'Role')
+        .populate('role', 'roleId roleName ce head frame spine lv title quitTime', 'Role')
-        .lean({ getters: true });
+        .lean({ getters: true, virtuals: true });
         return userGuilds;
     }
 
@@ -128,8 +128,8 @@ export default class UserGuild extends BaseModel {
         const userGuilds: UserGuildType = await UserGuildModel.findOne({ guildCode, status: USER_GUILD_STATUS.ON, auth: { $ne: GUILD_AUTH.LEADER } })
         .sort({ activeWeekly: -1, activeUpdateTime: 1 })
         .select(select)
-        .populate('role', 'roleId roleName ce headHid sHid lv title quitTime', 'Role')
+        .populate('role', 'roleId roleName ce head frame spine lv title quitTime', 'Role')
-        .lean({getters: true});
+        .lean({getters: true, virtuals: true });
         return userGuilds;
     }
 

shared/db/UserGuildApply.ts

@@ -79,8 +79,8 @@ export default class UserGuildApply extends BaseModel {
         const list: UserGuildApplyType[] = await UserGuildApplyModel.find(condition)
         .sort({ createdAt: -1 })
         .select('applyCode role')
-        .populate('role', 'roleId roleName ce headHid sHid lv title job quitTime', 'Role')
+        .populate('role', 'roleId roleName ce head frame spine lv title job quitTime', 'Role')
-        .limit(GUILD_PER_PAGE).lean({ getters: true });
+        .limit(GUILD_PER_PAGE).lean({ getters: true, virtuals: true });
         return list
     }
 

shared/domain/battleField/guild.ts

@@ -1,8 +1,9 @@
-import { PvpEnemies, PvpOtherHeroes } from "../../domain/dbGeneral";
+import { PvpEnemies, PvpOtherHeroes, WarStar } from "../../domain/dbGeneral";
 import { GuildType } from "../../db/Guild";
-import { RoleType, WarStar } from "../../db/Role";
+import { RoleType } from "../../db/Role";
 import { WAR_TYPE } from "../../consts/consts";
 import { gameData } from "../../pubUtils/data";
+import { FIGURE } from "../../pubUtils/dicParam";
 
 export class PlayerDetailHero {
     actorId: number;
@@ -49,8 +50,9 @@ export class PlayerDetail {
     roleName: string;
     lv: number;
     title?: number = 1;
-    sHid?: number = 19;
+    head?: number = FIGURE.DEFAULT_HEAD;
-    headHid?: number = 19;
+    frame?: number = FIGURE.DEFAULT_FRAME;
+    spine?: number = FIGURE.DEFAULT_SPINE;
 
     score?: number = 0;
     pLv?: number = 1;
@@ -66,8 +68,9 @@ export class PlayerDetail {
         if(detail.roleName) this.roleName = detail.roleName;
         if(detail.lv) this.lv = detail.lv;
         if(detail.title) this.title = detail.title;
-        if(detail.sHid) this.sHid = detail.sHid;
+        if(detail.head) this.head = detail.head;
-        if(detail.headHid) this.headHid = detail.headHid;
+        if(detail.frame) this.frame = detail.frame;
+        if(detail.spine) this.spine = detail.spine;
         if(detail.score) this.score = detail.score;
         if(detail.pLv) this.pLv = detail.pLv;
         if(detail.defCe) this.defCe = detail.defCe;

shared/domain/dbGeneral.ts

@@ -1,7 +1,8 @@
-import { prop } from '@typegoose/typegoose';
+import { prop, mongoose, Ref } from '@typegoose/typegoose';
 import { DicWarJson } from '../pubUtils/dictionary/DicWarJson';
-import { HeroType } from '../db/Hero';
 import { Attribute } from './roleField/attribute';
+import Hero, { HeroType } from '../db/Hero';
+import { FIGURE } from '../pubUtils/dicParam';
 
 // 从玩家数据中覆盖warjson的部分字段
 export class PvpHeroInfo {
@@ -146,4 +147,75 @@ export class ItemReward {
     id: number;
     @prop({ required: true })
     count: number;
+}
+
+
+export class TopHero {
+    @prop({ required: true })
+    hid: number; // 武将id
+    @prop({ required: true })
+    ce: number; // 战力
+    @prop({ ref: Hero, type: mongoose.Schema.Types.ObjectId })
+    hero: Ref<Hero>;
+}
+
+
+export class DungeonHero {
+    @prop({ required: true })
+    battleId: number; // 关卡id
+    @prop({ required: true, type: Number, default: [] })
+    heroes: Array<number>; // 武将id
+}
+
+export class PayRecord {
+    @prop({ required: true })
+    id: string;						// 购买项 product id
+    @prop({ required: true })
+    cnt: number;					// 购买次数
+}
+
+export class WarStar {
+    @prop({ required: true })
+    id: number;						// 关卡 id
+    @prop({ required: true })
+    warType: number;      // 关卡类型
+    @prop({ required: true })
+    star: number;					// 星级
+}
+
+export class Teraph {
+    @prop({ required: true, default: 1 })
+    id: number;						// 神像的id
+    @prop({ required: true, default: 1 })
+    grade: number;                  // 等级
+    @prop({ required: true, default: 0 })
+    hp: number;
+    @prop({ required: true, default: 0 })
+    atk: number;
+    @prop({ required: true, default: 0 })
+    def: number;
+    @prop({ required: true, default: 0 })
+    mdef: number;
+    @prop({ required: true, default: 0 })
+    agi: number;
+    @prop({ required: true, default: 0 })
+    luk: number;
+}
+
+export class Head {
+    @prop({ required: true, default: FIGURE.DEFAULT_HEAD })
+    id: number;						// 头像id
+    @prop({ required: true, default: false })
+    enable: boolean;				// 是否启用
+    @prop({ required: true })
+    time: number;					// 到期时间
+}
+
+export class Frame {
+    @prop({ required: true, default: FIGURE.DEFAULT_FRAME })
+    id: number;						// 相框id
+    @prop({ required: true, default: false })
+    enable: boolean;				// 是否启用
+    @prop({ required: true })
+    time: number;					// 到期时间
 }

shared/domain/rank.ts

@@ -1,20 +1,23 @@
+import { FIGURE } from "../pubUtils/dicParam";
+
 // 排行榜返回玩家值
 export class RankParam {
     roleName: string;
     lv: number;
     vLv: number;
     guildName: string = "";
-    head: string = 'zhaoyun';
+    head: number = FIGURE.DEFAULT_HEAD;
-    headHid: number = 19;
+    frame: number = FIGURE.DEFAULT_FRAME;
-    sHid: number = 19;
+    spine: number = FIGURE.DEFAULT_SPINE;
     title: number;
 
-    constructor(roleName: string, lv: number, vLv: number, headHid: number, sHid: number, title: number) {
+    constructor(roleName: string, lv: number, vLv: number, head: number, frame: number, spine: number, title: number) {
         this.roleName = roleName;
         this.lv = lv;
         this.vLv = vLv;
-        this.headHid = headHid;
+        this.head = head;
-        this.sHid = sHid;
+        this.frame = frame;
+        this.spine = spine;
         this.title = title;
     }
 }
@@ -28,11 +31,12 @@ export class GuildRankParam {
         roleName: string;
         title: number;
         lv: number;
-        headHid: number;
+        head: number;
-        sHid: number;
+        frame: number;
+        spine: number;
     }
 
-    constructor(icon: number, name: string, lv: number, leader: {roleName: string, title: number, lv: number, headHid: number, sHid: number}) {
+    constructor(icon: number, name: string, lv: number, leader: {roleName: string, title: number, lv: number, head: number, frame: number, spine: number}) {
         this.icon = icon;
         this.name = name;
         this.lv = lv;
@@ -45,14 +49,16 @@ export class GuildLeader {
     roleName: string;
     title: number;
     lv: number;
-    headHid: number;
+    head: number;
-    sHid: number;
+    frame: number;
+    spine: number;
 
-    constructor(leader: {roleName: string, title: number, lv: number, headHid: number, sHid: number}) {
+    constructor(leader: {roleName: string, title: number, lv: number, head: number, frame: number, spine: number}) {
         this.roleName = leader.roleName;
         this.title = leader.title;
         this.lv = leader.lv;
-        this.headHid = leader.headHid;
+        this.head = leader.head;
-        this.sHid = leader.sHid;
+        this.frame = leader.frame;
+        this.spine = leader.spine;
     }
 }

shared/domain/roleField/friend.ts

@@ -6,8 +6,9 @@ export class FriendParams {
     roleId: string;
     roleName: string;
     lv: number;
-    headHid: number;
+    head: number;
-    sHid: number;
+    frame: number;
+    spine: number;
     ce: number;
     title: number;
     serverId: number;
@@ -18,8 +19,9 @@ export class FriendParams {
         this.roleId = role.roleId;
         this.roleName = role.roleName;
         this.lv = role.lv;
-        this.headHid = role.headHid;
+        this.head = role.head;
-        this.sHid = role.sHid;
+        this.frame = role.frame;
+        this.spine = role.spine;
         this.ce = role.ce;
         this.title = role.title;
     }

shared/pubUtils/dicParam.ts

@@ -67,3 +67,8 @@ export const FRIEND = {
   FRIEND_RECONMMEND_NUM: 8, // 同一批推荐好友数量
   FRIEND_RECONMMEND_SERVICE: 4, // 同一批推荐本服的好友数量
 };
+export const FIGURE = {
+  DEFAULT_HEAD: 11201, // 默认头像
+  DEFAULT_FRAME: 11301, // 默认相框 
+  DEFAULT_SPINE: 11401, // 默认形象
+};

shared/pubUtils/interface.ts

@@ -41,8 +41,9 @@ export interface oppPlayersInter {
     pos: number; // 对手位置
     roleId: string; // 对手玩家id
     roleName: string; // 对手玩家名
-    headHid: number; // 头像
+    head: number; // 头像
-    sHid: number; // 形象
+    frame: number; // 相框
+    spine: number; // 形象
     pLv: number; // 对手队伍等级
     defCe: number; // 防守阵容战力
     addScore: number; // 战胜后可获军功