xy-server/game/network/http/HttpGame.ts
2025-04-23 09:34:08 +08:00

818 lines
26 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import Signal from "../../core/Signal";
import Http from "../../utils/Http";
import PlayerMgr from "../../object/PlayerMgr";
import GMMgr from "../../core/GMMgr";
import NoticeMgr from "../../core/NoticeMgr";
import ChargeSum from "../../core/ChargeSum";
import DB from "../../utils/DB";
import Player from "../../object/Player";
// 网络请求
import bodyParser from "body-parser";
import express from "express";
import {Request, Response } from "express";
import Launch from "../../core/Launch";
import GameUtil from "../../core/GameUtil";
import SKDataUtil from "../../gear/SKDataUtil";
import SKLogger from "../../gear/SKLogger";
import DugMgr from "../../role/DugMgr";
import { MsgCode } from "../../role/EEnum";
import GameConf from "../../../conf/GameConf";
import MailData from "../../mail/MailData";
import MailMgr from "../../mail/MailMgr";
import JingJiChang from "../../activity/JingJiChang";
import LotteryMgr from "../../core/LotteryMgr";
import SignInMgr from "../../core/SignInMgr";
import MallMgr from "../../core/MallMgr";
import ZhenbukuiMgr from "../../activity/ZhenbukuiMgr";
import RobotMgr from "../../core/RobotMgr";
import SKRedisUtil from "../../gear/SKRedisUtil";
import DialMgr from "../../core/DialMgr";
import DebrisMall from "../../core/DebrisMall";
import OnlineRewards from "../../activity/OnlineRewards";
import Currency from "../../activity/Currency";
import Ofuda from "../../object/Ofuda";
import { nextTick } from "process";
export default class HttpGame {
static shared = new HttpGame();
app: any;
constructor() {
this.app = express();
this.app.use(function (req: Request, res: Response, next: any) {
res.header("Access-Control-Allow-Origin", "*");
res.header("Access-Control-Expose-Headers", "'Content-Type,Access-Control-Allow-Headers,Authorization,X-Requested-With");
res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
res.header("X-Powered-By", ' 3.2.1');
res.header("Content-Type", "application/json;charset=utf-8");
next();
});
this.app.use(bodyParser.json({ limit: "1mb" }));
this.app.use(bodyParser.urlencoded({ limit: "1mb", extended: true }));
}
loginToken(req: any, res: any) {
SKLogger.info("login token")
let accountid = req.query.accountid;
let roleid = req.query.roleid;
let login_token = req.query.token;
Signal.shared.addLoginToken(accountid, login_token);
Http.reply(res, {
result: MsgCode.SUCCESS,
});
}
getClientIP(req: any, res: any): string {
var ip = req.headers['x-forwarded-for'] ||
req.ip ||
req.connection.remoteAddress ||
req.socket.remoteAddress ||
req.connection.socket.remoteAddress || '';
if (ip.split(',').length > 0) {
ip = ip.split(',')[0];
}
return ip;
}
// 充值回调
chargeCallback(req: any, res: any) {
let roleid = req.query.roleid;
let jade = SKDataUtil.numberBy(req.query.jade);
let sdorderno = req.query.sdorderno;
let sdpayno = req.query.sdpayno;
let sd_money: number = SKDataUtil.numberBy(req.query.sd_money);
let total_fee: number = SKDataUtil.numberBy(req.query.total_fee);
let msg: string = "";
if (sd_money != total_fee) {
// 支付调试模式下不验证金额是否匹配
if (GameConf.debugPay.length < 0) {
msg = `支付:在线玩家[${roleid}]订单金额${sd_money}元与实充金额${total_fee}元不匹配,游戏订单${sdorderno},支付订单${sdpayno}无效!`
SKLogger.warn(msg);
}
}
let player = PlayerMgr.shared.getPlayerByRoleId(roleid);
if (player) {
let msg = `支付:在线玩家[${player.roleid}:${player.name}]充值${jade}仙玉成功,游戏订单${sdorderno},支付订单${sdpayno}`
SKLogger.info(msg);
player.send('s2c_notice', {
strRichText: `您充值${total_fee}元成功!`,
});
// 充值奖励凤羽道具
this.addGoods(roleid,50019, Math.ceil(total_fee/2))
ChargeSum.shared.playerCharge(roleid, total_fee, jade);
Http.reply(res, { code: MsgCode.SUCCESS, msg: msg });
} else {
msg = `支付:离线玩家${roleid}充值${jade}仙玉成功,游戏订单:${sdorderno},支付订单:${sdpayno}`
SKLogger.info(msg);
// 充值奖励凤羽道具
this.addGoods(roleid,50019, Math.ceil(total_fee/2))
ChargeSum.shared.playerCharge(roleid, total_fee, jade);
Http.reply(res, { code: MsgCode.SUCCESS, msg: msg });
}
}
// 系统通知
sysNotice(req: any, res: any) {
let text = req.query.text;
let type = req.query.type; // 1 走马灯 2 聊天框 3 走马灯 + 聊天框
let serverid = req.query.servre_id; // 0 则全服公告
let times = req.query.times; // -1 则永久公告 需入库
let interval = req.query.interval; // 单位 秒
let id = req.query.id; // 消息id
if (!id) {
id = 0;
}
let notice = {
id: id,
text: text,
type: type,
times: times,
interval: interval,
};
NoticeMgr.shared.addNewNotice(notice);
Http.reply(res, { code: MsgCode.SUCCESS, msg: `发送系统通知:${text}成功` });
}
// 同步风雨同舟数据
syncDial(req: any, res: any) {
DialMgr.shared.init();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步宝图数据成功` });
}
// 同步宝图数据
syncTreasure(req: any, res: any) {
LotteryMgr.shared.init();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步宝图数据成功` });
}
// 同步签到数据
syncSignIn(req: any, res: any) {
SignInMgr.shared.readDB();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步签到数据成功` });
}
// 同步新鲜玩意数据
syncFresh(req: any, res: any) {
MallMgr.shared.syncFresh();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步新鲜玩意数据成功` });
}
// 同步强化材料数据
syncIntensify(req: any, res: any) {
MallMgr.shared.syncIntensify();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步强化材料数据成功` });
}
// 同步限购商店
syncQuota(req: any, res: any) {
MallMgr.shared.syncQuota();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步限购数据成功` });
}
// 同步每日推荐
syncRecommend(req: any, res: any) {
MallMgr.shared.syncRecommend();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步每日推荐数据成功` });
}
// 同步积分商店
syncIntegral(req: any, res: any) {
MallMgr.shared.syncIntegral();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步积分商店数据成功` });
}
// 同步绑定商店
syncBindJade(req: any, res: any) {
MallMgr.shared.syncBindJade();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步绑定商店数据成功` });
}
// 同步碎片商店
syncDebris(req: any, res: any) {
DebrisMall.shared.init();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步碎片商店数据成功` });
}
// 同步在线奖励
syncOnlineRewards(req: any, res: any) {
OnlineRewards.shared.init();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步在线奖励数据成功` });
}
// 同步限购商店
syncKuiNot(req: any, res: any) {
ZhenbukuiMgr.shared.init();
Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步甄不亏数据成功` });
}
deleteNotice(req: any, res: any) {
let id = req.query.id;
NoticeMgr.shared.delNotice(id);
Http.reply(res, { errcode: MsgCode.SUCCESS });
}
can_speak(req: any, res: any) {
let roleid = req.query.roleid;
let state = req.query.state;
GMMgr.shared.can_speak(roleid, state);
Http.reply(res, { code: MsgCode.SUCCESS });
}
clearPCache(req: any, res: any) {
let ip = this.getClientIP(req, res);
if (ip != GameConf.gate_ip) {
return;
}
let roleid = req.query.roleid;
PlayerMgr.shared.clearPlayerCache(roleid);
res.end(SKDataUtil.toJson({
ret: `操作完成`,
}, "{}"));
}
kickedOut(req: any, res: any) {
let roleids = req.query.roleids;
let sign = req.query.sign; // 签名
if (sign != GameConf.sign) {
Http.reply(res, {
code: MsgCode.FAILED,
msg: `你是傻逼吗!`
});
return;
}
PlayerMgr.shared.kickedOutPlayer(roleids);
}
/*
* 设置充值活动时间
*/
setChargeActivity(req: any, res: any) {
let start = parseInt(req.query.start);
let end = parseInt(req.query.end);
GMMgr.shared.setChargeActivity(start, end);
Http.reply(res, { errcode: 0, });
}
/*
* 关闭充值活动
*/
closeChargeActivity(req: any, res: any) {
GMMgr.shared.closeChargeActivity();
Http.reply(res, { errcode: 0, });
}
// 加仙玉
addJade(req: any, res: any) {
let roleId = req.query.roleId;
let jade: number = parseInt(req.query.jade);
jade = Math.min(100000000, jade);
let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
if (player) {
player.addMoney(GameUtil.goldKind.Jade, jade, "系统加仙玉");
let info = `玩家[${player.roleid}:${player.name}]加${jade}仙玉成功`;
SKLogger.debug(info);
Http.reply(res, {
code: MsgCode.SUCCESS,
msg: info
});
return;
}
let info = `玩家[${roleId}}]加${jade}仙玉失败`;
Http.reply(res, {
code: MsgCode.FAILED,
msg: info
});
}
// 加经验
addExp(req: any, res: any) {
let roleId = req.query.roleId;
let exp: number = parseInt(req.query.exp);
exp = Math.min(999999999999, exp);
let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
if (player) {
player.addExp(exp);
let info = `玩家[${player.roleid}:${player.name}]增加${exp}经验成功`;
Http.reply(res, {
code: MsgCode.SUCCESS,
msg: info
});
return;
}
DB.addExp(roleId, exp, (code: any) => {
Http.reply(res, {
code: code
});
});
}
//模拟战斗
testBattle(req: any, res: any){
let roleId = req.query.roleId;
let eroleId = req.query.eroleid;
let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
if(player){
JingJiChang.shared.battleStart(roleId,eroleId);
Http.reply(res, { code: MsgCode.SUCCESS });
return;
}
Http.reply(res, { code: MsgCode.FAILED });
}
//测试http线程锁死情况下 http链接能否处理
testSleep(){
SKLogger.info("test slerrp...............")
var start = (new Date()).getTime();
while ((new Date()).getTime() - start < 5 * 60* 1000) { //卡死5分钟
// 使用 continue 实现;
continue;
}
SKLogger.info("test slerrp...............success")
}
// 加道具
addItem(req: any, res: any) {
let roleId = req.query.roleId;
let item: number = parseInt(req.query.item);
let num: number = parseInt(req.query.num);
let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
// 在线玩家发放道具
if (player != null) {
if (player.addItem(item, num, true, "")) {
Http.reply(res, { code: MsgCode.SUCCESS });
} else {
Http.reply(res, { code: MsgCode.FAILED });
}
return;
}
// 离线玩家道具发放
DB.loginByRoleid(roleId, (code: number, data: any) => {
if (code != MsgCode.SUCCESS || data == null) {
Http.reply(res, { code: MsgCode.FAILED });
return;
}
let player = new Player();
player.loaded = true;
player.setDB(data);
if (player.addItem(item, num, true, "")) {
player.offline = false;
player.saveAll((failed: string[]) => {
player.offline = true;
if (failed.length > 0) {
SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入存档道具失败!`);
Http.reply(res, { code: MsgCode.FAILED });
} else {
SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入存档道具成功!`);
Http.reply(res, { code: MsgCode.SUCCESS });
}
});
return;
}
SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入道具失败!`);
Http.reply(res, { code: MsgCode.FAILED });
});
}
//发送天策符
addOfuda(req: any, res: any){
let roleId = req.query.roleId;
let name = req.query.name;
let grade = req.query.grade;
let addition = req.query.addition;
let ofudaobj = Ofuda.shared.createOfuda({
roleid: parseInt(roleId),
name: name,
grade: grade,
addition: addition
});
if(ofudaobj == null){
Http.reply(res, { code: MsgCode.FAILED });
return;
}
let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
// 在线玩家发放道具
if (player) {
if (Ofuda.shared.pofuda_map.has(player.roleid)) {//map里有没有这个key值
Ofuda.shared.pofuda_map.get(player.roleid).push(ofudaobj)
} else {
let list = [];
list.push(ofudaobj)
Ofuda.shared.pofuda_map.set(player.roleid, list);
}
Http.reply(res, { code: MsgCode.SUCCESS });
return;
}else {
Http.reply(res, { code: MsgCode.FAILED });
return;
}
}
// 充值发送道具
addGoods(roleId: any,item: number,num:number){
if (GameConf.integral){
let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
// 在线玩家发放道具
if (player != null) {
player.addItem(item, num, true, "")
return;
}
// 离线玩家道具发放
DB.loginByRoleid(roleId, (code: number, data: any) => {
if (code != MsgCode.SUCCESS || data == null) {
return;
}
let player = new Player();
player.loaded = true;
player.setDB(data);
if (player.addItem(item, num, true, "")) {
player.offline = false;
player.saveAll((failed: string[]) => {
player.offline = true;
if (failed.length > 0) {
SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入存档道具失败!`);
} else {
SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入存档道具成功!`);
}
});
return;
}
SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入道具失败!`);
});
}
}
// 加称谓
addTitle(req: any, res: any) {
let role_id = req.query.role_id;
let type = req.query.type;
let title_id = req.query.title_id;
let value = req.query.value;
let onload = req.query.onload;
let player = PlayerMgr.shared.getPlayerByRoleId(role_id);
if (player) {
player.addTitle(type, title_id, value, onload);
} else {
DB.addTitle(role_id, type, title_id, (code: number, msg: string) => {
});
}
Http.reply(res, { code: MsgCode.SUCCESS });
}
// 提现更改
withdrawState(req: any, res: any) {
let state = req.query.state;
let serial = req.query.serial;
let role_id = req.query.role_id;
let flag: boolean = Currency.shared.update_withdraw_state(role_id,{state:state,serial:serial});
if (flag){
Http.reply(res, { code: MsgCode.SUCCESS });
return;
}
Http.reply(res, { code: MsgCode.FAILED });
return;
}
// 获得现金
obtainCurrency(req: any, res: any) {
let msg = req.query.msg;
let role_id = req.query.role_id;
let player = PlayerMgr.shared.getPlayerByRoleId(role_id);
if (player) {
Currency.shared.gm_obtain_currency(player,msg);
Http.reply(res, { code: MsgCode.SUCCESS });
return;
}
Http.reply(res, { code: MsgCode.FAILED });
return;
}
// 清理玩家任务
closeTask(req: any, res: any) {
let role_id = req.query.roleId;
let player = PlayerMgr.shared.getPlayerByRoleId(role_id);
if (player) {
player.F5_Task();
}
Http.reply(res, { code: MsgCode.SUCCESS });
}
// 恢复数据
async rollbackPlayer(req: any, res: any) {
let role_id = req.query.roleId;
let msg = "";
// 先进行清理角色
let player = PlayerMgr.shared.player_role_list[role_id];
if (player){
player.destroy();
delete PlayerMgr.shared.player_role_list[player.roleid];
delete PlayerMgr.shared.player_only_list[player.onlyid];
}
// 获取角色缓存
let role = await SKRedisUtil.getValue(role_id.toString());
let pet = await SKRedisUtil.getValue(role_id + "pet");
let scheme = await SKRedisUtil.getValue(role_id + "scheme");
let hourse = await SKRedisUtil.getValue(role_id + "hourse");
let hourseskill = await SKRedisUtil.getValue(role_id + "hourseskill");
// 数据不为undefined
if (role != undefined){
let callback = (ret: any, item: any) => {
if (ret == MsgCode.SUCCESS) {
msg = "成功";
Http.reply(res, {code: MsgCode.SUCCESS, msg: msg});
} else {
msg = "失败";
Http.reply(res, {code: MsgCode.SUCCESS, msg: msg});
}
DB.saveSignIn(SKDataUtil.toJson(role.daySignIn,"{}"), role_id, role.mendDate,(code: number, msg: string) => {
let info = `存档:[${role_id}:${role.dbinfo.name}]签到数据存档`;
if (code == MsgCode.SUCCESS) {
info += `成功!`;
SKLogger.debug(info);
} else {
info += `失败[${msg}]!`;
SKLogger.warn(info);
}
});
DB.saveDial(role_id, role.dial_num,role.dial_count,role.dial_date,(code: number, msg: string) => {
let info = `存档:[${role_id}:${role.dbinfo.name}]风雨转盘数据存档`;
if (code == MsgCode.SUCCESS) {
info += `成功!`;
SKLogger.debug(info);
} else {
info += `失败[${msg}]!`;
SKLogger.warn(info);
}
});
DB.savePetsRedis(pet, role_id, (code: number, msg: string) => {
let info = `存档:[${role_id}:${role.dbinfo.name}]召唤兽存档`;
if (code == MsgCode.SUCCESS) {
info += `成功!`;
SKLogger.debug(info);
} else {
info += `失败[${msg}]!`;
SKLogger.warn(info);
}
});
// 保存套装
DB.saveSchemeRedis(scheme, (code: number, msg: string) => {
});
DB.saveHorseList(role_id, hourse, (error: any, rows: any[]) => {
if (error != null) {
SKLogger.warn(`存档:玩家[${role_id}:坐骑列表存档失败[${DB.errorInfo(error)}]!`);
} else {
SKLogger.debug(`存档:玩家[${role_id}:坐骑列表存档成功!`);
}
});
DB.saveHorseSkillList(role_id, hourseskill, (error: any, rows: any[]) => {
if (error != null) {
SKLogger.warn(`存档:玩家[${role_id}:坐骑技能存档失败[${DB.errorInfo(error)}]!`);
} else {
SKLogger.debug(`存档:玩家[${role_id}:坐骑技能存档完成!`);
}
});
callback = null;
}
DB.savePlayerInfo(role_id, role.dbinfo, callback);
}else {
Http.reply(res, {code: MsgCode.FAILED, msg: "缓存数据中没有该玩家信息"});
}
}
// 创建机器人
createRobot(req: any, res: any) {
RobotMgr.shared.createRobotOn(req.query.num,(code,count) => {
let msg = `以创建机器人:${count}`;
Http.reply(res, { code: code, msg: msg });
});
}
// 清理机器人
clearRobot(req: any, res: any) {
RobotMgr.shared.remoteAllRobot(req.query.num,(code,count) => {
let msg = `以清理机器人:${count}`;
Http.reply(res, { code: code, msg: msg });
});
}
// 清除玩家每日存档
clearDay(req: any, res: any) {
let roleId = req.query.roleId;
let type: number = parseInt(req.query.type);
let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
if (player != null) {
player.clearDayMap();
Http.reply(res, { code: MsgCode.SUCCESS });
return;
}
DB.loginByRoleid(roleId, (code: number, data: any) => {
if (code != MsgCode.SUCCESS || data == null) {
Http.reply(res, { code: MsgCode.FAILED });
return;
}
let player = new Player();
player.offline = false;
player.setDB(data);
player.clearDayMap();
player.saveAll((failed: string[]) => {
player.offline = true;
if (failed.length > 0) {
SKLogger.warn(`玩家[${player.roleid}:${player.name}]清除每日存档失败!`);
Http.reply(res, { code: MsgCode.FAILED });
} else {
SKLogger.debug(`玩家[${player.roleid}:${player.name}]清除每日存档成功!`);
Http.reply(res, { code: MsgCode.SUCCESS });
}
});
})
}
// 清理所有的玩家每日存档
clearAllDay(req: any, res: any) {
PlayerMgr.shared.clearAllDayCount();
let msg = `服务器[${GameUtil.serverName}][在线玩家数:${GameUtil.online}]已清空所有玩家每日存档!`;
Http.reply(res, { code: MsgCode.SUCCESS, msg: msg });
}
// 控制
control(req: any, res: any) {
let type = (req.query.type ? req.query.type : 0);
let open = (req.query.open ? req.query.open : 1);
let msg = `控制完成`;
if (type == 1) {
let enabled = (open == 1);
if (DugMgr.enabled != enabled) {
DugMgr.enabled = enabled;
msg = `${DugMgr.enabled ? `开启` : `关闭`}今日挖宝!`
SKLogger.info(msg);
}
}
Http.reply(res, { code: MsgCode.SUCCESS, msg: msg });
}
// 全部存档
saveAll(req: any, res: any) {
SKLogger.info(`服务器[${GameUtil.serverName}]正在存档!`);
Launch.shared.saveAll(() => {
let msg = `服务器[${GameUtil.serverName}]存档完成:机器人数[${GameUtil.robotCount}]在线玩家数[${GameUtil.online}]失败总数[${GameUtil.saveFailed.length}]存档总数[${GameUtil.saveTotal}]`;
SKLogger.info(msg)
let data = {
server_id: GameUtil.serverId,
server_name: GameUtil.serverName,
online: GameUtil.online,
saveCount: GameUtil.saveCount,
saveTotal: GameUtil.saveTotal,
saveFailed: GameUtil.saveFailed
}
Http.reply(res, { code: MsgCode.SUCCESS, msg: msg, data: data });
});
}
// 备用存档
saveAllReserve(req: any, res: any){
let player_role_list: any = PlayerMgr.shared.player_role_list
for (let roleId in player_role_list) {
let player = player_role_list[roleId];
if (player != null) {
player.saveAllReserve();
}
}
Http.reply(res, { code: MsgCode.SUCCESS, msg: "备用存档已经在执行中"});
}
// 关服
close(req: any, res: any) {
if (GameUtil.isClose) {
let data = {
server_id: GameUtil.serverId,
server_name: GameUtil.serverName,
online: GameUtil.online,
saveCount: GameUtil.saveCount,
saveTotal: GameUtil.saveTotal,
saveFailed: GameUtil.saveFailed
}
if (Launch.shared.isClose) {
let msg = `服务器[${GameUtil.serverName}]已关服:机器人数[${GameUtil.robotCount}]在线玩家数[${GameUtil.online}]失败总数[${GameUtil.saveFailed.length}]存档总数[${GameUtil.saveTotal}]`;
Http.reply(res, { code: MsgCode.SUCCESS, msg: msg, data: data });
} else {
let msg = `服务器[${GameUtil.serverName}]正在关服:机器人数[${GameUtil.robotCount}]在线玩家数[${GameUtil.online}]存档进度[${GameUtil.saveCount}/${GameUtil.saveTotal}]`;
Http.reply(res, { code: MsgCode.SUCCESS, msg: msg, data: data });
}
return;
}
GameUtil.isClose = true;
SKLogger.info(`正在关闭服务器[${GameUtil.serverName}]!`);
Launch.shared.close(() => {
let msg = `服务器[${GameUtil.serverName}]关服完成:机器人数[${GameUtil.robotCount}]在线玩家数[${GameUtil.online}]失败总数[${GameUtil.saveFailed.length}]存档总数[${GameUtil.saveTotal}]`;
SKLogger.info(msg);
let data = {
server_id: GameUtil.serverId,
server_name: GameUtil.serverName,
online: GameUtil.online,
saveCount: GameUtil.saveCount,
saveTotal: GameUtil.saveTotal,
saveFailed: GameUtil.saveFailed
}
Http.reply(res, { code: MsgCode.SUCCESS, msg: msg, data });
});
}
// 发送邮件
sendMail(req: any, res: any) {
if(!GameConf.mailEnabled){
Http.reply(res, { code: MsgCode.FAILED, msg: `发送邮件:邮件功能未开启`});
return;
}
let mail = new MailData();
let info = mail.parseReq(req);
if (info.length < 1) {
MailMgr.shared.addSystemMail(mail);
let msg = `发送邮件:服务器[${GameUtil.serverName}]发送邮件[${mail.mail_id}:${mail.title}]成功`;
Http.reply(res, { code: MsgCode.SUCCESS, msg: msg });
if(mail.role_id == 0){
PlayerMgr.shared.broadcastEmail()
}else{
let player = PlayerMgr.shared.getPlayerByRoleId(mail.role_id)
if(player){
player.send("s2c_friend_apply", {});
}
}
return;
}
Http.reply(res, { code: MsgCode.FAILED, msg: info });
}
//设置中间件, 判断卡死在哪条消息上
beforeRecv(req: any, res: any, next: any){
SKLogger.info(req.baseUrl)
SKLogger.info(req.originalUrl)
next();
}
// 启动Http服务
start(port: number) {
// 游戏服务器路由
let list: { [key: string]: (req: any, res: any) => void } = {
['login_token']: this.loginToken.bind(this),
['charge_callback']: this.chargeCallback.bind(this),
['sys_notice']: this.sysNotice.bind(this),
['can_speak']: this.can_speak.bind(this),
['delete_notice']: this.deleteNotice.bind(this),
['clear_pcache']: this.clearPCache.bind(this),
['kicked_out']: this.kickedOut.bind(this),
['set_charge_activity']: this.setChargeActivity.bind(this),
['close_charge_activity']: this.closeChargeActivity.bind(this),
['add_jade']: this.addJade.bind(this),
['add_exp']: this.addExp.bind(this),
['add_item']: this.addItem.bind(this),
['add_ofuda']: this.addOfuda.bind(this),
['add_title']: this.addTitle.bind(this),
["clear_day"]: this.clearDay.bind(this),
["clear_all_day"]: this.clearAllDay.bind(this),
// 全部存档
["save_all"]: this.saveAll.bind(this),
// 备用存档
["save_all_reserve"]: this.saveAllReserve.bind(this),
["control"]: this.control.bind(this),
// 恢复数据
["roll_back_player"]: this.rollbackPlayer.bind(this),
// 清理玩家任务
["close_task"]: this.closeTask.bind(this),
// 关服
["close"]: this.close.bind(this),
["send_mail"]: this.sendMail.bind(this),
// 同步风雨同舟数据
["sync_dial"]: this.syncDial.bind(this),
// 同步宝图数据
["sync_treasure"]: this.syncTreasure.bind(this),
// 同步签到数据
["sync_signIn"]: this.syncSignIn.bind(this),
// 同步新鲜玩意数据
["sync_fresh"]: this.syncFresh.bind(this),
// 同步强化材料数据
["sync_intensify"]: this.syncIntensify.bind(this),
// 同步限购商店数据
["sync_quota"]: this.syncQuota.bind(this),
// 同步限购商店数据
["sync_recommend"]: this.syncRecommend.bind(this),
// 同步限购商店数据
["sync_integral"]: this.syncIntegral.bind(this),
// 同步绑定商店数据
["sync_bindjade"]: this.syncBindJade.bind(this),
// 同步甄不亏商店数据
["sync_kui_not"]: this.syncKuiNot.bind(this),
// 同步碎片商城配置
["sync_debris"]: this.syncDebris.bind(this),
// 同步在线奖励配置
["sync_online_rewards"]: this.syncOnlineRewards.bind(this),
// 更改提现状态
["withdraw_state"]: this.withdrawState.bind(this),
// 获得现金
["obtain_currency"]: this.obtainCurrency.bind(this),
// 创建机器人数据
["create_robot"]: this.createRobot.bind(this),
// 清理机器人数据
["clear_robot"]: this.clearRobot.bind(this),
["test_battle"]: this.testBattle.bind(this),
["test"]: this.testSleep.bind(this)
};
for (let key in list) {
this.app.get('/' + key, [this.beforeRecv.bind(this)], list[key]);
}
this.app.listen(port);
}
}