8775 lines
257 KiB
TypeScript
8775 lines
257 KiB
TypeScript
/**
|
||
* 玩家类
|
||
*/
|
||
import BattleObj from "./BattleObj";
|
||
import RoleTaskMgr from "../core/RoleTaskMgr";
|
||
import PartnerMgr from "./PartnerMgr";
|
||
import RelationMgr from "./RelationMgr";
|
||
import BattleMgr from "../battle/BattleMgr";
|
||
import TeamMgr from "../core/TeamMgr";
|
||
import EquipMgr from "./EquipMgr";
|
||
import PlayerMgr from "./PlayerMgr";
|
||
import NpcMgr from "../core/NpcMgr";
|
||
import PaiHangMgr from "../core/PaiHangMgr";
|
||
import Equip from "./Equip";
|
||
import SchemeMgr from "./SchemeMgr";
|
||
import BangMgr from "../bang/BangMgr";
|
||
import ActivityMgr from "../activity/ActivityMgr";
|
||
import ActivityDefine from "../activity/ActivityDefine";
|
||
import PetMgr from "../core/PetMgr";
|
||
import ChargeSum from "../core/ChargeSum";
|
||
import BattleRole from "../battle/BattleRole";
|
||
import MonsterMgr from "../core/MonsterMgr";
|
||
import World from "./World";
|
||
import DB from "../utils/DB";
|
||
import MapMgr from "../core/MapMgr";
|
||
import PetPracticeMgr from "./PetPracticeMgr";
|
||
import PalaceFight from "../activity/PalaceFight";
|
||
import ChargeConfig from "../core/ChargeConfig";
|
||
import RolePracticeMgr from "./RolePracticeMgr";
|
||
import NpcConfigMgr from "../core/NpcConfigMgr";
|
||
import HorseList from "../horse/HorseList";
|
||
import Agent from "../network/Agent";
|
||
import Exchange from "../core/Exchange";
|
||
import HorseSkill from "../horse/HorseSkill";
|
||
import Pet from "./Pet";
|
||
import SKDataUtil from "../gear/SKDataUtil";
|
||
import Npc, { NpcCreater } from "../core/Npc";
|
||
import SkillUtil from "../skill/core/SkillUtil";
|
||
import ExpUtil from "../core/ExpUtil";
|
||
import SKLogger from "../gear/SKLogger";
|
||
import GameUtil from "../core/GameUtil";
|
||
import ItemUtil from "../core/ItemUtil";
|
||
import SkillBase from "../skill/core/SkillBase";
|
||
import SKTimeUtil from "../gear/SKTimeUtil";
|
||
import VIPUtil from "../role/VIPUtil";
|
||
import DugMgr from "../role/DugMgr";
|
||
import {
|
||
BattleType,
|
||
EActionType,
|
||
EAttrCalType,
|
||
EAttrTypeL1,
|
||
EAttrTypeL2,
|
||
EEquipPos,
|
||
EEquipType,
|
||
EEventType,
|
||
ELiveingType,
|
||
ENpcCreater,
|
||
ERaceType,
|
||
ESexType,
|
||
ESkillType,
|
||
MsgCode,
|
||
Operate
|
||
} from "../role/EEnum";
|
||
import MapModel from "../core/MapModel";
|
||
import AIMgr from "../core/AIMgr";
|
||
import RoleUtil from "../utils/RoleUtil";
|
||
import GTimer from "../common/GTimer";
|
||
import MailList from "../mail/MailList";
|
||
import JingJiChang from "../activity/JingJiChang";
|
||
import SKRedisUtil from "../gear/SKRedisUtil";
|
||
import FivePhases from "../object/FivePhases";
|
||
import ChangeCard from "../object/ChangeCard";
|
||
import DWorld from "./DWorld";
|
||
import SatAssembly from "../activity/SatAssembly";
|
||
import SKCxfUtil from "../gear/SKCxfUtil";
|
||
import BoxMgr from "../core/BoxMgr";
|
||
import SpecialEffect from "../object/SpecialEffect";
|
||
import PetSupport from "../object/PetSupport";
|
||
import MagicWeapon from "./MagicWeapon";
|
||
import Ofuda from "../object/Ofuda";
|
||
import MagicWeaponMgr from "./MagicWeaponMgr";
|
||
import FactionWar from "../activity/FactionWar";
|
||
import zhenFaMgr from "../zhenFa/zhenFa";
|
||
import ZhenFaUtil from "../core/ZhenFaUtil";
|
||
import xwManager from "../zhenFa/xwManager";
|
||
import { json } from "express";
|
||
import Baby from "./Baby";
|
||
import BabyMgr from "./BabyMgr";
|
||
import StarMgr from "./StarMgr";
|
||
import KanPo3 from "../skill/ofuda/KanPo3";
|
||
export default class Player extends BattleObj {
|
||
// 帐号索引
|
||
accountid: number = 0;
|
||
// 邀请码
|
||
invite: string = "";
|
||
// 角色编码
|
||
roleid: number = 0;
|
||
// 连接器
|
||
agent: Agent;
|
||
// 种族
|
||
race: number;
|
||
// 性别
|
||
sex: number;
|
||
// 武器
|
||
weapon: string = "";
|
||
// 状态
|
||
state: number;
|
||
// 装备列表
|
||
equip_list: any;
|
||
// 法宝列表
|
||
magic_weapon_list: any;
|
||
dir: number;
|
||
aoi_model: string;
|
||
aoi_obj_list: any;
|
||
battle_id: number;
|
||
taskMgr: RoleTaskMgr;
|
||
partnerMgr: PartnerMgr;
|
||
ZFMgr: zhenFaMgr;
|
||
XWMgr: xwManager;
|
||
money: number;
|
||
jade: number;
|
||
bind_jade: number;
|
||
bangscore: number;
|
||
shiscore: number;
|
||
discore: number;
|
||
xiuscore: number;
|
||
guoscore: number;
|
||
rewardrecord: number;
|
||
sprewardrecord: number;
|
||
curPet: any;
|
||
curPetId: number;
|
||
lastonline: any;
|
||
usingIncense: any;
|
||
loaded: boolean;
|
||
gmlevel: number;
|
||
teamid: number;
|
||
isleader: boolean;
|
||
lastWorldChatTime: number;
|
||
lastWorldChatStr: string;
|
||
nFlag: number;
|
||
offline: boolean;
|
||
offlineTimer: any;
|
||
incenseTimer: NodeJS.Timeout;
|
||
shape: number;
|
||
inPrison: boolean;
|
||
level_reward: string;
|
||
getgift: number;
|
||
getpet: number;
|
||
shuilu: any;
|
||
arena: any;
|
||
titleId: number;
|
||
titleType: number;
|
||
onLoad: boolean;
|
||
bangid: number;
|
||
bangname: string;
|
||
bangpost: number;
|
||
titles: any;
|
||
schemeName: string;
|
||
baldric: number;
|
||
color1: any;
|
||
color_one_serial: any;
|
||
color2: any;
|
||
color_two_serial: any;
|
||
safe_password: string;
|
||
safe_lock: number;
|
||
friendList: any;
|
||
applyFriendList: any;
|
||
star: number = 1;
|
||
shane: any;
|
||
titleVal: any;
|
||
equipObjs: any = {};
|
||
magicWeaponObjs: any = {};
|
||
schemeMgr: SchemeMgr;
|
||
xiulevel: number = 1;
|
||
currentEquips: Equip[] = [];
|
||
currentMagicWeapons: MagicWeapon[] = [];
|
||
listEquips: Equip[] = [];
|
||
listMagicWeapons: MagicWeapon[] = [];
|
||
petList: Pet[] = [];
|
||
bag_list: any = {};
|
||
locker_list: any = {};
|
||
relivelist: any[] = [];
|
||
lockerEquips: any[] = [];
|
||
dbData: any;
|
||
anleiCnt: any;
|
||
horseList: HorseList;
|
||
horseSkill: HorseSkill;
|
||
wingId: number;
|
||
exchange: Exchange;
|
||
onlineTime: number = 0;
|
||
// 每日限购
|
||
dayMap: any;
|
||
// 宝藏
|
||
treasure: any;
|
||
// 存档计数
|
||
saveTotal: number = 0;
|
||
// 存档失败
|
||
saveFailed: string[];
|
||
// 角色索引
|
||
roleIndex: number = 0;
|
||
// 邮件管理器
|
||
mailList: MailList;
|
||
// AI管理器
|
||
ai: AIMgr;
|
||
// 背包默认空间
|
||
bagKindNum: number;
|
||
// 仓库默认空间
|
||
lockerKindNum: number;
|
||
// 界面图标
|
||
iconList: any;
|
||
// 最后一次时使用的技能
|
||
lastSkill: number;
|
||
petLastSkill: number;
|
||
// 签到数据
|
||
daySignIn: any;
|
||
// 幸运转盘每日免费
|
||
dial_num: number = 0;
|
||
// 幸运转盘累计次数
|
||
dial_count: number = 0;
|
||
// 幸运转盘免费最后一次点击时间
|
||
dial_date: any;
|
||
// 最后一次补签时间
|
||
mendDate: any;
|
||
// 最后一次刷新任务日期
|
||
mend_date: any;
|
||
// 证道积分
|
||
sat_integral: number = 0;
|
||
// 暂离状态
|
||
pause: number;
|
||
//是否自动归队
|
||
ischeck: number;
|
||
//离线时间
|
||
offlinetime: number;
|
||
//双倍点数
|
||
doublecnt: number;
|
||
//未领取的双倍点数
|
||
unget_doublecnt: number;
|
||
// 属性状态
|
||
isFrozen: number;
|
||
|
||
ai_flag: number;
|
||
|
||
list: any[];
|
||
|
||
tianti_integral: number = 0;
|
||
|
||
//宝宝
|
||
BabyMgr: BabyMgr = new BabyMgr()
|
||
|
||
//星阵
|
||
StarMgr: StarMgr = new StarMgr(this)
|
||
|
||
constructor() {
|
||
super();
|
||
this.agent = null;
|
||
this.race = ERaceType.UNKNOW; // 种族
|
||
this.sex = ESexType.UNKNOW;
|
||
this.state = 1;
|
||
// 装备列表
|
||
this.equip_list = {};
|
||
// dir 朝向 1 2
|
||
// 4方向 3 4
|
||
this.dir = 4;
|
||
this.living_type = ELiveingType.PLAYER;
|
||
this.aoi_model = "wm";
|
||
this.aoi_obj_list = {};
|
||
this.battle_id = 0;
|
||
this.taskMgr = new RoleTaskMgr(this);
|
||
this.partnerMgr = new PartnerMgr(this);
|
||
this.ZFMgr = new zhenFaMgr(this);
|
||
this.ZFMgr.init()
|
||
this.XWMgr = new xwManager(this);
|
||
this.XWMgr.init()
|
||
this.list = []
|
||
this.money = 0;
|
||
this.jade = 0;
|
||
this.bind_jade = 0;
|
||
this.bangscore = 0;
|
||
this.shiscore = 0;
|
||
this.discore = 0;
|
||
this.xiuscore = 0;
|
||
this.guoscore = 0;
|
||
// 背包空间
|
||
this.bagKindNum = GameUtil.limitBagKindNum;
|
||
// 仓库默认空间
|
||
this.lockerKindNum = GameUtil.limitLockerKindNum;
|
||
this.rewardrecord = 0;
|
||
this.sprewardrecord = 0;
|
||
this.curPet = null;
|
||
this.curPetId = 0;
|
||
this.lastonline = null;
|
||
this.usingIncense = false;
|
||
this.loaded = false; // 是否加载完毕，玩家进入了场景
|
||
this.gmlevel = 0;
|
||
|
||
this.teamid = 0;
|
||
this.isleader = false;
|
||
|
||
this.lastWorldChatTime = 0;
|
||
this.lastWorldChatStr = '';
|
||
this.nFlag = 0;
|
||
|
||
this.offline = false;
|
||
this.offlineTimer = null;
|
||
|
||
this.shane = 0;
|
||
this.inPrison = false;
|
||
this.level_reward = '';
|
||
this.getgift = 0;
|
||
this.getpet = 1;
|
||
|
||
this.shuilu = {
|
||
season: 1,
|
||
score: 0,
|
||
gongji: 0,
|
||
wtime: 0,
|
||
ltime: 0,
|
||
};
|
||
this.arena = {
|
||
count: 10, //挑战次数
|
||
jpoint: 0, //竞技点
|
||
jtime: 0, //光阴
|
||
ranking: 0
|
||
};
|
||
//this.curtitle = 0;
|
||
this.titleId = -1;
|
||
this.titleType = -1; //当前的称谓类型
|
||
this.titleVal = ''; //当前称谓值
|
||
this.onLoad = false; //是否装载称谓
|
||
this.bangid = 0;
|
||
this.bangname = '';
|
||
this.bangpost = 0;
|
||
this.titles = [];
|
||
this.schemeName = '套装方案';
|
||
this.baldric = 0;
|
||
this.color1 = 0; // 染色部位1
|
||
this.color_one_serial = 0; // 染色部位编号一
|
||
this.color2 = 0; // 染色部位2
|
||
this.color_two_serial = 0; // 染色部位编号二
|
||
this.safe_password = '';
|
||
this.safe_lock = 0;
|
||
this.friendList = {};// 好友列表
|
||
this.applyFriendList = {};// 好友申请列表
|
||
// 击杀地煞星 星级
|
||
this.star = 1;
|
||
// 翅膀索引
|
||
this.wingId = 0;
|
||
this.dayMap = {};
|
||
// 签到数据
|
||
this.daySignIn = {};
|
||
this.horseList = new HorseList(this);
|
||
this.horseSkill = new HorseSkill(this);
|
||
this.mailList = new MailList(this);
|
||
// 界面图标
|
||
this.iconList = SKDataUtil.toJson(GameUtil.iconList, "{}");
|
||
// 最后一次时使用的技能
|
||
this.lastSkill = ESkillType.NormalAtkSkill;
|
||
this.petLastSkill = ESkillType.NormalAtkSkill;
|
||
this.mendDate = "";
|
||
this.mend_date = "";
|
||
// 幸运转盘免费次数
|
||
this.dial_num = 0;
|
||
// 幸运转盘累计次数
|
||
this.dial_count = 0;
|
||
// 幸运转盘免费最后一次点击时间
|
||
this.dial_date = "";
|
||
this.sat_integral = 0;
|
||
this.pause = 0;
|
||
this.ischeck = 0;
|
||
this.offlinetime = 0;
|
||
this.doublecnt = 0;
|
||
this.unget_doublecnt = 0;
|
||
this.isFrozen = 0;
|
||
this.ai_flag = 0;
|
||
this.tianti_integral = 0;
|
||
}
|
||
|
||
update(dt: number) {
|
||
if (this.shane > 0) {
|
||
this.shane--;
|
||
if (this.shane <= 0) {
|
||
this.shane = 0;
|
||
this.ShanEChange();
|
||
}
|
||
}
|
||
// 未关服则每30分钟存档一次
|
||
if (dt % (GameUtil.savePlayerTime) == 0) {
|
||
// 机器人不定时存档
|
||
if (this.isRobot()) {
|
||
return;
|
||
}
|
||
// if (!GameUtil.isClose) {
|
||
let self = this;
|
||
this.saveAll((failed: string[]) => {
|
||
if (failed.length > 0) {
|
||
SKLogger.warn(`定时存档:玩家[${self.roleid}:${self.name}]存档失败:${failed}`);
|
||
} else {
|
||
SKLogger.debug(`玩家[${self.roleid}:${self.name}]定时存档成功!`);
|
||
}
|
||
});
|
||
// }
|
||
}
|
||
if (dt % (1000) == 0) {
|
||
this.getTaskMgr().OnTimer();
|
||
}
|
||
if (this.ai) {
|
||
this.ai.update(dt);
|
||
}
|
||
}
|
||
|
||
GetFlag(nIndex: any): any {
|
||
return GameUtil.getFlag(this.nFlag, nIndex);
|
||
}
|
||
|
||
SetFlag(nIndex: any, bValue: any) {
|
||
this.nFlag = GameUtil.setFlag(this.nFlag, nIndex, bValue);
|
||
}
|
||
// 获得每日限购已购次数
|
||
getDayCount(dayId: number): number {
|
||
let count = this.dayMap[dayId];
|
||
if (count == null) {
|
||
return 0;
|
||
}
|
||
return count;
|
||
}
|
||
// 增加加每日限购数量
|
||
addDayCount(dayId: number, count: number) {
|
||
let current = this.dayMap[dayId];
|
||
if (current == null) {
|
||
this.dayMap[dayId] = count;
|
||
} else {
|
||
this.dayMap[dayId] = current + count;
|
||
}
|
||
}
|
||
// 清空每日存档
|
||
clearDayMap() {
|
||
// this.dayMap = {};
|
||
let keys = Object.keys(this.dayMap)
|
||
for (let index = 0; index < keys.length; index++) {
|
||
let key = keys[index];
|
||
if (key.indexOf("day") != -1) {
|
||
this.dayMap[key] = 0
|
||
}
|
||
}
|
||
|
||
let chargeSum = ChargeSum.shared.getPlayerChargeSum(this.roleid);
|
||
let vipLevel = VIPUtil.getVipLevel(chargeSum);
|
||
// 小于VIP等级的每日奖励已领取处理
|
||
vipLevel += 1;
|
||
for (let i = 0; i < vipLevel; i++) {
|
||
this.dayMap[`vip_${i}`] = 1;
|
||
}
|
||
this.send(`s2c_clear_day`, {
|
||
dayMap: SKDataUtil.toJson(this.dayMap, "{}")
|
||
});
|
||
}
|
||
|
||
// 清空VIP存档
|
||
clearDayMapVip() {
|
||
let chargeSum = ChargeSum.shared.getPlayerChargeSum(this.roleid);
|
||
let vipLevel = VIPUtil.getVipLevel(chargeSum);
|
||
this.dayMap[`vip_${vipLevel}`] = 0;
|
||
this.send(`s2c_clear_day`, {
|
||
dayMap: SKDataUtil.toJson(this.dayMap, "{}")
|
||
});
|
||
}
|
||
|
||
OnEnterTeam() {
|
||
this.getTaskMgr().checkAndInceptTask();
|
||
this.getTaskMgr().updateTaskStateToClient();
|
||
}
|
||
// 离开队伍
|
||
leaveTeam() {
|
||
if (this.teamid == 0) {
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]已离队`);
|
||
return;
|
||
}
|
||
this.teamid = 0;
|
||
this.isleader = false;
|
||
this.getTaskMgr().leaveTeam();
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]${this.isleader ? "队长" : "队员"}离开队伍${this.teamid}`);
|
||
}
|
||
|
||
getTeamId() {
|
||
return this.teamid;
|
||
}
|
||
|
||
isTeamLeader() {
|
||
if (this.teamid == 0) {
|
||
return false;
|
||
}
|
||
return this.isleader;
|
||
}
|
||
|
||
getTaskMgr(): RoleTaskMgr {
|
||
if (!this.taskMgr) {
|
||
this.taskMgr = new RoleTaskMgr(this);
|
||
}
|
||
return this.taskMgr;
|
||
}
|
||
|
||
CheckNewDay(lastonline: any) {
|
||
if (lastonline == null) {
|
||
return;
|
||
}
|
||
let cdate = new Date(GameUtil.gameTime);
|
||
let ly = lastonline.getFullYear();
|
||
let lm = lastonline.getMonth();
|
||
let lw = GTimer.getYearWeek(lastonline);
|
||
let ld = GTimer.getYearDay(lastonline);
|
||
|
||
if (ly != cdate.getFullYear()) {
|
||
this.OnNewYear();
|
||
}
|
||
if (lm != cdate.getMonth()) {
|
||
this.OnNewMonth();
|
||
}
|
||
if (lw != GTimer.getYearWeek(cdate)) {
|
||
this.OnNewWeek();
|
||
}
|
||
if (lw != GTimer.getYearWeek(cdate)) {
|
||
this.OnNewWeek();
|
||
}
|
||
if (ld != GTimer.getYearDay(cdate)) {
|
||
this.OnNewDay();
|
||
}
|
||
}
|
||
|
||
OnNewYear() {
|
||
// 这辈子估计不会调用
|
||
}
|
||
|
||
OnNewMonth() {
|
||
}
|
||
|
||
OnNewWeek() {
|
||
}
|
||
|
||
OnNewDay() {
|
||
|
||
}
|
||
|
||
on5oclock() {
|
||
if (this.getTaskMgr() == null)
|
||
return;
|
||
this.getTaskMgr().OnNewDay();
|
||
}
|
||
|
||
// OnNewHour() {
|
||
// }
|
||
|
||
setAgent(agent: any) {
|
||
if (this.agent) {
|
||
if (this.agent != agent) {
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]在其他设备登录!`);
|
||
this.agent.otherLogin();
|
||
}
|
||
}
|
||
this.agent = agent;
|
||
}
|
||
|
||
playerOffline() {
|
||
|
||
if (this.offline) {
|
||
return;
|
||
}
|
||
delete this.aoi_obj_list[this.onlyid];
|
||
let self = this;
|
||
let offtime = this.offlinetime * (60 * 60 * 1000)
|
||
this.offlineTimer = SKTimeUtil.delay(() => {
|
||
if (this.teamid > 0) {
|
||
TeamMgr.shared.leaveTeam(this);
|
||
}
|
||
self.destroy();//时间结束清理下线
|
||
}, offtime);
|
||
if (this.battle_id != 0) {
|
||
BattleMgr.shared.playerOffline(this.battle_id, this.onlyid);
|
||
}
|
||
// 未关服离线存档
|
||
if (!GameUtil.isClose && this.saveTotal < 1) {
|
||
// 机器人下线不存档
|
||
if (this.isRobot()) {
|
||
return;
|
||
}
|
||
let self = this;
|
||
// this.redisSave();
|
||
this.saveAll((failed: string[]) => {
|
||
if (failed.length > 0) {
|
||
SKLogger.warn(`存档:玩家[${self.roleid}:${self.name}]离线存档失败!`);
|
||
} else {
|
||
SKLogger.debug(`存档:玩家[${self.roleid}:${self.name}]离线存档成功!`);
|
||
}
|
||
});
|
||
// 通过cxf存档
|
||
this.cxfSavePlayerAll();
|
||
}
|
||
RelationMgr.shared.deleteTempRelationByPlayer(this.roleid);
|
||
this.agent = null;
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]已离线`);
|
||
this.offline = true;
|
||
this.calcOnlineTime();
|
||
}
|
||
|
||
activateScheme() {
|
||
let scheme = this.schemeMgr.getActivateScheme();
|
||
if (scheme) {
|
||
this.addattr2 = scheme.content.attribute.addPoint;
|
||
this.qianneng = scheme.content.attribute.qianNeng;
|
||
this.addattr1 = scheme.content.defense.xiuPoint;
|
||
this.xiulevel = scheme.content.defense.xiuLevel;
|
||
for (const key in this.addattr1) {
|
||
if (this.addattr1.hasOwnProperty(key)) {
|
||
this.xiulevel += this.addattr1[key];
|
||
}
|
||
}
|
||
for (let index = 0; index < this.currentEquips.length; index++) {
|
||
this.currentEquips[index].pos = EEquipPos.BAG;
|
||
this.addEquipList(this.currentEquips[index]);
|
||
}
|
||
this.currentEquips = [];
|
||
for (var it in scheme.content.curEquips) {
|
||
let eid = scheme.content.curEquips[it];
|
||
let equip = this.equipObjs[eid];
|
||
if (equip) {
|
||
let flag = true;
|
||
let fullEquipData = equip.getFullData(this.roleid);
|
||
if (fullEquipData.NeedGrade > this.level || fullEquipData.NeedRei > this.relive) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色等级不足，尚不能使用！'
|
||
});
|
||
flag = false;
|
||
}
|
||
if (fullEquipData.Shuxingxuqiu) { //属性需求不符合
|
||
for (const key in fullEquipData.Shuxingxuqiu) {
|
||
if (this.getAttr1(key) < fullEquipData.Shuxingxuqiu[key]) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色属性不足，尚不能使用！'
|
||
});
|
||
flag = false;
|
||
}
|
||
}
|
||
}
|
||
if (flag) {
|
||
equip.pos = EEquipPos.USE;
|
||
} else {
|
||
equip.pos = EEquipPos.BAG;
|
||
continue;
|
||
}
|
||
this.currentEquips.push(equip);
|
||
for (let index = 0; index < this.listEquips.length; index++) {
|
||
if (this.listEquips[index].EquipID == eid) {
|
||
this.listEquips.splice(index, 1);
|
||
break;
|
||
}
|
||
}
|
||
if (equip.EIndex == 1) {
|
||
this.changeWeapon(equip);
|
||
}
|
||
}
|
||
}
|
||
this.sendEquipList();
|
||
this.schemeName = scheme.schemeName;
|
||
this.partnerMgr.vecChuZhan = SKDataUtil.jsonBy(SKDataUtil.toJson(scheme.content.partner, "{}"));
|
||
this.calculateAttr();
|
||
this.send('s2c_player_data', this.getData());
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
}
|
||
}
|
||
|
||
checkSchemeEquip(equipid: any): boolean {
|
||
//装备
|
||
let equip: Equip = this.equipObjs[equipid];
|
||
let fullEquipData = equip.getFullData();
|
||
if (fullEquipData.OwnerRoleId > 0 && fullEquipData.OwnerRoleId != this.resid) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色不匹配，不能使用！'
|
||
});
|
||
return false;
|
||
} else if ((fullEquipData.Sex != 9 && fullEquipData.Sex != this.sex) || (fullEquipData.Race != 9 && fullEquipData.Race != this.race)) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色不匹配，不能使用！'
|
||
});
|
||
return false;
|
||
}
|
||
if (fullEquipData.Shuxingxuqiu) { //属性需求不符合
|
||
for (const key in fullEquipData.Shuxingxuqiu) {
|
||
if (this.getAttr1(key) < fullEquipData.Shuxingxuqiu[key]) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色属性不足，尚不能使用！'
|
||
});
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
syncSchemePartner() {
|
||
if (this.schemeMgr != null) {
|
||
this.schemeMgr.syncSchemePartner();
|
||
}
|
||
}
|
||
|
||
destroy() {
|
||
if (this.offlineTimer) {
|
||
SKTimeUtil.cancelDelay(this.offlineTimer);
|
||
this.offlineTimer = null;
|
||
}
|
||
if (this.incenseTimer) {
|
||
SKTimeUtil.cancelDelay(this.incenseTimer);
|
||
this.incenseTimer = null;
|
||
}
|
||
if (this.agent) {
|
||
this.agent.close();
|
||
this.agent = null;
|
||
}
|
||
for (let equipid in this.equipObjs) {
|
||
EquipMgr.shared.delEquip(equipid);
|
||
}
|
||
let map = MapMgr.shared.getMap(this);
|
||
if (map) {
|
||
map.exitMap(this);
|
||
}
|
||
delete this.taskMgr;
|
||
delete this.partnerMgr;
|
||
PlayerMgr.shared.delPlayer(this.roleid);
|
||
NpcMgr.shared.deletePlayersNpc(this.roleid);
|
||
}
|
||
// 从数据库中读档
|
||
setDB(data: any) {
|
||
data.lastonline = new Date(data.lastonline);
|
||
this.dbData = data;
|
||
this.accountid = data.accountid;
|
||
this.invite = data.invite;
|
||
this.roleid = data.roleid;
|
||
this.mapid = data.mapid;
|
||
this.resid = data.resid;
|
||
this.race = RoleUtil.checkRace(data.race, data.resid);
|
||
this.sex = RoleUtil.checkSex(data.sex, data.resid);
|
||
this.name = data.name;
|
||
this.level_reward = data.level_reward;
|
||
this.exp = data.exp;
|
||
// 默认最低星 1星
|
||
this.star = data.star;
|
||
if (this.star < 1) {
|
||
this.star = 1;
|
||
}
|
||
this.bag_list = SKDataUtil.jsonBy(data.bagitem) || {};
|
||
// 设置称谓信息
|
||
// 称谓放在有关系统初始化之前，之后会操作称谓
|
||
let titles: any = SKDataUtil.jsonBy(data.title);
|
||
this.setTitles(titles);
|
||
this.initBang(data.bangid);
|
||
let partnerdata = SKDataUtil.jsonBy(data.partnerlist);
|
||
this.partnerMgr.init(partnerdata);
|
||
this.locker_list = SKDataUtil.jsonBy(data.lockeritem) || {};
|
||
this.money = data.money;
|
||
this.jade = data.jade;
|
||
this.bind_jade = data.bind_jade || 0;
|
||
this.bangscore = data.bang_score || 0;
|
||
this.shiscore = data.shi_score || 0;
|
||
this.discore = data.di_score || 0;
|
||
this.xiuscore = data.xiu_score || 0;
|
||
this.guoscore = data.guo_score || 0;
|
||
this.rewardrecord = data.rewardrecord;
|
||
this.sprewardrecord = data.sprewardrecord;
|
||
this.x = data.x;
|
||
this.y = data.y;
|
||
this.curPetId = data.pet;
|
||
this.curPet = null;
|
||
this.petList = [];
|
||
this.lastonline = data.lastonline;
|
||
this.nFlag = data.state;
|
||
this.getgift = data.getgift;
|
||
this.tianti_integral = Number(data.tianti_integral);//天梯积分
|
||
// 背包空间
|
||
this.bagKindNum = data.bag_kind_num;
|
||
// 等级相关
|
||
let relivelist = [
|
||
[0, 0],
|
||
[0, 0],
|
||
[0, 0],
|
||
[0, 0],
|
||
];
|
||
let relist = SKDataUtil.jsonBy(data.relivelist) || relivelist;
|
||
let fixed = 4 - relist.length;
|
||
for (let i = 0; i < fixed; i++) {
|
||
relist.push([0, 0]);
|
||
}
|
||
this.relivelist = relist;
|
||
this.relive = data.relive;
|
||
this.level = data.level;
|
||
this.sat_integral = data.sat_integral;
|
||
this.offlinetime = data.offlinetime;
|
||
this.doublecnt = data.doublecnt;
|
||
this.unget_doublecnt = data.unget_doublecnt == null ? 0 : data.unget_doublecnt;
|
||
this.mend_date = data.mend_date == null ? "" : data.mend_date;
|
||
|
||
if (data.color && data.color.length > 0) {
|
||
let colors = SKDataUtil.jsonBy(data.color);
|
||
if (colors.c1) {
|
||
this.color1 = colors.c1;
|
||
}
|
||
if (colors.c2) {
|
||
this.color2 = colors.c2;
|
||
}
|
||
if (colors.p1) {
|
||
this.color_one_serial = colors.p1;
|
||
}
|
||
if (colors.p2) {
|
||
this.color_two_serial = colors.p2;
|
||
}
|
||
}
|
||
|
||
if (data.safecode != null) {
|
||
let array = data.safecode.split(':');
|
||
this.safe_password = array[1] || '';
|
||
this.safe_lock = parseInt(array[0]) || 0;
|
||
}
|
||
else {
|
||
this.safe_password = '';
|
||
this.safe_lock = 0;
|
||
}
|
||
this.currentEquips = [];
|
||
this.listEquips = [];
|
||
this.equipObjs = {};
|
||
this.lockerEquips = [];
|
||
let equipList: any = {};
|
||
if (data.equipRows) {
|
||
for (let info of data.equipRows) {
|
||
equipList[info.EquipID] = info;
|
||
}
|
||
}
|
||
for (let equipid in equipList) {
|
||
if (this.equipObjs[equipid] != null) {
|
||
continue;
|
||
}
|
||
let info = SKDataUtil.valueForKey(equipList, equipid);
|
||
if (info == null) {
|
||
SKLogger.warn(``);
|
||
} else {
|
||
let equip = new Equip(info, this);
|
||
switch (info.pos) {
|
||
case EEquipPos.USE: {
|
||
let find = false;
|
||
for (let useequip of this.currentEquips) {
|
||
if (useequip.EIndex == equip.EIndex) {
|
||
find = true;
|
||
equip.pos = EEquipPos.BAG;
|
||
this.addEquipList(equip);
|
||
}
|
||
}
|
||
if (!find) {
|
||
this.currentEquips.push(equip);
|
||
if (equip.EIndex == 6) {
|
||
let conf = EquipMgr.shared.getXianQiBy(equip.Type);
|
||
this.wingId = conf.Shape;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case EEquipPos.BAG: {
|
||
this.addEquipList(equip);
|
||
break;
|
||
}
|
||
case EEquipPos.BANK: {
|
||
this.lockerEquips.push(equip);
|
||
break;
|
||
}
|
||
default: {
|
||
equip.pos = EEquipPos.BAG;
|
||
this.addEquipList(equip);
|
||
}
|
||
}
|
||
this.equipObjs[equip.EquipID] = equip;
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]加入装备[${equip.EquipID}:${equip.name}]`);
|
||
}
|
||
}
|
||
// 水陆大会信息
|
||
this.initShuilu(data.shuilu);
|
||
this.initJingji(data.arena);
|
||
this.initRolePoint(data.addpoint);
|
||
this.checkRolePoint();
|
||
// 修炼等级
|
||
this.xiulevel = data.xiulevel;
|
||
this.initXiuLianPoint(data.xiupoint);
|
||
this.checkXiulianPoint();
|
||
// 设置等级在属性设置 之后设置！
|
||
this.setLevel(data.level);
|
||
// 取消技能熟练度升级，直接满级
|
||
this.resetSkill();
|
||
this.getpet = data.getpet;
|
||
// GM等级
|
||
this.gmlevel = data.gmlevel;
|
||
this.shane = data.shane;
|
||
if (this.shane > 0) {
|
||
let curDate = new Date();
|
||
let passtime = (curDate.getTime() - data.lastonline.getTime()) / 1000;
|
||
if (passtime > 0) {
|
||
this.shane -= Math.floor(passtime * 4);
|
||
}
|
||
if (this.shane <= 0) {
|
||
this.shane = 0;
|
||
}
|
||
}
|
||
let schemeMgr: SchemeMgr = new SchemeMgr(this);
|
||
this.schemeMgr = schemeMgr;
|
||
this.schemeMgr.readDB();
|
||
// 好友相关
|
||
let friendlist: any = SKDataUtil.jsonBy(data.friendlist) || {};
|
||
if (friendlist.version == 1) {
|
||
for (let roleid in friendlist) {
|
||
if (roleid == 'version') {
|
||
delete friendlist['version'];
|
||
continue;
|
||
}
|
||
if (friendlist.hasOwnProperty(roleid)) {
|
||
let finfo = friendlist[roleid];
|
||
try {
|
||
finfo.name = Buffer.from(finfo.name, 'base64').toString();
|
||
} catch (error) {
|
||
SKLogger.warn(`好友名称[${finfo.name}]编码失败`);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
this.friendList = friendlist;
|
||
// 兑换码
|
||
this.exchange = new Exchange(this.roleid);
|
||
this.exchange.readDB();
|
||
//阵法信息
|
||
if (!!data.zhenfa) {
|
||
var info = SKDataUtil.jsonBy(data.zhenfa);
|
||
this.ZFMgr.initByData(info)
|
||
}
|
||
|
||
if (!!data.xw) {
|
||
var info = SKDataUtil.jsonBy(data.xw);
|
||
this.XWMgr.loadData(info)
|
||
}
|
||
// 坐骑
|
||
this.horseList.setDB(data.horseRows);
|
||
this.horseList.horseIndex = SKDataUtil.clamp(data.horse_index, 0, 4);
|
||
// 坐骑技能
|
||
this.horseSkill.setDB(data.horseSkillRows);
|
||
this.setPetDB(data.petRows);
|
||
this.loaded = true;
|
||
if (data.day_count) {
|
||
this.dayMap = SKDataUtil.jsonBy(data.day_count);
|
||
}
|
||
// 不是机器人才进行读取签到数据和邮件数据
|
||
if (!this.isRobot()) {
|
||
// 获取当前角色签到数据
|
||
if (data.signIn[0]) {
|
||
// 补签日期
|
||
this.mendDate = data.signIn[0].mendDate == null ? "" : data.signIn[0].mendDate;
|
||
let signInInfo = SKDataUtil.jsonBy(data.signIn[0].daySignIn);
|
||
// 获取当前角色所签到的月份
|
||
let key: any = Object.keys(signInInfo);
|
||
// 储存的月份与当前月份不相等重新进行生成
|
||
if (key != GTimer.getCurMonth()) {
|
||
this.daySignIn = SKDataUtil.jsonBy(GameUtil.getDaySignIn());
|
||
} else {
|
||
this.daySignIn = signInInfo;
|
||
}
|
||
} else {
|
||
this.daySignIn = SKDataUtil.jsonBy(GameUtil.getDaySignIn());
|
||
}
|
||
// 获取当前角色签到数据
|
||
if (data.dial[0]) {
|
||
// 补签日期
|
||
this.dial_num = data.dial[0].dial_num;
|
||
this.dial_count = data.dial[0].dial_count;
|
||
this.dial_date = data.dial[0].dial_date;
|
||
} else {
|
||
this.dial_num = 1;
|
||
this.dial_count = 0;
|
||
this.dial_date = GTimer.getYearMonthDay();
|
||
}
|
||
this.mailList.setDB(data.mailRows);
|
||
}
|
||
this.OnlineReminder();
|
||
//宝宝信息
|
||
this.BabyMgr.setDB(data.baby)
|
||
this.StarMgr.setDB(data.star_info)
|
||
};
|
||
|
||
setTitles(titles: any) {
|
||
if (titles == null) {
|
||
return;
|
||
}
|
||
this.titles = titles.titles;
|
||
this.onLoad = titles.onload;
|
||
this.titles.filter((e: any) => {
|
||
if (e.onload) {
|
||
this.titleType = e.type;
|
||
this.titleId = e.titleid;
|
||
this.titleVal = e.value;
|
||
}
|
||
});
|
||
}
|
||
|
||
setActivateSchemeName(schemeName: any) {
|
||
this.schemeName = schemeName;
|
||
this.send('s2c_player_data', this.getData());
|
||
}
|
||
|
||
// 开启背包格子
|
||
openBackpackGrid() {
|
||
// 消耗金额
|
||
let price: number = GameUtil.bagPrice;
|
||
// 消耗金额类型
|
||
let consume_type: number = GameUtil.goldKind.Money;
|
||
|
||
// 当前背包格子大于65时,每开启5个格子固定消费仙玉(也就是开启75个格子时往后消费固定仙玉)
|
||
if (this.bagKindNum > 65) {
|
||
if (this.jade < price) {
|
||
this.send_notice(`仙玉不足无法开启物品格子`);
|
||
return;
|
||
}
|
||
consume_type = GameUtil.goldKind.Jade;
|
||
}
|
||
// 当前背包格子不等于初始格子并且当前背包格子小于65个格子时消费 银币
|
||
else if (this.bagKindNum != GameUtil.limitBagKindNum) {
|
||
// ((当前背包格子 - 默认背包格子) / 5 * 背包开启价格 + 背包开启价格) * 50
|
||
price = ((this.bagKindNum - GameUtil.limitBagKindNum) / 5 * GameUtil.bagPrice + GameUtil.bagPrice) * 50;
|
||
if (this.money < price) {
|
||
this.send_notice(`银币不足无法开启物品格子`);
|
||
return;
|
||
}
|
||
}
|
||
// 第一次开启格子
|
||
else {
|
||
if (this.money < price) {
|
||
this.send_notice(`银币不足无法开启物品格子`);
|
||
return;
|
||
}
|
||
}
|
||
// 增加背包格子
|
||
this.bagKindNum += 5;
|
||
// 扣钱金钱
|
||
this.addMoney(consume_type, -price, "", MsgCode.SUCCESS)
|
||
this.send('s2c_open_backpack_grid', {
|
||
num: this.bagKindNum
|
||
});
|
||
// 发送信息
|
||
this.send_notice(`你新增了5个物品格子`);
|
||
|
||
}
|
||
|
||
OnlineReminder() {
|
||
let name: any = [];
|
||
let moneyRank: any = null;
|
||
let levelRank: any = null;
|
||
let jingjiRank: any = null;
|
||
let moneyDesc: any = '';
|
||
let levelDesc: any = '';
|
||
let jingjiDesc: any = '';
|
||
moneyRank = PaiHangMgr.shared.getMoneyRank();
|
||
levelRank = PaiHangMgr.shared.getLevelRank();
|
||
jingjiRank = PaiHangMgr.shared.getJingJiRank();
|
||
for (let i = 0; i < 3; i++) {
|
||
SKLogger.debug(moneyRank.length)
|
||
if (moneyRank.length > 0 && moneyRank.length > i) {
|
||
name.push(moneyRank[i][1]);
|
||
}
|
||
SKLogger.debug(levelRank.length)
|
||
if (levelRank.length > 0 && levelRank.length > i) {
|
||
name.push(levelRank[i][1]);
|
||
}
|
||
SKLogger.debug(jingjiRank.length)
|
||
if (jingjiRank.length > 0 && jingjiRank.length > i) {
|
||
name.push(jingjiRank[i][1]);
|
||
}
|
||
}
|
||
let allname: any = SKDataUtil.unique(name);
|
||
for (let j = 0; j < allname.length; j++) {
|
||
if (allname[j] == this.name) {
|
||
for (let n = 0; n < 3; n++) {
|
||
if (moneyRank.length > 0 && moneyRank.length > n) {
|
||
if (moneyRank[n][0] == this.name) {
|
||
moneyDesc = `财富排行第${n + 1}`;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
for (let m = 0; m < 3; m++) {
|
||
if (levelRank.length > 0 && levelRank.length > m) {
|
||
if (levelRank[m][0] == this.name) {
|
||
levelDesc = `练功狂人排行第${m + 1}`;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
for (let k = 0; k < 3; k++) {
|
||
if (jingjiRank.length > 0 && jingjiRank.length > k) {
|
||
if (jingjiRank[k][0] == this.name) {
|
||
jingjiDesc = `竞技排行第${k + 1}`;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
let strRichText = `<color=#0fffff > ${moneyDesc}</color ><color=#0fffff > ${levelDesc}</color ><color=#0fffff > ${jingjiDesc}</color ><color=#00ff00 > ${allname[j]}</c > <color=#ffffff > 玩家,上线了！</c >`;
|
||
PlayerMgr.shared.broadcast('s2c_screen_msg', {
|
||
strRichText: strRichText,
|
||
bInsertFront: 0
|
||
});
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
checkEquipExist(equipId: any) {
|
||
let checkRes = false;
|
||
checkRes = this.currentEquips.some((e: any) => {
|
||
return e.EquipID == equipId;
|
||
})
|
||
if (!checkRes) {
|
||
return this.listEquips.some((e: any) => {
|
||
return e.EquipID == equipId;
|
||
});
|
||
}
|
||
return checkRes;
|
||
}
|
||
|
||
initBang(bangid: any) {
|
||
// 检查是否被踢
|
||
this.bangid = bangid;
|
||
if (this.bangid > 0 && BangMgr.shared.bangList[this.bangid] == null) {
|
||
this.bangid = 0;
|
||
}
|
||
if (this.bangid != 0) {
|
||
let bang = BangMgr.shared.getBang(this.bangid);
|
||
if (bang == null) {
|
||
SKLogger.info(`没有找到帮编号${this.bangid}`)
|
||
this.bangid = 0;
|
||
} else {
|
||
if (bang.isinit == true) {
|
||
if (bang.checkPlayer(this.roleid)) {
|
||
if (bang.masterid == this.roleid) {
|
||
bang.mastername = this.name;
|
||
}
|
||
this.bangname = bang.name;
|
||
this.bangpost = bang.getBangPost(this.roleid);
|
||
if (bang.masterid == this.roleid) {
|
||
this.addTitle(GameUtil.titleType.CommonTitle, GameUtil.titleBangType.BangZhu, '', false);
|
||
} else {
|
||
this.addTitle(GameUtil.titleType.CommonTitle, GameUtil.titleBangType.BangZhong, '', false);
|
||
}
|
||
} else {
|
||
SKLogger.info(`${this.name}:没有找到帮编号${this.bangid}`)
|
||
this.bangid = 0;
|
||
this.bangname = '';
|
||
this.bangpost = 0;
|
||
this.delTitle(GameUtil.titleType.CommonTitle, GameUtil.titleBangType.BangZhu);
|
||
this.delTitle(GameUtil.titleType.CommonTitle, GameUtil.titleBangType.BangZhong);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
initShuilu(shuiluinfo: any) {
|
||
this.shuilu = {
|
||
season: 1,
|
||
score: 0,
|
||
gongji: 0,
|
||
wtime: 0,
|
||
ltime: 0,
|
||
};
|
||
if (shuiluinfo) {
|
||
let t = SKDataUtil.jsonBy(shuiluinfo);
|
||
this.shuilu.season = t.season ? t.season : 0;
|
||
this.shuilu.score = t.score ? t.score : 0;
|
||
this.shuilu.gongji = t.gongji ? t.gongji : 0;
|
||
this.shuilu.wtime = t.wtime ? t.wtime : 0;
|
||
this.shuilu.ltime = t.ltime ? t.ltime : 0;
|
||
}
|
||
let shuiludahui = ActivityMgr.shared.getActivity(ActivityDefine.activityKindID.ShuiLuDaHui);
|
||
if (shuiludahui && this.shuilu.season != shuiludahui.season) {
|
||
this.shuilu.season = shuiludahui.season;
|
||
this.shuilu.score = 0;
|
||
this.shuilu.wtime = 0;
|
||
this.shuilu.ltime = 0;
|
||
}
|
||
}
|
||
initJingji(jingjiinfo: any) {
|
||
this.arena = {
|
||
count: 10,
|
||
jpoint: 0,
|
||
jtime: 0,
|
||
ranking: 0,
|
||
};
|
||
if (jingjiinfo) {
|
||
let t = SKDataUtil.jsonBy(jingjiinfo);
|
||
this.arena.count = t.count ? t.count : 10;
|
||
this.arena.jpoint = t.jpoint ? t.jpoint : 0;
|
||
this.arena.jtime = t.jtime ? t.jtime : 0;
|
||
this.arena.ranking = t.ranking ? t.ranking : 0;
|
||
}
|
||
}
|
||
// 升级技能
|
||
updateSkill(data: any) {
|
||
if (this.skill_list[data.skillId] == null) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `找不到技能[${SkillUtil.getSkillName(data.skillId)}]`
|
||
});
|
||
return;
|
||
}
|
||
let maxLevel = ExpUtil.getMaxSkillLevel(this.relive);
|
||
if (this.skill_list[data.skillId] > maxLevel) {
|
||
this.skill_list[data.skillId] = maxLevel;
|
||
}
|
||
if (this.skill_list[data.skillId] >= maxLevel) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `技能[${SkillUtil.getSkillName(data.skillId)}]已经满级了!`
|
||
});
|
||
return;
|
||
}
|
||
this.skill_list[data.skillId] += 100;
|
||
if (this.skill_list[data.skillId] > maxLevel) {
|
||
this.skill_list[data.skillId] = maxLevel;
|
||
}
|
||
this.send('s2c_player_data', this.getData());
|
||
let info = this.CostFee(GameUtil.goldKind.Money, data.costMoney); //升级技能所消耗的金币
|
||
if (info.length > 0) {
|
||
this.send('s2c_notice', {
|
||
strRichText: info
|
||
});
|
||
}
|
||
}
|
||
|
||
addCustomPoint(data: any) {
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
let addlist = SKDataUtil.jsonBy(data.addattr);
|
||
let alladd = 0;
|
||
for (const key in addlist) {
|
||
if (addlist.hasOwnProperty(key)) {
|
||
//如果有负数，跳过
|
||
if (addlist[key] < 0) {
|
||
continue;
|
||
}
|
||
alladd += addlist[key];
|
||
}
|
||
}
|
||
//如果加点超过1500点
|
||
if (alladd > 1500 || alladd < 0) {
|
||
return;
|
||
}
|
||
if (alladd == 0) {
|
||
return;
|
||
}
|
||
if (alladd <= this.qianneng) {
|
||
for (const key in this.addattr2) {
|
||
if (addlist.hasOwnProperty(key) && this.addattr2.hasOwnProperty(key)) {
|
||
this.addattr2[key] += addlist[key];
|
||
}
|
||
}
|
||
this.calQianNeng();
|
||
this.calculateAttr();
|
||
if (player) {
|
||
//cxf人物加点
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: player.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.ITEM,
|
||
operateDepict: "人物加点",
|
||
operateResSerial: player.roleid,
|
||
operateResName: player.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
// this.send('s2c_player_data', this.getData());
|
||
this.schemeMgr && this.schemeMgr.syncSchemePoint();
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
// 如果在队伍中需要刷新队伍信息
|
||
this.refresh_team_data();
|
||
}
|
||
}
|
||
|
||
// 属性检测
|
||
freeze() {
|
||
//如果玩家根骨、灵性、力量、敏捷等属性超过2000点
|
||
if (this.attr1[EAttrTypeL1.BONE] > 2000 || this.attr1[EAttrTypeL1.SPIRIT] > 2000 || this.attr1[EAttrTypeL1.STRENGTH] > 2000 || this.attr1[EAttrTypeL1.DEXTERITY] > 2000) {
|
||
this.send_notice('系统检测属性异常，请联系管理人员说明情况否则，对您进行封号处理');
|
||
// DB.freezeIP(this.accountid, (ret: any, ip: any) => {
|
||
// if (ret == MsgCode.SUCCESS) {
|
||
// if (ip == 0) {
|
||
// return;
|
||
// }
|
||
// delete PlayerMgr.shared.player_role_list[this.roleid];
|
||
// delete PlayerMgr.shared.player_only_list[this.onlyid];
|
||
// this.destroy();
|
||
// FrozenIPMgr.shared.addFrozenIP(ip,this.accountid);
|
||
// Signal.shared.DeleteTocken(this.accountid);
|
||
// }
|
||
// });
|
||
}
|
||
}
|
||
|
||
|
||
initTaskMgr(data: string) {
|
||
let dict: any = SKDataUtil.jsonBy(data) || {};
|
||
let vecStateList = SKDataUtil.getDefault(dict.StateList, []);
|
||
let vecRecordList = SKDataUtil.getDefault(dict.RecordList, []);
|
||
let mapDailyCnt = SKDataUtil.getDefault(dict.DailyCnt, {});
|
||
let mapFuBenCnt = SKDataUtil.getDefault(dict.FuBenCnt, {});
|
||
let mapDailyStart = SKDataUtil.getDefault(dict.DailyStart, {});
|
||
let mapActiveScore = SKDataUtil.getDefault(dict.mapActiveScore, {});
|
||
let szBeenTake = SKDataUtil.getDefault(dict.szBeenTake, [0, 0, 0, 0, 0, 0]);
|
||
this.getTaskMgr().init(vecStateList, vecRecordList, mapDailyCnt, mapFuBenCnt, mapDailyStart, mapActiveScore, szBeenTake);
|
||
}
|
||
// 设置召唤兽数据
|
||
setPetDB(rows: any) {
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]加载召唤兽列表...`);
|
||
if (rows == null || rows.length < 1) {
|
||
this.getpet = 0;
|
||
} else {
|
||
for (let item of rows) {
|
||
if (item.state == 0) { // 被删除
|
||
continue;
|
||
}
|
||
let pet = new Pet(item.dataid);
|
||
pet.setOwner(this);
|
||
pet.setDB(item);
|
||
this.petList.push(pet);
|
||
if (this.curPetId == 0) {
|
||
this.curPetId = pet.petid;
|
||
this.curPet = pet;
|
||
} else if (this.curPetId == pet.petid) {
|
||
this.curPet = pet;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 重置技能,取消技能熟练度升级，直接满级
|
||
resetSkill() {
|
||
let conf: any = GameUtil.defineSkill;
|
||
this.skill_list = SKDataUtil.clone(conf[this.race][this.sex]);
|
||
let maxLevel = ExpUtil.getMaxSkillLevel(this.relive);
|
||
for (let skillId in this.skill_list) {
|
||
this.skill_list[skillId] = maxLevel;
|
||
}
|
||
}
|
||
// 机器人重置技能,取消技能熟练度升级，直接满级
|
||
resetRoleSkill() {
|
||
let conf: any = GameUtil.robotDefineSkill;
|
||
this.skill_list = SKDataUtil.clone(conf[this.race][this.sex]);
|
||
let maxLevel = ExpUtil.getMaxSkillLevel(this.relive);
|
||
for (let skillId in this.skill_list) {
|
||
this.skill_list[skillId] = maxLevel;
|
||
}
|
||
}
|
||
// 初始化角色加点
|
||
initRolePoint(rolepoints: any) {
|
||
if (rolepoints == null) {
|
||
return;
|
||
}
|
||
if (rolepoints.length > 0 && (rolepoints[0] == '{' || rolepoints[0] == '[')) {
|
||
let setPonit2 = (key: any, num: any) => {
|
||
if (typeof (num) == 'number' && !isNaN(num)) {
|
||
this.addattr2[key] = num > 0 ? num : 0;
|
||
}
|
||
}
|
||
let addpoint = SKDataUtil.jsonBy(rolepoints);
|
||
setPonit2(EAttrTypeL2.GENGU, addpoint[EAttrTypeL2.GENGU]);
|
||
setPonit2(EAttrTypeL2.LINGXING, addpoint[EAttrTypeL2.LINGXING]);
|
||
setPonit2(EAttrTypeL2.MINJIE, addpoint[EAttrTypeL2.MINJIE]);
|
||
setPonit2(EAttrTypeL2.LILIANG, addpoint[EAttrTypeL2.LILIANG]);
|
||
}
|
||
}
|
||
|
||
updateFriend(pInfo: any) {
|
||
let friend = this.friendList[pInfo.roleid];
|
||
if (friend) {
|
||
this.friendList[pInfo.roleid].name = pInfo.name;
|
||
}
|
||
}
|
||
// 获得好友数量
|
||
getFriendNum(): number {
|
||
let n = 0;
|
||
for (let pid in this.friendList) {
|
||
if (this.friendList.hasOwnProperty(pid)) {
|
||
n++;
|
||
}
|
||
}
|
||
return n;
|
||
}
|
||
|
||
checkRolePoint() {
|
||
let qncount = this.level * 4; // LevelMgr.getRoleLevelQianneng();
|
||
let qn = 0;
|
||
for (const key in this.addattr2) {
|
||
if (this.addattr2.hasOwnProperty(key)) {
|
||
qn += this.addattr2[key];
|
||
}
|
||
}
|
||
if (qn > qncount) {
|
||
this.resetRolePoint();
|
||
this.calQianNeng();
|
||
}
|
||
}
|
||
|
||
initXiuLianPoint(xiupoints: any) {
|
||
if (xiupoints != null) {
|
||
if (xiupoints.length > 0 && (xiupoints[0] == '{' || xiupoints[0] == '[')) {
|
||
let setPonit1 = (key: any, num: any) => {
|
||
if (typeof (num) == 'number' && !isNaN(num)) {
|
||
this.addattr1[key] = num > 0 ? num : 0;
|
||
}
|
||
}
|
||
let xiupoint = SKDataUtil.jsonBy(xiupoints);
|
||
for (const attrtype in xiupoint) {
|
||
if (xiupoint.hasOwnProperty(attrtype)) {
|
||
const num = xiupoint[attrtype];
|
||
setPonit1(attrtype, num);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
checkXiulianPoint() {
|
||
let maxlevel = RolePracticeMgr.shared.GetMaxPriactiveLevel(this.relive);
|
||
if (this.xiulevel > maxlevel) {
|
||
this.xiulevel = maxlevel;
|
||
this.resetXiulianPoint();
|
||
return;
|
||
}
|
||
let xlpoint = 0
|
||
for (const key in this.addattr1) {
|
||
if (this.addattr1.hasOwnProperty(key)) {
|
||
const p = this.addattr1[key];
|
||
xlpoint += p;
|
||
}
|
||
}
|
||
if (xlpoint > this.xiulevel) {
|
||
this.resetXiulianPoint();
|
||
}
|
||
}
|
||
|
||
getTotalQianneng() {
|
||
return this.level * 4;
|
||
}
|
||
|
||
calQianNeng() {
|
||
let qncount = this.level * 4; // LevelMgr.getRoleLevelQianneng();
|
||
let qn = 0;
|
||
for (const key in this.addattr2) {
|
||
if (this.addattr2.hasOwnProperty(key)) {
|
||
qn += this.addattr2[key];
|
||
}
|
||
}
|
||
let left_qn = qncount - qn;
|
||
this.qianneng = left_qn;
|
||
//当潜能值发生变化时，同步方案潜能值
|
||
this.schemeMgr && this.schemeMgr.syncSchemePoint();
|
||
}
|
||
|
||
calculatePointAttr() {
|
||
this.calQianNeng();
|
||
this.setAttr1(EAttrTypeL1.BONE, this.level + this.addattr2[EAttrTypeL1.BONE]);
|
||
this.setAttr1(EAttrTypeL1.STRENGTH, this.level + this.addattr2[EAttrTypeL1.STRENGTH]);
|
||
this.setAttr1(EAttrTypeL1.SPIRIT, this.level + this.addattr2[EAttrTypeL1.SPIRIT]);
|
||
this.setAttr1(EAttrTypeL1.DEXTERITY, this.level + this.addattr2[EAttrTypeL1.DEXTERITY]);
|
||
}
|
||
|
||
calculateZhenfaAttr() {
|
||
console.log("calculateZhenfaAttr.......")
|
||
this.ZFMgr.calculateZhenfaAttr(this.attr1)
|
||
}
|
||
|
||
calculateStarAttr() {
|
||
this.StarMgr.calculateStarAttr(this.attr1)
|
||
}
|
||
|
||
calculateEquipAttr() {
|
||
if (this.currentEquips) {
|
||
let list = [EAttrTypeL1.HP, EAttrTypeL1.MP, EAttrTypeL1.HP_MAX, EAttrTypeL1.MP_MAX, EAttrTypeL1.ATK, EAttrTypeL1.SPD];
|
||
for (const equip of this.currentEquips) {
|
||
for (let key in EAttrTypeL1) {
|
||
let value = SKDataUtil.numberBy(key);
|
||
if (isNaN(value)) {
|
||
continue;
|
||
}
|
||
if (list.indexOf(value) != -1) {
|
||
continue;
|
||
}
|
||
let equipattr = equip.getAttr(value);
|
||
if (equipattr == null || equipattr == 0) {
|
||
continue;
|
||
}
|
||
let addattr = GameUtil.attrToBaseAttr[value];
|
||
if (addattr != null) {
|
||
let target_attr = addattr.target;
|
||
if (addattr.cal == EAttrCalType.ADD_PERCENT) {
|
||
this.attr1[target_attr] = (1 + equipattr / 100) * this.attr1[target_attr];
|
||
} else if (addattr.cal == EAttrCalType.PERCENT) {
|
||
this.attr1[target_attr] = (equipattr / 100) * this.attr1[target_attr];
|
||
} else if (addattr.cal == EAttrCalType.ADD_NUM) {
|
||
this.attr1[target_attr] += equipattr;
|
||
}
|
||
} else {
|
||
this.attr1[value] += equipattr;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
this.checkBaldricSuit();
|
||
this.checkPlayerOfudaUseState();
|
||
}
|
||
// 检查佩饰套装
|
||
checkBaldricSuit() {
|
||
let suitId: number = -1;
|
||
let suitName: string = "";
|
||
let suitCount: number = 0;
|
||
for (let equip of this.currentEquips) {
|
||
if (ItemUtil.isBaldric(equip.EIndex)) {
|
||
let itemData = ItemUtil.getItemData(equip.Type);
|
||
if (itemData) {
|
||
if (suitId == -1) {
|
||
suitId = itemData.level;
|
||
suitName = itemData.name.substring(0, 2);
|
||
suitCount++;
|
||
} else if (suitId == itemData.level) { //如果品级一样 则配饰技能不变
|
||
suitId = itemData.level;
|
||
suitCount++;
|
||
} else if (suitName == itemData.name.substring(0, 2)) {
|
||
if (suitId > itemData.level) { //如果比原配饰品级低 则替换成低级的技能
|
||
suitId = itemData.level;
|
||
}
|
||
suitCount++;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (suitCount >= 5) {
|
||
let suitData = ItemUtil.getBaldricSuit(suitId);
|
||
if (suitData) {
|
||
let skill = SkillUtil.getSkill(suitData.skill);
|
||
if (skill) {
|
||
this.baldric = skill.skill_id;
|
||
this.calcBaldricSkill(skill, 0, "佩饰技能");
|
||
}
|
||
}
|
||
} else {
|
||
this.baldric = 0;
|
||
}
|
||
}
|
||
//检查正在使用的天策符
|
||
checkPlayerOfudaUseState() {
|
||
let ms1 = new Date().getMilliseconds();
|
||
let ofuda_map = Ofuda.shared.inUseOfudaByRoleid(this.roleid);
|
||
if (ofuda_map == null || ofuda_map == undefined) {
|
||
return;
|
||
}
|
||
if (ofuda_map.size > 0) {
|
||
for (let [key, value] of ofuda_map) {
|
||
if (value.oftype == 1 || value.oftype == 2) {
|
||
let skill = SkillUtil.getSkill(key);
|
||
this.calcBaldricSkill(skill, value.addition, "天策符")
|
||
}
|
||
if (value.oftype == 3) {
|
||
for (let pet of this.petList) {
|
||
pet.calculateAttribute();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let ms2 = new Date().getMilliseconds();
|
||
let time = ms2 - ms1;
|
||
SKLogger.info(`检查正在使用的天策符-运行时间：${time}ms`);
|
||
}
|
||
checkPetOfudaUseState(pet: any, attr: any) {
|
||
let ofuda_map = Ofuda.shared.inUseOfudaByRoleid(this.roleid);
|
||
if (ofuda_map == null || ofuda_map == undefined) {
|
||
return 0;
|
||
}
|
||
if (ofuda_map.size > 0) {
|
||
for (let [key, value] of ofuda_map) {
|
||
if (value.oftype == 3) {
|
||
let skill = SkillUtil.getSkill(key);
|
||
if (attr == EAttrTypeL1.PHY_BREAK) {
|
||
if (skill.skill_id == ESkillType.MengGong1 || skill.skill_id == ESkillType.MengGong2 || skill.skill_id == ESkillType.MengGong3) {
|
||
return this.petOfudaAttr(skill, value.addition, pet);
|
||
}
|
||
continue;
|
||
} else if (attr == EAttrTypeL1.PHY_BREAK_PROB) {
|
||
if (skill.skill_id == ESkillType.KanPo1 || skill.skill_id == ESkillType.KanPo2 || skill.skill_id == ESkillType.KanPo3) {
|
||
return this.petOfudaAttr(skill, value.addition, pet);
|
||
}
|
||
continue;
|
||
} else if (attr == EAttrTypeL1.PHY_HIT) {
|
||
if (skill.skill_id == ESkillType.JingZhun1 || skill.skill_id == ESkillType.JingZhun2 || skill.skill_id == ESkillType.JingZhun3) {
|
||
return this.petOfudaAttr(skill, value.addition, pet);
|
||
}
|
||
continue;
|
||
} else if (attr == EAttrTypeL1.PHY_REBOUND) {
|
||
if (skill.skill_id == ESkillType.HuWei1 || skill.skill_id == ESkillType.HuWei2 || skill.skill_id == ESkillType.HuWei3) {
|
||
return this.petOfudaAttr(skill, value.addition, pet);
|
||
}
|
||
continue;
|
||
} else if (attr == EAttrTypeL1.K_DETER) {
|
||
if (skill.skill_id == ESkillType.LianXi1 || skill.skill_id == ESkillType.LianXi2 || skill.skill_id == ESkillType.LianXi3) {
|
||
return this.petOfudaAttr(skill, value.addition, pet);
|
||
}
|
||
continue;
|
||
} else if (attr == EAttrTypeL1.K_SEAL) {
|
||
if (skill.skill_id == ESkillType.HuiGen1 || skill.skill_id == ESkillType.HuiGen2 || skill.skill_id == ESkillType.HuiGen3) {
|
||
return this.petOfudaAttr(skill, value.addition, pet);
|
||
}
|
||
continue;
|
||
} else if (attr == EAttrTypeL1.K_CONFUSION) {
|
||
if (skill.skill_id == ESkillType.HuiGen1 || skill.skill_id == ESkillType.HuiGen2 || skill.skill_id == ESkillType.HuiGen3) {
|
||
return this.petOfudaAttr(skill, value.addition, pet);
|
||
}
|
||
continue;
|
||
} else if (attr == EAttrTypeL1.K_SLEEP) {
|
||
if (skill.skill_id == ESkillType.HuiGen1 || skill.skill_id == ESkillType.HuiGen2 || skill.skill_id == ESkillType.HuiGen3) {
|
||
return this.petOfudaAttr(skill, value.addition, pet);
|
||
}
|
||
continue;
|
||
} else if (attr == EAttrTypeL1.K_FORGET) {
|
||
if (skill.skill_id == ESkillType.HuiGen1 || skill.skill_id == ESkillType.HuiGen2 || skill.skill_id == ESkillType.HuiGen3) {
|
||
return this.petOfudaAttr(skill, value.addition, pet);
|
||
}
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
calcOfudaSkill(skill: SkillBase, addition: number) {
|
||
if (skill == null) {
|
||
return 0;
|
||
}
|
||
if (skill.action_type != EActionType.PASSIVE) {
|
||
return 0;
|
||
}
|
||
let level = 0;
|
||
let bang = BangMgr.shared.getBang(this.bangid);
|
||
if (bang) {
|
||
let list = bang.rolelist;
|
||
for (let key in list) {
|
||
if (this.roleid == list[key].roleid) {
|
||
level = list[key].ofudalevel;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
let effectMap = skill.effectMap;
|
||
for (let key in effectMap) {
|
||
let type: EAttrTypeL1 = SKDataUtil.numberBy(key);
|
||
let ret = skill.getBaldricEffect(type);
|
||
return ret.add = SKDataUtil.toDecimal2((1 + (addition * 0.1)) * (level * 0.1));
|
||
}
|
||
return 0;
|
||
}
|
||
// 计算佩饰技能
|
||
calcBaldricSkill(skill: SkillBase, addition: number, prefix: string) {
|
||
if (skill == null) {
|
||
return;
|
||
}
|
||
if (skill.action_type != EActionType.PASSIVE) {
|
||
return;
|
||
}
|
||
let level = 0;
|
||
let bang = BangMgr.shared.getBang(this.bangid);
|
||
if (bang) {
|
||
let list = bang.rolelist;
|
||
for (let key in list) {
|
||
if (this.roleid == list[key].roleid) {
|
||
level = list[key].ofudalevel;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
let effectMap = skill.effectMap;
|
||
for (let key in effectMap) {
|
||
let type: EAttrTypeL1 = SKDataUtil.numberBy(key);
|
||
let ret = skill.getBaldricEffect(type);
|
||
if (prefix == "天策符") {
|
||
if (ret.add < 0) {
|
||
ret.add = Math.floor((1 + (addition * 0.1)) * (level * 0.1) * (ret.add / 10));
|
||
} else {
|
||
|
||
ret.add = SKDataUtil.toDecimal2((1 + (addition * 0.1)) * (level * 0.1));
|
||
}
|
||
}
|
||
if (ret.add) {
|
||
let old = SKDataUtil.toDecimal2(this.attr1[type]);
|
||
if (!(type == 0 || type == 1 || type == 2 || type == 9)) {
|
||
this.attr1[type] = SKDataUtil.toDecimal2(old + ret.add);
|
||
}
|
||
let current: number = this.attr1[type];
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]佩饰技能[${skill.skill_name}][${GameUtil.attrTypeL1Name[type]}]改变[${ret.add}]:${old}->${current}`);
|
||
let oldHP = this.attr1[EAttrTypeL1.HP];
|
||
let oldMP = this.attr1[EAttrTypeL1.MP];
|
||
let oldATK = this.attr1[EAttrTypeL1.ATK];
|
||
let oldSPD = this.attr1[EAttrTypeL1.SPD];
|
||
if (prefix != "天策符") {
|
||
if (type == EAttrTypeL1.HP_MAX) {
|
||
this.attr1[EAttrTypeL1.HP] = this.attr1[EAttrTypeL1.HP_MAX];
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]佩饰技能[${skill.skill_name}]气血最大值改变:${oldHP}->${this.attr1[EAttrTypeL1.HP]}`);
|
||
} else if (type == EAttrTypeL1.MP_MAX) {
|
||
this.attr1[EAttrTypeL1.MP] = this.attr1[EAttrTypeL1.MP_MAX];
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]佩饰技能[${skill.skill_name}]法力最大值改变:${oldMP}->${this.attr1[EAttrTypeL1.MP]}`);
|
||
} else if (type == EAttrTypeL1.HP_PERC) {
|
||
this.attr1[EAttrTypeL1.HP] = Math.floor(this.attr1[EAttrTypeL1.HP_MAX] * (1 + ret.add / 100));
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]佩饰技能[${skill.skill_name}]气血百分比改变:${oldHP}->${this.attr1[EAttrTypeL1.HP]}`);
|
||
} else if (type == EAttrTypeL1.MP_PERC) {
|
||
this.attr1[EAttrTypeL1.MP] = Math.floor(this.attr1[EAttrTypeL1.MP_MAX] * (1 + ret.add / 100));
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]佩饰技能[${skill.skill_name}]法力百分比改变:${oldMP}->${this.attr1[EAttrTypeL1.MP]}`);
|
||
} else if (type == EAttrTypeL1.ATK_PERC) {
|
||
this.attr1[EAttrTypeL1.ATK] = Math.floor(this.attr1[EAttrTypeL1.ATK] * (1 + ret.add / 100));
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]佩饰技能[${skill.skill_name}]攻击百分比改变:${oldATK}->${this.attr1[EAttrTypeL1.ATK]}`);
|
||
} else if (type == EAttrTypeL1.ATK_ADD) {
|
||
this.attr1[EAttrTypeL1.ATK] = Math.floor(this.attr1[EAttrTypeL1.ATK] * (1 + ret.add / 100));
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]佩饰技能[${skill.skill_name}]攻击百分比改变:${oldATK}->${this.attr1[EAttrTypeL1.ATK]}`);
|
||
} else if (type == EAttrTypeL1.SPD_PERC) {
|
||
this.attr1[EAttrTypeL1.SPD] = Math.floor(this.attr1[EAttrTypeL1.SPD] * (1 + ret.add / 100));
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]佩饰技能[${skill.skill_name}]速度百分比改变:${oldSPD}->${this.attr1[EAttrTypeL1.SPD]}`);
|
||
} else if (type == EAttrTypeL1.CURE_EHAN) {//加强治愈
|
||
this.attr1[EAttrTypeL1.CURE_EHAN] = Math.floor(this.attr1[EAttrTypeL1.CURE_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.SWEEP_EHAN) {//加强横扫
|
||
this.attr1[EAttrTypeL1.SWEEP_EHAN] = Math.floor(this.attr1[EAttrTypeL1.SWEEP_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.BREAK_EHAN) {//加强破甲
|
||
this.attr1[EAttrTypeL1.BREAK_EHAN] = Math.floor(this.attr1[EAttrTypeL1.BREAK_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.THUD_EHAN) {//加强震击
|
||
this.attr1[EAttrTypeL1.THUD_EHAN] = Math.floor(this.attr1[EAttrTypeL1.THUD_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.BLOODRETURN_EHAN) {//加强三尸
|
||
this.attr1[EAttrTypeL1.BLOODRETURN_EHAN] = Math.floor(this.attr1[EAttrTypeL1.BLOODRETURN_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_WIND) {//忽视抗风
|
||
this.attr1[EAttrTypeL1.HK_WIND] = Math.floor(this.attr1[EAttrTypeL1.HK_WIND] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_WILDFIRE) {//忽视抗鬼火
|
||
this.attr1[EAttrTypeL1.HK_WILDFIRE] = Math.floor(this.attr1[EAttrTypeL1.HK_WILDFIRE] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.K_BLOODRETURN) {//抗三尸
|
||
this.attr1[EAttrTypeL1.K_BLOODRETURN] = Math.floor(this.attr1[EAttrTypeL1.K_BLOODRETURN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_BLOODRETURN) {//忽视抗三尸
|
||
this.attr1[EAttrTypeL1.HK_BLOODRETURN] = Math.floor(this.attr1[EAttrTypeL1.HK_BLOODRETURN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.K_CONFUSION) {//抗混乱
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] = Math.floor(this.attr1[EAttrTypeL1.K_CONFUSION] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_CONFUSION) {//忽视抗混乱
|
||
this.attr1[EAttrTypeL1.HK_CONFUSION] = Math.floor(this.attr1[EAttrTypeL1.HK_CONFUSION] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_FIRE) {//忽视抗火
|
||
this.attr1[EAttrTypeL1.HK_FIRE] = Math.floor(this.attr1[EAttrTypeL1.HK_FIRE] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_WATER) {//忽视抗水
|
||
this.attr1[EAttrTypeL1.HK_WATER] = Math.floor(this.attr1[EAttrTypeL1.HK_WATER] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_THUNDER) {//忽视雷
|
||
this.attr1[EAttrTypeL1.HK_THUNDER] = Math.floor(this.attr1[EAttrTypeL1.HK_THUNDER] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.K_SLEEP) {//抗睡
|
||
this.attr1[EAttrTypeL1.K_SLEEP] = Math.floor(this.attr1[EAttrTypeL1.K_SLEEP] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_SLEEP) {//忽视抗睡
|
||
this.attr1[EAttrTypeL1.HK_SLEEP] = Math.floor(this.attr1[EAttrTypeL1.HK_SLEEP] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.PHY_DODGE) {//闪避
|
||
this.attr1[EAttrTypeL1.PHY_DODGE] = Math.floor(this.attr1[EAttrTypeL1.PHY_DODGE] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.K_DETER) {//抗震慑
|
||
this.attr1[EAttrTypeL1.PHY_DODGE] = Math.floor(this.attr1[EAttrTypeL1.PHY_DODGE] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_DETER) {//忽视抗震慑
|
||
this.attr1[EAttrTypeL1.HK_DETER] = Math.floor(this.attr1[EAttrTypeL1.HK_DETER] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.PHY_BREAK) {//破防程度
|
||
this.attr1[EAttrTypeL1.PHY_BREAK] = Math.floor(this.attr1[EAttrTypeL1.PHY_BREAK] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.PHY_BREAK_PROB) {//破防率
|
||
this.attr1[EAttrTypeL1.PHY_BREAK_PROB] = Math.floor(this.attr1[EAttrTypeL1.PHY_BREAK_PROB] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_FORGET) {//忽视抗遗忘
|
||
this.attr1[EAttrTypeL1.HK_FORGET] = Math.floor(this.attr1[EAttrTypeL1.HK_FORGET] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.S_GOLD) {//强力克金
|
||
this.attr1[EAttrTypeL1.S_GOLD] = Math.floor(this.attr1[EAttrTypeL1.S_GOLD] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.S_WOOD) {//强力克木
|
||
this.attr1[EAttrTypeL1.S_WOOD] = Math.floor(this.attr1[EAttrTypeL1.S_WOOD] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.S_WATER) {//强力克水
|
||
this.attr1[EAttrTypeL1.S_WATER] = Math.floor(this.attr1[EAttrTypeL1.S_WATER] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.S_FIRE) {//强力克火
|
||
this.attr1[EAttrTypeL1.S_FIRE] = Math.floor(this.attr1[EAttrTypeL1.S_FIRE] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.S_SOIL) {//强力克土
|
||
this.attr1[EAttrTypeL1.S_SOIL] = Math.floor(this.attr1[EAttrTypeL1.S_SOIL] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.KB_WIND) {//风系狂暴率
|
||
this.attr1[EAttrTypeL1.KB_WIND] = Math.floor(this.attr1[EAttrTypeL1.KB_WIND] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.KB_FIRE) {//火系狂暴率
|
||
this.attr1[EAttrTypeL1.KB_FIRE] = Math.floor(this.attr1[EAttrTypeL1.KB_FIRE] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.KB_WATER) {//水系狂暴率
|
||
this.attr1[EAttrTypeL1.KB_WATER] = Math.floor(this.attr1[EAttrTypeL1.KB_WATER] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.KB_THUNDER) {//雷系狂暴率
|
||
this.attr1[EAttrTypeL1.KB_THUNDER] = Math.floor(this.attr1[EAttrTypeL1.KB_THUNDER] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.KB_BLOODRETURN) {//三尸狂暴率
|
||
this.attr1[EAttrTypeL1.KB_BLOODRETURN] = Math.floor(this.attr1[EAttrTypeL1.KB_BLOODRETURN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.KB_WILDFIRE) {//鬼火狂暴率
|
||
this.attr1[EAttrTypeL1.KB_WILDFIRE] = Math.floor(this.attr1[EAttrTypeL1.KB_WILDFIRE] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.Q_BLOODRETURN) {//三尸狂暴
|
||
this.attr1[EAttrTypeL1.Q_BLOODRETURN] = Math.floor(this.attr1[EAttrTypeL1.Q_BLOODRETURN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.Q_WILDFIRE) {//鬼火狂暴
|
||
this.attr1[EAttrTypeL1.Q_WILDFIRE] = Math.floor(this.attr1[EAttrTypeL1.Q_WILDFIRE] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.Q_WIND) {//风系狂暴
|
||
this.attr1[EAttrTypeL1.Q_WIND] = Math.floor(this.attr1[EAttrTypeL1.Q_WIND] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.Q_FIRE) {//火系狂暴
|
||
this.attr1[EAttrTypeL1.Q_FIRE] = Math.floor(this.attr1[EAttrTypeL1.Q_FIRE] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.Q_WATER) {//水系狂暴
|
||
this.attr1[EAttrTypeL1.Q_WATER] = Math.floor(this.attr1[EAttrTypeL1.Q_WATER] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.Q_THUNDER) {//雷系狂暴
|
||
this.attr1[EAttrTypeL1.Q_THUNDER] = Math.floor(this.attr1[EAttrTypeL1.Q_THUNDER] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.WATER_EHAN) {//强水
|
||
this.attr1[EAttrTypeL1.WATER_EHAN] = Math.floor(this.attr1[EAttrTypeL1.WATER_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.FIRE_EHAN) {//强火
|
||
this.attr1[EAttrTypeL1.FIRE_EHAN] = Math.floor(this.attr1[EAttrTypeL1.FIRE_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.WIND_EHAN) {//强风
|
||
this.attr1[EAttrTypeL1.WIND_EHAN] = Math.floor(this.attr1[EAttrTypeL1.WIND_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.THUNDER_EHAN) {//强雷
|
||
this.attr1[EAttrTypeL1.THUNDER_EHAN] = Math.floor(this.attr1[EAttrTypeL1.THUNDER_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.CHAOS_EHAN) {//强雷
|
||
this.attr1[EAttrTypeL1.CHAOS_EHAN] = Math.floor(this.attr1[EAttrTypeL1.CHAOS_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.SEAL_EHAN) {//强雷
|
||
this.attr1[EAttrTypeL1.SEAL_EHAN] = Math.floor(this.attr1[EAttrTypeL1.SEAL_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.DEFEND_ADD_EHAN) {//强雷
|
||
this.attr1[EAttrTypeL1.DEFEND_ADD_EHAN] = Math.floor(this.attr1[EAttrTypeL1.DEFEND_ADD_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.SPD_ADD_EHAN) {//强雷
|
||
this.attr1[EAttrTypeL1.SPD_ADD_EHAN] = Math.floor(this.attr1[EAttrTypeL1.SPD_ADD_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.DETER_EHAN) {//强雷
|
||
this.attr1[EAttrTypeL1.DETER_EHAN] = Math.floor(this.attr1[EAttrTypeL1.DETER_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.SLEEP_EHAN) {//强雷
|
||
this.attr1[EAttrTypeL1.SLEEP_EHAN] = Math.floor(this.attr1[EAttrTypeL1.SLEEP_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.TOXIN_EHAN) {//强毒
|
||
this.attr1[EAttrTypeL1.TOXIN_EHAN] = Math.floor(this.attr1[EAttrTypeL1.TOXIN_EHAN] * (1 + ret.add / 100));
|
||
} else if (type == EAttrTypeL1.HK_POISON) {//忽视抗毒
|
||
this.attr1[EAttrTypeL1.HK_POISON] = Math.floor(this.attr1[EAttrTypeL1.HK_POISON] * (1 + ret.add / 100));
|
||
}
|
||
} else {
|
||
this.attr1[type] = this.attr1[type];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
checkOfudaBySkillId(skillid: any) {
|
||
let ofuda_map = Ofuda.shared.inUseOfudaByRoleid(this.roleid);
|
||
if (ofuda_map == null || ofuda_map == undefined || ofuda_map.size < 0) {
|
||
return false;
|
||
}
|
||
for (let [key, value] of ofuda_map) {
|
||
if (key == skillid) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 基础百分比气血等 属性放在 等级计算等级之后
|
||
calculateEquipBaseAttr() {
|
||
if (this.currentEquips) {
|
||
let list = [EAttrTypeL1.HP_ADD, EAttrTypeL1.MP_ADD, EAttrTypeL1.ATK_ADD, EAttrTypeL1.SPD_ADD, EAttrTypeL1.HP_PERC, EAttrTypeL1.MP_PERC, EAttrTypeL1.ATK_PERC, EAttrTypeL1.SPD_PERC]; //, EAttrTypeL1.AATK, EAttrTypeL1.ASPD
|
||
for (let equip of this.currentEquips) {
|
||
for (let key in EAttrTypeL1) {
|
||
let value = SKDataUtil.numberBy(key);
|
||
if (isNaN(value)) {
|
||
continue;
|
||
}
|
||
if (list.indexOf(value) == -1) {
|
||
continue;
|
||
}
|
||
let equipattr = equip.getAttr(value);
|
||
if (equipattr == null || equipattr == 0) {
|
||
continue;
|
||
}
|
||
let addattr = GameUtil.attrToBaseAttr[value];
|
||
if (addattr != null) {
|
||
let target_attr = addattr.target;
|
||
if (addattr.cal == EAttrCalType.ADD_PERCENT) {
|
||
this.attr1[target_attr] = Math.floor((1 + equipattr / 100) * this.attr1[target_attr]);
|
||
} else if (addattr.cal == EAttrCalType.PERCENT) {
|
||
this.attr1[target_attr] = Math.floor((1 + equipattr / 100) * this.attr1[target_attr]);
|
||
} else if (addattr.cal == EAttrCalType.ADD_NUM) {
|
||
this.attr1[target_attr] = Math.floor(this.attr1[target_attr] + equipattr);
|
||
}
|
||
} else {
|
||
this.attr1[value] = Math.floor(this.attr1[value] + equipattr);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let ofuda_map = Ofuda.shared.inUseOfudaByRoleid(this.roleid);
|
||
if (ofuda_map != null && ofuda_map != undefined && ofuda_map.size > 0) {
|
||
//载物符 - 通明 | 活血
|
||
for (let [key, value] of ofuda_map) {
|
||
if (key == ESkillType.TongMing1 || key == ESkillType.TongMing2 || key == ESkillType.TongMing3) {
|
||
let skill = SkillUtil.getSkill(key);
|
||
let addition = this.calcOfudaSkill(skill, value.addition);
|
||
this.attr1[EAttrTypeL1.MP] += Math.floor(this.attr1[EAttrTypeL1.MP_MAX] * (addition / 100));
|
||
}
|
||
if (key == ESkillType.HuoXue1 || key == ESkillType.HuoXue2 || key == ESkillType.HuoXue3) {
|
||
let skill = SkillUtil.getSkill(key);
|
||
let addition = this.calcOfudaSkill(skill, value.addition);
|
||
this.attr1[EAttrTypeL1.HP] += Math.floor(this.attr1[EAttrTypeL1.HP_MAX] * (addition / 100));
|
||
}
|
||
}
|
||
}
|
||
|
||
// if(this.attr1[EAttrTypeL1.MP] > this.attr1[EAttrTypeL1.MP_MAX]){
|
||
// this.attr1[EAttrTypeL1.MP] = this.attr1[EAttrTypeL1.MP_MAX]
|
||
// }
|
||
|
||
// if(this.attr1[EAttrTypeL1.HP] > this.attr1[EAttrTypeL1.HP_MAX]){
|
||
// this.attr1[EAttrTypeL1.HP] = this.attr1[EAttrTypeL1.HP_MAX]
|
||
// }
|
||
}
|
||
|
||
addXiulianPoint(data: any) {
|
||
if (!data) {
|
||
return;
|
||
}
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
// 重置修炼点
|
||
if (data.type == 0) {
|
||
let strErr = this.CostFee(GameUtil.goldKind.Money, 200000);
|
||
if (strErr != '') {
|
||
return;
|
||
}
|
||
this.resetXiulianPoint();
|
||
this.calculateAttr();
|
||
this.send('s2c_player_data', this.getData());
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
this.schemeMgr && this.schemeMgr.syncSchemePoint();
|
||
if (player) {
|
||
//cxf重置修炼点
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: player.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PLAYER,
|
||
operateDepict: "重置修炼点",
|
||
operateResSerial: player.roleid,
|
||
operateResName: player.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (data.type == 1) {
|
||
let sumpoint = 0;
|
||
let addpoint: any = {};
|
||
addpoint = SKDataUtil.jsonBy(data.info);
|
||
for (const key in addpoint) {
|
||
sumpoint += addpoint[key];
|
||
}
|
||
/*
|
||
let curpoint = 0;
|
||
for (const key in this.addattr1) {
|
||
curpoint += this.addattr1[key];
|
||
}
|
||
|
||
if (sumpoint + curpoint > this.xiulevel) {
|
||
return;
|
||
}
|
||
*/
|
||
|
||
if (sumpoint > this.xiulevel) {
|
||
return;
|
||
}
|
||
for (const key in addpoint) {
|
||
if (this.addattr1[key] == null) {
|
||
this.addattr1[key] = 0;
|
||
}
|
||
if (Number(key) == 1000) {
|
||
if (this.race == 1 && (this.addattr1[key] + addpoint[key] > 32)) {
|
||
this.send_notice(`上限为180点`);
|
||
return;
|
||
}
|
||
if ((this.race == 2 || this.race == 5) && (this.addattr1[key] + addpoint[key] > 20)) {
|
||
this.send_notice(`上限为150点`);
|
||
return;
|
||
}
|
||
if ((this.race == 3 || this.race == 4) && (this.addattr1[key] + addpoint[key] > 24)) {
|
||
this.send_notice(`上限为160点`);
|
||
return;
|
||
}
|
||
}
|
||
this.addattr1[key] += addpoint[key];
|
||
}
|
||
}
|
||
this.checkXiulianPoint();
|
||
this.calculateAttr();
|
||
if (player) {
|
||
//帮派修炼
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: player.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PLAYER,
|
||
operateDepict: "帮派修炼",
|
||
operateResSerial: player.roleid,
|
||
operateResName: player.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
this.send('s2c_player_data', this.getData());
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
}
|
||
|
||
resetRolePoint() {
|
||
//重置加点
|
||
this.addattr2[EAttrTypeL2.GENGU] = 0;
|
||
this.addattr2[EAttrTypeL2.LINGXING] = 0;
|
||
this.addattr2[EAttrTypeL2.MINJIE] = 0;
|
||
this.addattr2[EAttrTypeL2.LILIANG] = 0;
|
||
for (let equip of this.currentEquips) {
|
||
this.addEquipList(equip);
|
||
}
|
||
this.currentEquips = [];
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player) {
|
||
//cxf重置加点
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: player.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PLAYER,
|
||
operateDepict: "重置加点",
|
||
operateResSerial: player.roleid,
|
||
operateResName: player.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
this.changeWeapon(null);
|
||
}
|
||
|
||
resetXiulianPoint() {
|
||
for (const key in this.addattr1) {
|
||
this.addattr1[key] = 0;
|
||
}
|
||
}
|
||
|
||
xiulianUpgrade(data: any) {
|
||
let maxxiulian = RolePracticeMgr.shared.GetMaxPriactiveLevel(this.relive);
|
||
if (this.xiulevel < maxxiulian) {
|
||
if (this.bangscore >= data.score) {
|
||
this.bangscore -= data.score;
|
||
DB.updateMoney({ bind_jade: this.bind_jade, shiscore: this.shiscore, bangscore: this.bangscore, discore: this.discore, xiuscore: this.xiuscore, guoscore: this.guoscore, roleid: this.roleid });
|
||
this.xiulevel++;
|
||
this.send('s2c_player_data', this.getData());
|
||
this.send('s2c_notice', {
|
||
strRichText: '获得1个修炼点'
|
||
});
|
||
} else {
|
||
this.send_notice("帮贡不足");
|
||
return;
|
||
}
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player) {
|
||
//cxf帮派修炼等级
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.PLAYER,
|
||
operateDepict: "帮派修炼等级",
|
||
operateResSerial: this.bangid,
|
||
operateResName: this.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
this.schemeMgr && this.schemeMgr.syncSchemePoint();
|
||
} else {
|
||
this.send('s2c_notice', {
|
||
strRichText: '修炼点已达到上限'
|
||
});
|
||
}
|
||
}
|
||
|
||
|
||
getEquipAttr(attrtype: number): number {
|
||
let tmp = 0;
|
||
for (const equip of this.currentEquips) {
|
||
tmp += equip.getAttr(attrtype);
|
||
}
|
||
return tmp;
|
||
}
|
||
|
||
calculateLevel() {
|
||
let int = Math.floor;
|
||
let E = int((100 - this.level) / 5);
|
||
let L = this.level;
|
||
|
||
let Gs: any = GameUtil.growPre[this.race];
|
||
let P = this.getAttr1(EAttrTypeL2.GENGU); // + this.getEquipAttr(EAttrTypeL1.GENGU);
|
||
let G = Gs[EAttrTypeL2.GENGU];
|
||
let base = GameUtil.baseAttr[this.race][EAttrTypeL1.HP];
|
||
|
||
let Fs: any = this.getReliveFix();
|
||
|
||
let F: any = (Fs[EAttrTypeL1.HP] != null) ? Fs[EAttrTypeL1.HP] : 1;
|
||
let hp = int((int((L + E) * P * G + base) + this.getEquipAttr(EAttrTypeL1.HP_MAX)) * (1 + F / 100));
|
||
P = this.getAttr1(EAttrTypeL2.LINGXING); // + this.getEquipAttr(EAttrTypeL1.LINGXING);
|
||
G = Gs[EAttrTypeL2.LINGXING];
|
||
base = GameUtil.baseAttr[this.race][EAttrTypeL1.MP];
|
||
F = (Fs[EAttrTypeL1.MP] != null) ? Fs[EAttrTypeL1.MP] : 1;
|
||
let mp = int((int((L + E) * P * G + base) + this.getEquipAttr(EAttrTypeL1.MP_MAX)) * (1 + F / 100));
|
||
|
||
P = this.getAttr1(EAttrTypeL2.LILIANG); // + this.getEquipAttr(EAttrTypeL1.LILIANG);
|
||
G = Gs[EAttrTypeL2.LILIANG];
|
||
base = GameUtil.baseAttr[this.race][EAttrTypeL1.ATK];
|
||
F = (Fs[EAttrTypeL1.ATK] != null) ? Fs[EAttrTypeL1.ATK] : 1;
|
||
let atk = int((L + E) * P * G / 5 + base + this.getEquipAttr(EAttrTypeL1.ATK) * (1 + F / 100));
|
||
|
||
P = this.getAttr1(EAttrTypeL2.MINJIE); // + this.getEquipAttr(EAttrTypeL1.MINJIE);
|
||
G = Gs[EAttrTypeL2.MINJIE];
|
||
base = GameUtil.baseAttr[this.race][EAttrTypeL1.SPD];
|
||
F = (Fs[EAttrTypeL1.SPD] != null) ? Fs[EAttrTypeL1.SPD] : 1;
|
||
let spd = int((int((10 + P) * G) + this.getEquipAttr(EAttrTypeL1.SPD)) * (1 + F / 100))
|
||
|
||
|
||
this.attr1[EAttrTypeL1.HP] = hp;
|
||
this.attr1[EAttrTypeL1.HP_MAX] = hp;
|
||
this.attr1[EAttrTypeL1.MP] = mp;
|
||
this.attr1[EAttrTypeL1.MP_MAX] = mp;
|
||
this.attr1[EAttrTypeL1.ATK] = atk;
|
||
this.attr1[EAttrTypeL1.SPD] = spd;
|
||
|
||
this.calculateEquipBaseAttr();
|
||
|
||
this.hp = this.attr1[EAttrTypeL1.HP];
|
||
this.maxhp = this.attr1[EAttrTypeL1.HP];
|
||
this.mp = this.attr1[EAttrTypeL1.MP];
|
||
this.maxmp = this.attr1[EAttrTypeL1.MP];
|
||
this.atk = this.attr1[EAttrTypeL1.ATK];
|
||
this.spd = this.attr1[EAttrTypeL1.SPD];
|
||
this.attr1[EAttrTypeL1.HP_MAX] = this.attr1[EAttrTypeL1.HP];
|
||
this.attr1[EAttrTypeL1.MP_MAX] = this.attr1[EAttrTypeL1.MP];
|
||
|
||
if (this.race == ERaceType.HUMEN) {
|
||
// 抗混乱 封印 毒 昏睡 每4级 + 1
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] += 0 + int(L / 4);
|
||
this.attr1[EAttrTypeL1.K_SEAL] += 0 + int(L / 4);
|
||
this.attr1[EAttrTypeL1.K_SLEEP] += 0 + int(L / 4);
|
||
this.attr1[EAttrTypeL1.K_POISON] += 0 + int(L / 4);
|
||
} else if (this.race == ERaceType.SKY) {
|
||
this.attr1[EAttrTypeL1.K_WATER] += 0 + int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_FIRE] += 0 + int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_THUNDER] += 0 + int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_WIND] += 0 + int(L / 8);
|
||
} else if (this.race == ERaceType.DEMON) {
|
||
this.attr1[EAttrTypeL1.K_PHY_GET] += 0 + int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] += 0 + int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_SEAL] += 0 + int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_SLEEP] += 0 + int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_POISON] += 0 + int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_WATER] += 0 + int(L / 12);
|
||
this.attr1[EAttrTypeL1.K_FIRE] += 0 + int(L / 12);
|
||
this.attr1[EAttrTypeL1.K_THUNDER] += 0 + int(L / 12);
|
||
this.attr1[EAttrTypeL1.K_WIND] += 0 + int(L / 12);
|
||
} else if (this.race == ERaceType.GHOST) {
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] += 0 + int(L / 6);
|
||
this.attr1[EAttrTypeL1.K_SEAL] += 0 + int(L / 6);
|
||
this.attr1[EAttrTypeL1.K_SLEEP] += 0 + int(L / 6);
|
||
this.attr1[EAttrTypeL1.K_POISON] += 0 + int(L / 6);
|
||
this.attr1[EAttrTypeL1.K_FORGET] += 0 + int(L / 6);
|
||
this.attr1[EAttrTypeL1.K_WILDFIRE] += 0 + int(L / 6);
|
||
this.attr1[EAttrTypeL1.K_BLOODRETURN] += 0 + int(L / 6);
|
||
this.attr1[EAttrTypeL1.K_WATER] += 0 - int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_FIRE] += 0 - int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_THUNDER] += 0 - int(L / 8);
|
||
this.attr1[EAttrTypeL1.K_WIND] += 0 - int(L / 8);
|
||
this.attr1[EAttrTypeL1.PHY_HIT] += 0 + int(L / 4);
|
||
this.attr1[EAttrTypeL1.PHY_DODGE] += 0 + int(L / 4);
|
||
}
|
||
}
|
||
|
||
getReliveFix(): any {
|
||
let result: any = {};
|
||
let relivefixs: any[] = [GameUtil.reliveFixAttr1, GameUtil.reliveFixAttr2, GameUtil.reliveFixAttr3, GameUtil.reliveFixAttr4]
|
||
for (let index = 0; index < this.relive; index++) {
|
||
let rerace = this.relivelist[index][0];
|
||
let resex = this.relivelist[index][1];
|
||
let item: any = relivefixs[index][rerace];
|
||
if (item == null) {
|
||
continue;
|
||
}
|
||
let temp: any = item[resex];
|
||
for (const attr1 in temp) {
|
||
const num = temp[attr1];
|
||
if (result[attr1] == null) {
|
||
result[attr1] = 0;
|
||
}
|
||
result[attr1] += num;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
calculateReliveAttr() {
|
||
if (this.relive == 0) {
|
||
return;
|
||
}
|
||
let list = [EAttrTypeL1.HP, EAttrTypeL1.HP_MAX, EAttrTypeL1.MP, EAttrTypeL1.MP_MAX, EAttrTypeL1.ATK, EAttrTypeL1.SPD];
|
||
let fixed = this.getReliveFix();
|
||
for (let key in fixed) {
|
||
if (fixed.hasOwnProperty(key)) {
|
||
const addattr = fixed[key];
|
||
const id = parseInt(key);
|
||
if (list.indexOf(id) == -1) {
|
||
this.attr1[key] += addattr;
|
||
} else {
|
||
// this.attr1[key] = Math.ceil(this.attr1[key] * (1 + addattr / 100));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
calculateXiuAttr() {
|
||
let tempK_SLEEP: number = 0;
|
||
let tempK_SEAL: number = 0;
|
||
let tempK_CONFUSION: number = 0;
|
||
let tempK_FORGET: number = 0;
|
||
let temp_Max: number = 0;
|
||
this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] = 100 + (this.addattr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] == null ? 0 : this.addattr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] * 2.5);
|
||
this.attr1[EAttrTypeL1.K_SEAL] += (this.addattr1[EAttrTypeL1.K_SEAL] == null ? 0 : this.addattr1[EAttrTypeL1.K_SEAL] * 5);
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] += (this.addattr1[EAttrTypeL1.K_CONFUSION] == null ? 0 : this.addattr1[EAttrTypeL1.K_CONFUSION] * 5);
|
||
this.attr1[EAttrTypeL1.K_SLEEP] += (this.addattr1[EAttrTypeL1.K_SLEEP] == null ? 0 : this.addattr1[EAttrTypeL1.K_SLEEP] * 5);
|
||
this.attr1[EAttrTypeL1.K_FORGET] += (this.addattr1[EAttrTypeL1.K_FORGET] == null ? 0 : this.addattr1[EAttrTypeL1.K_FORGET] * 5);
|
||
tempK_SEAL = this.attr1[EAttrTypeL1.K_SEAL];
|
||
tempK_CONFUSION = this.attr1[EAttrTypeL1.K_CONFUSION];
|
||
tempK_SLEEP = this.attr1[EAttrTypeL1.K_SLEEP];
|
||
tempK_FORGET = this.attr1[EAttrTypeL1.K_FORGET];
|
||
SKLogger.warn("---------1111111111111111111---" + tempK_SEAL + "-抗封印-" + tempK_CONFUSION + "-抗混乱-" + tempK_SLEEP + "-抗昏睡--" + tempK_FORGET)
|
||
if (this.attr1[EAttrTypeL1.K_SEAL] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT]) {
|
||
this.attr1[EAttrTypeL1.K_SEAL] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT];
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_CONFUSION] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT]) {
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT];
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_SLEEP] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT]) {
|
||
this.attr1[EAttrTypeL1.K_SLEEP] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT];
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_FORGET] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT]) {
|
||
this.attr1[EAttrTypeL1.K_FORGET] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT];
|
||
}
|
||
/*
|
||
if(this.race == ERaceType.HUMEN){
|
||
if (this.attr1[EAttrTypeL1.K_SEAL] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN]) {
|
||
this.attr1[EAttrTypeL1.K_SEAL] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN];
|
||
}
|
||
}else if(this.race == ERaceType.DRAGON){
|
||
if (this.attr1[EAttrTypeL1.K_SEAL] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG]) {
|
||
this.attr1[EAttrTypeL1.K_SEAL] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG];
|
||
}
|
||
}else{
|
||
if (this.attr1[EAttrTypeL1.K_SEAL] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT]) {
|
||
this.attr1[EAttrTypeL1.K_SEAL] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT];
|
||
}
|
||
}
|
||
if(this.race == ERaceType.HUMEN){
|
||
if (this.attr1[EAttrTypeL1.K_CONFUSION] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN]) {
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN];
|
||
}
|
||
}else if(this.race == ERaceType.DRAGON){
|
||
if (this.attr1[EAttrTypeL1.K_CONFUSION] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG]) {
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG];
|
||
}
|
||
}else{
|
||
if (this.attr1[EAttrTypeL1.K_CONFUSION] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT]) {
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT];
|
||
}
|
||
}
|
||
if(this.race == ERaceType.HUMEN){
|
||
if (this.attr1[EAttrTypeL1.K_SLEEP] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN]) {
|
||
this.attr1[EAttrTypeL1.K_SLEEP] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN];
|
||
}
|
||
}else if(this.race == ERaceType.DRAGON){
|
||
if (this.attr1[EAttrTypeL1.K_SLEEP] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG]) {
|
||
this.attr1[EAttrTypeL1.K_SLEEP] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG];
|
||
}
|
||
}else{
|
||
if (this.attr1[EAttrTypeL1.K_SLEEP] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT]) {
|
||
this.attr1[EAttrTypeL1.K_SLEEP] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT];
|
||
}
|
||
}
|
||
if(this.race == ERaceType.HUMEN){
|
||
if (this.attr1[EAttrTypeL1.K_FORGET] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN]) {
|
||
this.attr1[EAttrTypeL1.K_FORGET] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN];
|
||
}
|
||
}else if(this.race == ERaceType.DRAGON){
|
||
if (this.attr1[EAttrTypeL1.K_FORGET] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG]) {
|
||
this.attr1[EAttrTypeL1.K_FORGET] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG];
|
||
}
|
||
}else{
|
||
if (this.attr1[EAttrTypeL1.K_FORGET] > this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT]) {
|
||
this.attr1[EAttrTypeL1.K_FORGET] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT];
|
||
}
|
||
}
|
||
*/
|
||
if (this.race == ERaceType.HUMEN) {
|
||
if (this.attr1[EAttrTypeL1.K_FORGET] > 180) {
|
||
this.attr1[EAttrTypeL1.K_FORGET] = 180;
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_SLEEP] > 180) {
|
||
this.attr1[EAttrTypeL1.K_SLEEP] = 180;
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_CONFUSION] > 180) {
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] = 180;
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_SEAL] > 180) {
|
||
this.attr1[EAttrTypeL1.K_SEAL] = 180
|
||
}
|
||
temp_Max = 180;
|
||
} else if (this.race == ERaceType.DRAGON || this.race == ERaceType.SKY) {
|
||
if (this.attr1[EAttrTypeL1.K_FORGET] > 150) {
|
||
this.attr1[EAttrTypeL1.K_FORGET] = 150;
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_SLEEP] > 150) {
|
||
this.attr1[EAttrTypeL1.K_SLEEP] = 150;
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_CONFUSION] > 150) {
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] = 150;
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_SEAL] > 150) {
|
||
this.attr1[EAttrTypeL1.K_SEAL] = 150
|
||
}
|
||
temp_Max = 150;
|
||
} else {
|
||
if (this.attr1[EAttrTypeL1.K_FORGET] > 160) {
|
||
this.attr1[EAttrTypeL1.K_FORGET] = 160;
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_SLEEP] > 160) {
|
||
this.attr1[EAttrTypeL1.K_SLEEP] = 160;
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_CONFUSION] > 160) {
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] = 160;
|
||
}
|
||
if (this.attr1[EAttrTypeL1.K_SEAL] > 160) {
|
||
this.attr1[EAttrTypeL1.K_SEAL] = 160
|
||
}
|
||
temp_Max = 160;
|
||
}
|
||
|
||
let ofuda_map = Ofuda.shared.inUseOfudaByRoleid(this.roleid);
|
||
if (ofuda_map != null && ofuda_map != undefined && ofuda_map.size > 0) {
|
||
//载物符 - 明镜 | 清明 | 沉着 | 强心
|
||
for (let [key, value] of ofuda_map) {
|
||
if (key == ESkillType.MingJing1 || key == ESkillType.MingJing2 || key == ESkillType.MingJing3) {
|
||
let skill = SkillUtil.getSkill(key);
|
||
let addition = this.calcOfudaSkill(skill, value.addition);
|
||
// if(this.race == ERaceType.HUMEN){
|
||
// if (tempK_SEAL > (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN] + addition)) {
|
||
// this.attr1[EAttrTypeL1.K_SEAL] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN] + addition;
|
||
// }
|
||
// }else if(this.race == ERaceType.DRAGON){
|
||
// if (tempK_SEAL > (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG] + addition)) {
|
||
// this.attr1[EAttrTypeL1.K_SEAL] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG] + addition;
|
||
// }
|
||
// }else{
|
||
if (tempK_SEAL >= (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] + addition)) {
|
||
this.attr1[EAttrTypeL1.K_SEAL] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] + addition;
|
||
} else if (tempK_SEAL >= temp_Max) {
|
||
this.attr1[EAttrTypeL1.K_SEAL] = tempK_SEAL;
|
||
}
|
||
//}
|
||
}
|
||
if (key == ESkillType.QingMing1 || key == ESkillType.QingMing2 || key == ESkillType.QingMing3) {
|
||
let skill = SkillUtil.getSkill(key);
|
||
let addition = this.calcOfudaSkill(skill, value.addition);
|
||
// if(this.race == ERaceType.HUMEN){
|
||
// if (tempK_CONFUSION > (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN] + addition)) {
|
||
// this.attr1[EAttrTypeL1.K_CONFUSION] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN] + addition;
|
||
// }
|
||
// }else if(this.race == ERaceType.DRAGON){
|
||
// if (tempK_CONFUSION > (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG] + addition)) {
|
||
// this.attr1[EAttrTypeL1.K_CONFUSION] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG] + addition;
|
||
// }
|
||
// }else{
|
||
if (tempK_CONFUSION >= (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] + addition)) {
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] + addition;
|
||
} else if (tempK_CONFUSION >= temp_Max) {
|
||
this.attr1[EAttrTypeL1.K_CONFUSION] = tempK_CONFUSION;
|
||
}
|
||
//}
|
||
|
||
}
|
||
if (key == ESkillType.ChenZhuo1 || key == ESkillType.ChenZhuo2 || key == ESkillType.ChenZhuo3) {
|
||
let skill = SkillUtil.getSkill(key);
|
||
let addition = this.calcOfudaSkill(skill, value.addition);
|
||
// if(this.race == ERaceType.HUMEN){
|
||
// if (tempK_SLEEP > (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN] + addition)) {
|
||
// this.attr1[EAttrTypeL1.K_SLEEP] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN] + addition;
|
||
// }
|
||
// }else if(this.race == ERaceType.DRAGON){
|
||
// if (tempK_SLEEP > (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG] + addition)) {
|
||
// this.attr1[EAttrTypeL1.K_SLEEP] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG] + addition;
|
||
// }
|
||
// }else{
|
||
if (tempK_SLEEP >= (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] + addition)) {
|
||
this.attr1[EAttrTypeL1.K_SLEEP] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] + addition;
|
||
} else if (tempK_SLEEP >= temp_Max) {
|
||
this.attr1[EAttrTypeL1.K_SLEEP] = tempK_SLEEP;
|
||
}
|
||
//}
|
||
}
|
||
if (key == ESkillType.QiangXin1 || key == ESkillType.QiangXin2 || key == ESkillType.QiangXin3) {
|
||
let skill = SkillUtil.getSkill(key);
|
||
let addition = this.calcOfudaSkill(skill, value.addition);
|
||
// if(this.race == ERaceType.HUMEN){
|
||
// if (tempK_FORGET > (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN] + addition)) {
|
||
// this.attr1[EAttrTypeL1.K_FORGET] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_REN] + addition;
|
||
// }
|
||
// }else if(this.race == ERaceType.DRAGON){
|
||
// if (tempK_FORGET > (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG] + addition)) {
|
||
// this.attr1[EAttrTypeL1.K_FORGET] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_LIMIT_LONG] + addition;
|
||
// }
|
||
// }else{
|
||
if (tempK_FORGET >= (this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] + addition)) {
|
||
this.attr1[EAttrTypeL1.K_FORGET] = this.attr1[EAttrTypeL1.K_SEAL_CONFUSION_SLEEP_FORGET_LIMIT] + addition;
|
||
} else if (tempK_FORGET >= temp_Max) {
|
||
this.attr1[EAttrTypeL1.K_FORGET] = tempK_FORGET;
|
||
}
|
||
//}
|
||
}
|
||
}
|
||
}
|
||
SKLogger.warn("---------2222222---" + this.attr1[EAttrTypeL1.K_SEAL] + "-抗封印-" + this.attr1[EAttrTypeL1.K_CONFUSION] + "-抗混乱-" + this.attr1[EAttrTypeL1.K_SLEEP] + "-抗昏睡--" + this.attr1[EAttrTypeL1.K_FORGET])
|
||
this.attr1[EAttrTypeL1.K_WIND] += (this.addattr1[EAttrTypeL1.K_WIND] == null ? 0 : this.addattr1[EAttrTypeL1.K_WIND] * 5);
|
||
this.attr1[EAttrTypeL1.K_THUNDER] += (this.addattr1[EAttrTypeL1.K_THUNDER] == null ? 0 : this.addattr1[EAttrTypeL1.K_THUNDER] * 5);
|
||
this.attr1[EAttrTypeL1.K_WATER] += (this.addattr1[EAttrTypeL1.K_WATER] == null ? 0 : this.addattr1[EAttrTypeL1.K_WATER] * 5);
|
||
this.attr1[EAttrTypeL1.K_FIRE] += (this.addattr1[EAttrTypeL1.K_FIRE] == null ? 0 : this.addattr1[EAttrTypeL1.K_FIRE] * 5);
|
||
|
||
this.attr1[EAttrTypeL1.K_WILDFIRE] += (this.addattr1[EAttrTypeL1.K_WILDFIRE] == null ? 0 : this.addattr1[EAttrTypeL1.K_WILDFIRE] * 5);
|
||
this.attr1[EAttrTypeL1.K_BLOODRETURN] += (this.addattr1[EAttrTypeL1.K_BLOODRETURN] == null ? 0 : this.addattr1[EAttrTypeL1.K_BLOODRETURN] * 5);
|
||
this.attr1[EAttrTypeL1.K_POISON] += (this.addattr1[EAttrTypeL1.K_POISON] == null ? 0 : this.addattr1[EAttrTypeL1.K_POISON] * 5);
|
||
this.attr1[EAttrTypeL1.PHY_GET] += (this.addattr1[EAttrTypeL1.PHY_GET] == null ? 0 : this.addattr1[EAttrTypeL1.PHY_GET] * 4);
|
||
}
|
||
// 是否为机器人
|
||
isRobot(): boolean {
|
||
if (this.ai) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
// 全部存档
|
||
saveAll(callback: (failed: string[]) => void) {
|
||
if (this.roleid != undefined && this.resid != undefined) {
|
||
let prefix: string = `${this.isRobot() ? `机器人` : `玩家`}`;
|
||
if (this.saveTotal > 0) {
|
||
SKLogger.warn(`${prefix}[${this.roleid}:${this.name}]正在存档中,当前存档:${this.saveTotal}`);
|
||
return;
|
||
}
|
||
if (!this.loaded) {
|
||
SKLogger.warn(`${prefix}[${this.roleid}:${this.name}]没有加载完成稍后存档`);
|
||
callback([]);
|
||
return;
|
||
}
|
||
if (this.ai_flag != 1) {
|
||
this.saveTotal = 5; // 检查是否存档完成 套装,召唤兽,坐骑列表,坐骑技能,玩家
|
||
this.saveFailed = [];
|
||
let equipSQL = '';
|
||
for (const equip of this.currentEquips) {
|
||
equipSQL += equip.saveSQL();
|
||
}
|
||
for (const equip of this.listEquips) {
|
||
equipSQL += equip.saveSQL();
|
||
}
|
||
for (let equip of this.lockerEquips) {
|
||
equipSQL += equip.saveSQL();
|
||
}
|
||
if (this.mapid == 3002) {
|
||
this.mapid = 1011;
|
||
this.x = 237;
|
||
this.y = 19;
|
||
}
|
||
if (this.mapid == 1201 && !this.inPrison) {
|
||
this.mapid = 1011;
|
||
this.x = 112;
|
||
this.y = 78;
|
||
}
|
||
let titles = SKDataUtil.toJson({
|
||
onload: this.onLoad,
|
||
titles: this.titles,
|
||
}, "{}");
|
||
let partnerList: string = "";
|
||
if (this.partnerMgr) {
|
||
partnerList = this.partnerMgr.toJson();
|
||
}
|
||
let color = { c1: this.color1, c2: this.color2, p1: this.color_one_serial, p2: this.color_two_serial };
|
||
let friendlist = SKDataUtil.clone(this.friendList);
|
||
for (let roleid in friendlist) {
|
||
if (friendlist.hasOwnProperty(roleid)) {
|
||
if (roleid == 'version') {
|
||
continue;
|
||
}
|
||
let finfo = friendlist[roleid];
|
||
finfo.name = Buffer.from(finfo.name).toString('base64');
|
||
}
|
||
}
|
||
friendlist.version = 1;
|
||
let dbinfo = {
|
||
accountid: this.accountid,
|
||
name: this.name,
|
||
mapid: this.mapid,
|
||
x: this.x,
|
||
y: this.y,
|
||
addpoint: this.addattr2,
|
||
xiupoint: this.addattr1,
|
||
xiulevel: this.xiulevel,
|
||
pet: this.curPetId,
|
||
friendlist: friendlist,
|
||
equipinfo: equipSQL,
|
||
bagitem: this.bag_list,
|
||
bangid: this.bangid,
|
||
taskstate: this.taskStateToJson(),
|
||
partnerlist: partnerList,
|
||
lockeritem: this.locker_list,
|
||
skill: this.skill_list,
|
||
money: this.money,
|
||
jade: this.jade,
|
||
bind_jade: this.bind_jade,
|
||
bang_score: this.bangscore,
|
||
shi_score: this.shiscore,
|
||
di_score: this.discore,
|
||
xiu_score: this.xiuscore,
|
||
guo_score: this.guoscore,
|
||
exp: this.exp,
|
||
level: this.level,
|
||
level_reward: this.level_reward,
|
||
resid: this.resid,
|
||
race: this.race,
|
||
sex: this.sex,
|
||
relive: this.relive,
|
||
relivelist: this.relivelist,
|
||
shane: this.shane,
|
||
state: this.nFlag,
|
||
rewardrecord: this.rewardrecord,
|
||
sprewardrecord: this.sprewardrecord,
|
||
getgift: this.getgift,
|
||
shuilu: this.shuilu,
|
||
arena: this.arena,
|
||
titles: titles,
|
||
active_scheme_name: this.schemeName,
|
||
color: color,
|
||
star: this.star,
|
||
horse_index: this.horseList.horseIndex,
|
||
day_count: this.dayMap,
|
||
bagKindNum: this.bagKindNum,
|
||
mend_date: this.mend_date,
|
||
sat_integral: this.sat_integral,
|
||
offlinetime: this.offlinetime,
|
||
doublecnt: this.doublecnt,
|
||
unget_doublecnt: this.unget_doublecnt,
|
||
zhenfa: this.ZFMgr.toJson(),
|
||
xw: this.XWMgr.getXwListByJson(),
|
||
baby: this.BabyMgr.ToJson(),
|
||
star_info: this.StarMgr.ToJson(),
|
||
tianti_integral: this.tianti_integral,
|
||
};
|
||
let self = this;
|
||
DB.savePlayerInfo(this.roleid, dbinfo, (code: number, msg: string) => {
|
||
let info = `存档:${prefix}[${this.roleid}:${this.name}]角色存档`;
|
||
if (code == MsgCode.SUCCESS) {
|
||
info += `成功!`;
|
||
SKLogger.debug(info);
|
||
} else {
|
||
info += `失败:[${msg}]!`;
|
||
SKLogger.warn(info);
|
||
}
|
||
self.checkSave(code, info, callback, "玩家信息");
|
||
});
|
||
// 保存套装
|
||
if (this.schemeMgr) {
|
||
this.schemeMgr.saveDB((code: number, msg: string) => {
|
||
this.checkSave(code, msg, callback, "套装");
|
||
});
|
||
} else {
|
||
let msg = `存档:${prefix}[${this.roleid}:${this.name}]套装无需存档!`;
|
||
this.checkSave(MsgCode.SUCCESS, msg, callback, "套装");
|
||
}
|
||
// 保存召唤兽
|
||
DB.savePets(this.petList, this.roleid, (code: number, msg: string) => {
|
||
let info = `存档:${prefix}[${this.roleid}:${this.name}]召唤兽存档`;
|
||
if (code == MsgCode.SUCCESS) {
|
||
info += `成功!`;
|
||
SKLogger.debug(info);
|
||
} else {
|
||
info += `失败[${msg}]!`;
|
||
SKLogger.warn(info);
|
||
}
|
||
this.checkSave(code, msg, callback, "召唤兽");
|
||
});
|
||
this.horseList.saveDB((code: number, msg: string) => {
|
||
let info = `存档:${prefix}[${this.roleid}:${this.name}]坐骑列表存档`;
|
||
if (code == MsgCode.SUCCESS) {
|
||
info += `成功!`;
|
||
SKLogger.debug(info);
|
||
} else {
|
||
info += `失败[${msg}]!`;
|
||
SKLogger.warn(info);
|
||
}
|
||
this.checkSave(code, info, callback, "坐骑");
|
||
});
|
||
this.horseSkill.saveDB((code: number, msg: string) => {
|
||
let info = `存档:${prefix}[${this.roleid}:${this.name}]坐骑技能存档`;
|
||
if (code == MsgCode.SUCCESS) {
|
||
info += `成功!`;
|
||
SKLogger.debug(info);
|
||
} else {
|
||
info += `失败[${msg}]!`;
|
||
SKLogger.warn(info);
|
||
}
|
||
this.checkSave(code, info, callback, "坐骑技能");
|
||
});
|
||
//天策符的使用状态
|
||
let ofudaList = Ofuda.shared.getOfListByRoid(this.roleid);
|
||
if (ofudaList.length > 0) {
|
||
DB.insertOfuda(this.roleid, SKDataUtil.toJson(ofudaList, "{}"));
|
||
}
|
||
} else {
|
||
let dbinfo = {
|
||
accountid: this.accountid,
|
||
name: this.name,
|
||
mapid: this.mapid,
|
||
x: this.x,
|
||
y: this.y,
|
||
addpoint: this.addattr2,
|
||
xiupoint: this.addattr1,
|
||
xiulevel: this.xiulevel,
|
||
pet: this.curPetId,
|
||
bagitem: this.bag_list,
|
||
bangid: this.bangid,
|
||
taskstate: this.taskStateToJson(),
|
||
lockeritem: this.locker_list,
|
||
skill: this.skill_list,
|
||
money: this.money,
|
||
jade: this.jade,
|
||
bind_jade: this.bind_jade,
|
||
bang_score: this.bangscore,
|
||
shi_score: this.shiscore,
|
||
di_score: this.discore,
|
||
xiu_score: this.xiuscore,
|
||
guo_score: this.guoscore,
|
||
exp: this.exp,
|
||
level: this.level,
|
||
level_reward: this.level_reward,
|
||
resid: this.resid,
|
||
race: this.race,
|
||
sex: this.sex,
|
||
relive: this.relive,
|
||
relivelist: this.relivelist,
|
||
shane: this.shane,
|
||
state: this.nFlag,
|
||
rewardrecord: this.rewardrecord,
|
||
sprewardrecord: this.sprewardrecord,
|
||
getgift: this.getgift,
|
||
shuilu: this.shuilu,
|
||
arena: this.arena,
|
||
active_scheme_name: this.schemeName,
|
||
star: this.star,
|
||
horse_index: this.horseList.horseIndex,
|
||
day_count: this.dayMap,
|
||
bagKindNum: this.bagKindNum,
|
||
mend_date: this.mend_date,
|
||
sat_integral: this.sat_integral,
|
||
al_flag: this.ai_flag
|
||
};
|
||
DB.savePlayerInfoRobot(this.roleid, dbinfo, (code: number, msg: string) => {
|
||
let info = `机器人存档:[${this.roleid}:${this.name}]角色存档`;
|
||
if (code == MsgCode.SUCCESS) {
|
||
info += `成功!`;
|
||
SKLogger.info(info);
|
||
callback([]);
|
||
} else {
|
||
info += `失败:[${msg}]!`;
|
||
SKLogger.warn(info);
|
||
callback([]);
|
||
}
|
||
|
||
});
|
||
}
|
||
|
||
} else {
|
||
SKLogger.warn("玩家信息错误/机器人不进行存档");
|
||
callback([]);
|
||
}
|
||
}
|
||
// 保存角色签到数据
|
||
saveSignIn() {
|
||
DB.saveSignIn(SKDataUtil.toJson(this.daySignIn, "{}"), this.roleid, this.mendDate, (code: number, msg: string) => {
|
||
let info = `存档:[${this.roleid}:${this.name}]签到数据存档`;
|
||
if (code == MsgCode.SUCCESS) {
|
||
info += `成功!`;
|
||
SKLogger.info(info);
|
||
} else {
|
||
info += `失败[${msg}]!`;
|
||
SKLogger.info(info);
|
||
}
|
||
});
|
||
}
|
||
|
||
// 备用存档
|
||
saveAllReserve() {
|
||
if (this.roleid != undefined && this.resid != undefined) {
|
||
let equipSQL = '';
|
||
for (const equip of this.currentEquips) {
|
||
equipSQL += equip.saveSQL();
|
||
}
|
||
for (const equip of this.listEquips) {
|
||
equipSQL += equip.saveSQL();
|
||
}
|
||
for (let equip of this.lockerEquips) {
|
||
equipSQL += equip.saveSQL();
|
||
}
|
||
if (this.mapid == 3002) {
|
||
this.mapid = 1011;
|
||
this.x = 237;
|
||
this.y = 19;
|
||
}
|
||
if (this.mapid == 1201 && !this.inPrison) {
|
||
this.mapid = 1011;
|
||
this.x = 112;
|
||
this.y = 78;
|
||
}
|
||
let titles = SKDataUtil.toJson({
|
||
onload: this.onLoad,
|
||
titles: this.titles,
|
||
}, "{}");
|
||
let partnerList: string = "";
|
||
if (this.partnerMgr) {
|
||
partnerList = this.partnerMgr.toJson();
|
||
}
|
||
let color = { c1: this.color1, c2: this.color2, p1: this.color_one_serial, p2: this.color_two_serial };
|
||
let friendlist = SKDataUtil.clone(this.friendList);
|
||
for (let roleid in friendlist) {
|
||
if (friendlist.hasOwnProperty(roleid)) {
|
||
if (roleid == 'version') {
|
||
continue;
|
||
}
|
||
let finfo = friendlist[roleid];
|
||
finfo.name = Buffer.from(finfo.name).toString('base64');
|
||
}
|
||
}
|
||
friendlist.version = 1;
|
||
let dbinfo = {
|
||
accountid: this.accountid,
|
||
name: this.name,
|
||
mapid: this.mapid,
|
||
x: this.x,
|
||
y: this.y,
|
||
addpoint: this.addattr2,
|
||
xiupoint: this.addattr1,
|
||
xiulevel: this.xiulevel,
|
||
pet: this.curPetId,
|
||
friendlist: friendlist,
|
||
equipinfo: equipSQL,
|
||
bagitem: this.bag_list,
|
||
bangid: this.bangid,
|
||
taskstate: this.taskStateToJson(),
|
||
partnerlist: partnerList,
|
||
lockeritem: this.locker_list,
|
||
skill: this.skill_list,
|
||
money: this.money,
|
||
jade: this.jade,
|
||
bind_jade: this.bind_jade,
|
||
bang_score: this.bangscore,
|
||
shi_score: this.shiscore,
|
||
di_score: this.discore,
|
||
xiu_score: this.xiuscore,
|
||
guo_score: this.guoscore,
|
||
exp: this.exp,
|
||
level: this.level,
|
||
level_reward: this.level_reward,
|
||
resid: this.resid,
|
||
race: this.race,
|
||
sex: this.sex,
|
||
relive: this.relive,
|
||
relivelist: this.relivelist,
|
||
shane: this.shane,
|
||
state: this.nFlag,
|
||
rewardrecord: this.rewardrecord,
|
||
sprewardrecord: this.sprewardrecord,
|
||
getgift: this.getgift,
|
||
shuilu: this.shuilu,
|
||
arena: this.arena,
|
||
titles: titles,
|
||
active_scheme_name: this.schemeName,
|
||
color: color,
|
||
star: this.star,
|
||
horse_index: this.horseList.horseIndex,
|
||
day_count: this.dayMap,
|
||
bagKindNum: this.bagKindNum,
|
||
mend_date: this.mend_date,
|
||
sat_integral: this.sat_integral,
|
||
zhenfa: this.ZFMgr.toJson(),
|
||
xw: this.XWMgr.getXwListByJson(),
|
||
baby: this.BabyMgr.ToJson(),
|
||
star_info: this.StarMgr.ToJson(),
|
||
tianti_integral: this.tianti_integral,
|
||
};
|
||
DB.savePlayerInfo(this.roleid, dbinfo, (code: number, msg: string) => {
|
||
let info = `备用存档:[${this.roleid}:${this.name}]角色存档`;
|
||
if (code == MsgCode.SUCCESS) {
|
||
info += `成功!`;
|
||
SKLogger.info(info);
|
||
} else {
|
||
info += `失败:[${msg}]!`;
|
||
SKLogger.warn(info);
|
||
}
|
||
|
||
});
|
||
} else {
|
||
SKLogger.warn("备用玩家信息错误不进行存档");
|
||
}
|
||
}
|
||
|
||
// 保存角色风雨转盘数据
|
||
saveDial() {
|
||
DB.saveDial(this.roleid, this.dial_num, this.dial_count, this.dial_date, (code: number, msg: string) => {
|
||
let info = `存档:[${this.roleid}:${this.name}]风雨转盘数据存档`;
|
||
if (code == MsgCode.SUCCESS) {
|
||
info += `成功!`;
|
||
SKLogger.info(info);
|
||
} else {
|
||
info += `失败[${msg}]!`;
|
||
SKLogger.info(info);
|
||
}
|
||
});
|
||
}
|
||
|
||
// 通过CXF通讯存档
|
||
cxfSavePlayerAll() {
|
||
if (this.roleid != undefined && this.resid != undefined) {
|
||
let prefix: string = `${this.isRobot() ? `机器人` : `玩家`}`;
|
||
|
||
if (!this.loaded) {
|
||
SKLogger.warn(`${prefix}[${this.roleid}:${this.name}]没有加载完成稍后存档`);
|
||
return;
|
||
}
|
||
|
||
this.saveFailed = [];
|
||
// --------------------------------------------------- 装备存档 ----------------------------------------------------------
|
||
for (const equip of this.currentEquips) {
|
||
SKCxfUtil.getCxfSaveEquip(equip.cxfEquip(this.roleid));
|
||
}
|
||
for (const equip of this.listEquips) {
|
||
SKCxfUtil.getCxfSaveEquip(equip.cxfEquip(this.roleid));
|
||
}
|
||
for (let equip of this.lockerEquips) {
|
||
SKCxfUtil.getCxfSaveEquip(equip.cxfEquip(this.roleid));
|
||
}
|
||
// --------------------------------------------------- 玩家存档 ----------------------------------------------------------
|
||
if (this.mapid == 3002) {
|
||
this.mapid = 1011;
|
||
this.x = 237;
|
||
this.y = 19;
|
||
}
|
||
if (this.mapid == 1201 && !this.inPrison) {
|
||
this.mapid = 1011;
|
||
this.x = 112;
|
||
this.y = 78;
|
||
}
|
||
let titles = SKDataUtil.toJson({
|
||
onload: this.onLoad,
|
||
titles: this.titles,
|
||
}, "{}");
|
||
let partnerList: string = "";
|
||
if (this.partnerMgr) {
|
||
partnerList = this.partnerMgr.toJson();
|
||
}
|
||
let color = { c1: this.color1, c2: this.color2, p1: this.color_one_serial, p2: this.color_two_serial };
|
||
let friendlist = SKDataUtil.clone(this.friendList);
|
||
for (let roleid in friendlist) {
|
||
if (friendlist.hasOwnProperty(roleid)) {
|
||
if (roleid == 'version') {
|
||
continue;
|
||
}
|
||
let finfo = friendlist[roleid];
|
||
finfo.name = Buffer.from(finfo.name).toString('base64');
|
||
}
|
||
}
|
||
friendlist.version = 1;
|
||
let dbinfo = {
|
||
roleid: this.roleid,
|
||
accountid: this.accountid,
|
||
serverid: GameUtil.serverId,
|
||
name: this.name,
|
||
resid: this.resid,
|
||
race: this.race,
|
||
sex: this.sex,
|
||
relive: this.relive,
|
||
relivelist: SKDataUtil.toJson(this.relivelist, "[]"),
|
||
level: this.level,
|
||
level_reward: this.level_reward,
|
||
exp: this.exp,
|
||
money: this.money,
|
||
jade: this.jade,
|
||
bind_jade: this.bind_jade,
|
||
bang_score: this.bangscore,
|
||
shi_score: this.shiscore,
|
||
di_score: this.discore,
|
||
xiu_score: this.xiuscore,
|
||
guo_score: this.guoscore,
|
||
mapid: this.mapid,
|
||
x: this.x,
|
||
y: this.y,
|
||
bangid: this.bangid,
|
||
color: SKDataUtil.toJson(color, "{}"),
|
||
star: this.star,
|
||
shane: this.shane,
|
||
addpoint: SKDataUtil.toJson(this.addattr2, "{}"),
|
||
xiupoint: SKDataUtil.toJson(this.addattr1, "{}"),
|
||
xiulevel: this.xiulevel,
|
||
skill: SKDataUtil.toJson(this.skill_list, "{}"),
|
||
bagitem: SKDataUtil.toJson(this.bag_list, "{}"),
|
||
lockeritem: SKDataUtil.toJson(this.locker_list, "{}"),
|
||
pet: this.curPetId,
|
||
friendlist: SKDataUtil.toJson(friendlist, "{}"),
|
||
taskstate: SKDataUtil.toJson(this.taskStateToJson(), "{}"),
|
||
partnerlist: SKDataUtil.toJson(partnerList, "{}"),
|
||
state: this.nFlag,
|
||
rewardrecord: this.rewardrecord,
|
||
sprewardrecord: this.sprewardrecord,
|
||
getgift: this.getgift,
|
||
shuilu: SKDataUtil.toJson(this.shuilu, "{}"),
|
||
arena: SKDataUtil.toJson(this.arena, "{}"),
|
||
titles: titles,
|
||
activeSchemeName: this.schemeName,
|
||
horseIndex: this.horseList.horseIndex,
|
||
dayCount: SKDataUtil.toJson(this.dayMap, "{}"),
|
||
bagKindNum: this.bagKindNum,
|
||
mendDate: this.mend_date,
|
||
satIntegral: this.sat_integral,
|
||
tianti_integral: this.tianti_integral,
|
||
};
|
||
// 玩家信息存档
|
||
SKCxfUtil.getCxfSaveGamer(dbinfo);
|
||
// --------------------------------------------------- 套装存档 ----------------------------------------------------------
|
||
// 保存套装
|
||
if (this.schemeMgr) {
|
||
let schemeList: any = this.schemeMgr.schemeList;
|
||
for (let key in schemeList) {
|
||
let scheme = schemeList[key];
|
||
SKCxfUtil.getCxfSaveScheme(scheme.toObj());
|
||
}
|
||
}
|
||
// -------------------------------------------------- 召唤兽存档 ---------------------------------------------------------
|
||
for (let pet of this.petList) {
|
||
SKCxfUtil.getCxfSavePet(pet.toSaveObj())
|
||
}
|
||
// ------------------------------------------------- 坐骑列表存档 --------------------------------------------------------
|
||
for (let position in this.horseList.dict) {
|
||
let horse = this.horseList.dict[position];
|
||
if (horse) {
|
||
let horseObj: any = {};
|
||
horseObj.roleId = this.roleid;
|
||
horseObj.exp = horse.exp;
|
||
horseObj.name = horse.name;
|
||
horseObj.level = horse.level;
|
||
horseObj.position = horse.position;
|
||
SKCxfUtil.getCxfSaveHorse(horseObj);
|
||
}
|
||
}
|
||
// ------------------------------------------------- 坐骑技能存档 --------------------------------------------------------
|
||
for (let position in this.horseSkill.dict) {
|
||
let skill: any = this.horseSkill.dict[position];
|
||
if (skill) {
|
||
let horseSkillObj: any = {};
|
||
horseSkillObj.skillId = skill.skill_id;
|
||
horseSkillObj.exp = skill.exp;
|
||
horseSkillObj.position = position;
|
||
horseSkillObj.roleId = this.roleid;
|
||
SKCxfUtil.getCxfSaveHorseSkill(horseSkillObj);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 检查存档
|
||
checkSave(code: MsgCode, msg: string, callback: (failed: string[]) => void, content: string) {
|
||
if (code != MsgCode.SUCCESS) {
|
||
this.saveFailed.push(msg);
|
||
}
|
||
SKLogger.debug(msg);
|
||
this.saveTotal--;
|
||
// SKLogger.info(`**存档:[${this.roleid}:${this.name}]存档进度${this.saveTotal}/5,当前内容：${content}`);
|
||
if (this.saveTotal > 0) {
|
||
return;
|
||
}
|
||
// SKLogger.info(`[${this.roleid}:${this.name}]完成存档${this.saveTotal}`);
|
||
callback(this.saveFailed);
|
||
}
|
||
|
||
redisSave() {
|
||
let equipSQL = '';
|
||
for (const equip of this.currentEquips) {
|
||
equipSQL += equip.saveSQL();
|
||
}
|
||
for (const equip of this.listEquips) {
|
||
equipSQL += equip.saveSQL();
|
||
}
|
||
for (let equip of this.lockerEquips) {
|
||
equipSQL += equip.saveSQL();
|
||
}
|
||
if (this.mapid == 3002) {
|
||
this.mapid = 1011;
|
||
this.x = 237;
|
||
this.y = 19;
|
||
}
|
||
if (this.mapid == 1201 && !this.inPrison) {
|
||
this.mapid = 1011;
|
||
this.x = 112;
|
||
this.y = 78;
|
||
}
|
||
let titles = SKDataUtil.toJson({
|
||
onload: this.onLoad,
|
||
titles: this.titles,
|
||
}, "{}");
|
||
let partnerList: string = "";
|
||
if (this.partnerMgr) {
|
||
partnerList = this.partnerMgr.toJson();
|
||
}
|
||
let color = { c1: this.color1, c2: this.color2, p1: this.color_one_serial, p2: this.color_two_serial };
|
||
let friendlist = SKDataUtil.clone(this.friendList);
|
||
for (let roleid in friendlist) {
|
||
if (friendlist.hasOwnProperty(roleid)) {
|
||
if (roleid == 'version') {
|
||
continue;
|
||
}
|
||
let finfo = friendlist[roleid];
|
||
finfo.name = Buffer.from(finfo.name).toString('base64');
|
||
}
|
||
}
|
||
friendlist.version = 1;
|
||
let role_data: any = {
|
||
daySignIn: SKDataUtil.toJson(this.daySignIn, "{}"),
|
||
mendDate: this.mendDate,
|
||
dial_num: this.dial_num,
|
||
dial_count: this.dial_count,
|
||
dial_date: this.dial_date,
|
||
friendList: this.friendList,
|
||
color: color,
|
||
dbinfo: {
|
||
accountid: this.accountid,
|
||
name: this.name,
|
||
mapid: this.mapid,
|
||
x: this.x,
|
||
y: this.y,
|
||
addpoint: this.addattr2,
|
||
xiupoint: this.addattr1,
|
||
xiulevel: this.xiulevel,
|
||
pet: this.curPetId,
|
||
friendlist: friendlist,
|
||
equipinfo: equipSQL,
|
||
bagitem: this.bag_list,
|
||
bangid: this.bangid,
|
||
taskstate: this.taskStateToJson(),
|
||
partnerlist: partnerList,
|
||
lockeritem: this.locker_list,
|
||
skill: this.skill_list,
|
||
money: this.money,
|
||
jade: this.jade,
|
||
bind_jade: this.bind_jade,
|
||
bang_score: this.bangscore,
|
||
shi_score: this.shiscore,
|
||
di_score: this.discore,
|
||
xiu_score: this.xiuscore,
|
||
guo_score: this.guoscore,
|
||
exp: this.exp,
|
||
level: this.level,
|
||
level_reward: this.level_reward,
|
||
resid: this.resid,
|
||
race: this.race,
|
||
sex: this.sex,
|
||
relive: this.relive,
|
||
relivelist: this.relivelist,
|
||
shane: this.shane,
|
||
state: this.nFlag,
|
||
rewardrecord: this.rewardrecord,
|
||
sprewardrecord: this.sprewardrecord,
|
||
getgift: this.getgift,
|
||
shuilu: this.shuilu,
|
||
arena: this.arena,
|
||
titles: titles,
|
||
active_scheme_name: this.schemeName,
|
||
color: color,
|
||
star: this.star,
|
||
horse_index: this.horseList.horseIndex,
|
||
day_count: this.dayMap,
|
||
bagKindNum: this.bagKindNum,
|
||
mend_date: this.mend_date,
|
||
tianti_integral: this.tianti_integral,
|
||
},
|
||
}
|
||
SKRedisUtil.setValue(this.roleid.toString(), role_data);
|
||
let pet_list: any = [];
|
||
let scheme_list: any = [];
|
||
let hourse_list: any = [];
|
||
let hourse_skill_list: any = [];
|
||
for (let key in this.petList) {
|
||
let pet = this.petList[key];
|
||
pet_list.push(pet.toSaveObj())
|
||
}
|
||
for (let key in this.schemeMgr.schemeList) {
|
||
let scheme = this.schemeMgr.schemeList[key];
|
||
scheme_list.push(scheme.toObj())
|
||
}
|
||
for (let key in this.horseList.dict) {
|
||
let hourse = this.horseList.dict[key];
|
||
hourse_list.push(hourse)
|
||
}
|
||
for (let key in this.horseSkill.dict) {
|
||
let hourses = this.horseSkill.dict[key];
|
||
hourse_skill_list.push(hourses)
|
||
}
|
||
SKRedisUtil.setValue(this.roleid + "pet", SKDataUtil.toJson(pet_list, "{}"));
|
||
SKRedisUtil.setValue(this.roleid + "scheme", SKDataUtil.toJson(scheme_list, "{}"));
|
||
SKRedisUtil.setValue(this.roleid + "hourse", SKDataUtil.toJson(hourse_list, "{}"));
|
||
SKRedisUtil.setValue(this.roleid + "hourseskill", SKDataUtil.toJson(hourse_skill_list, "{}"));
|
||
}
|
||
|
||
|
||
toObj(): any {
|
||
let teamPlayers = TeamMgr.shared.getTeamPlayer(this.teamid);
|
||
let card = ChangeCard.shared.selectUseCard(this.roleid);
|
||
let effid = SpecialEffect.shared.getSuiEffect(this.roleid)
|
||
let changeid = 0;
|
||
let effectid = 0;
|
||
if (card) {
|
||
changeid = card.resid;
|
||
}
|
||
if (effid > 0) {
|
||
effectid = effid;
|
||
}
|
||
let obj: any = super.toObj();
|
||
obj.relive = this.relive;
|
||
obj.xiulevel = this.xiulevel;
|
||
obj.level = this.level;
|
||
obj.accountid = this.accountid;
|
||
obj.roleid = this.roleid;
|
||
obj.resid = this.resid;
|
||
obj.race = this.race;
|
||
obj.sex = this.sex;
|
||
obj.spd = this.attr1[EAttrTypeL1.SPD];
|
||
obj.bangid = this.bangid;
|
||
obj.livingtype = this.living_type;
|
||
obj.teamid = this.teamid;
|
||
obj.isleader = this.isleader;
|
||
obj.teamcnt = teamPlayers == null ? 0 : teamPlayers.length;
|
||
obj.weapon = this.getWeapon();
|
||
obj.battleid = this.battle_id;
|
||
obj.bangname = this.bangname;
|
||
obj.titletype = this.titleType;
|
||
obj.titleid = this.titleId;
|
||
obj.titleval = this.titleVal;
|
||
obj.color1 = this.color1;
|
||
obj.color2 = this.color2;
|
||
obj.schemename = this.schemeName;
|
||
obj.baldric = this.baldric;
|
||
obj.safepassword = this.safe_password;
|
||
obj.safelock = this.safe_lock;
|
||
obj.horseList = this.horseList.toObj();
|
||
obj.wingId = this.wingId;
|
||
obj.sat_integral = this.sat_integral;
|
||
obj.dayMap = SKDataUtil.toJson(this.dayMap, "{}");
|
||
obj.chargesum = ChargeSum.shared.getPlayerChargeSum(this.roleid);
|
||
obj.bagKindNum = this.bagKindNum;
|
||
obj.lockerKindNum = this.lockerKindNum;
|
||
obj.tianti_integral = this.tianti_integral;
|
||
// 坐牢时间
|
||
obj.shane = this.shane
|
||
// 界面图标
|
||
obj.iconList = this.iconList;
|
||
// 出战宠物信息
|
||
let pet: any;
|
||
if (this.curPet != undefined) {
|
||
pet = {};
|
||
pet.petid = this.curPet.petid;
|
||
pet.resid = this.curPet.resid;
|
||
pet.name = this.curPet.name;
|
||
pet.spd = this.curPet.attr1[EAttrTypeL1.SPD];
|
||
pet.level = this.curPet.level;
|
||
pet.relive = this.curPet.relive;
|
||
}
|
||
obj.curPet = pet == undefined ? "" : pet;
|
||
// 最后一次时使用的技能
|
||
let role = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
let skill = ESkillType.NormalAtkSkill;
|
||
if (role != null && role != undefined) {
|
||
let brole = new BattleRole();
|
||
brole.setObj(role);
|
||
if (brole.last_skill > 0) {
|
||
skill = brole.last_skill;
|
||
}
|
||
}
|
||
obj.lastSkill = skill;
|
||
// 竞技场信息
|
||
obj.arena = this.arena;
|
||
// 签到数据
|
||
obj.daySignIn = this.daySignIn;
|
||
// 补签日期
|
||
obj.mendDate = this.mendDate;
|
||
//变身卡id
|
||
obj.changeid = changeid;
|
||
let seffectlist = [505201, 505202, 505301, 505302, 505401, 505406, 505407, 505433, 505452, 505457, 505432, 505437, 505601, 505602, 505453];
|
||
let index = Math.floor((Math.random() * seffectlist.length))
|
||
if (this.ai_flag == 0) {
|
||
//正在使用的特效
|
||
obj.effectlist = SKDataUtil.toJson(SpecialEffect.shared.getUseingEffect(this.roleid), "{}");
|
||
//随身特效
|
||
obj.effectid = effectid;
|
||
} else {
|
||
let list = [];
|
||
list.push(seffectlist[index]);
|
||
obj.effectlist = SKDataUtil.toJson(list, "{}");
|
||
obj.effectid = seffectlist[index];
|
||
}
|
||
//头像框
|
||
obj.portrait = SpecialEffect.shared.getPortraitByRoleid(this.roleid);
|
||
|
||
obj.pause = this.pause;
|
||
obj.ischeck = this.ischeck;
|
||
obj.offlinetime = this.offlinetime;
|
||
obj.doublecnt = this.doublecnt;
|
||
obj.unget_doublecnt = this.unget_doublecnt;
|
||
obj.getgift = this.getgift;
|
||
obj.isFrozen = this.isFrozen;
|
||
obj.babyList = this.BabyMgr.ToJson()
|
||
obj.xwList = this.XWMgr.ToJson()
|
||
obj.starInfo = this.StarMgr.ToJson()
|
||
this.clear_task();
|
||
// 属性检测
|
||
this.freeze();
|
||
return obj;
|
||
}
|
||
|
||
clear_task() {
|
||
// 处理部分任务不刷新
|
||
let mendDate: any = new Date(GTimer.getYearMonthDay()).getTime();
|
||
let lastDate = mendDate;
|
||
if (this.mend_date != "") {
|
||
lastDate = new Date(this.mend_date).getTime();
|
||
if (lastDate < mendDate) {
|
||
this.F5_Task();
|
||
}
|
||
} else {
|
||
this.F5_Task();
|
||
}
|
||
}
|
||
|
||
F5_Task() {
|
||
let hours: number = GTimer.getHours();
|
||
if (hours >= 5) {
|
||
if (!this.isRobot()) {
|
||
console.log("玩家：" + this.roleid + " == " + this.name + "任务刷新了~")
|
||
if (this.dbData != undefined) {
|
||
this.dbData.taskstate = null;
|
||
}
|
||
this.arena.count = 10;
|
||
this.dial_num = 1;
|
||
this.getTaskMgr().OnNewDay();
|
||
this.clearDayMap();
|
||
this.clearDayMapVip();
|
||
this.mend_date = GTimer.getYearMonthDay();
|
||
}
|
||
}
|
||
}
|
||
|
||
getWeapon() {
|
||
for (let equip of this.currentEquips) {
|
||
if (equip.EIndex == 1) {
|
||
let equipobj: any = {};
|
||
equipobj.equipid = equip.EquipID;
|
||
equipobj.gemcnt = equip.GemCnt;
|
||
equipobj.type = equip.EquipType;
|
||
equipobj.level = equip.Grade;
|
||
return SKDataUtil.toJson(equipobj, "{}");
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
|
||
getData() {
|
||
let fp = FivePhases.shared.getFivePhasesByRoleid(this.roleid);
|
||
let card = ChangeCard.shared.selectUseCard(this.roleid);
|
||
let fplevel = 0;
|
||
let changeid = 0;
|
||
if (fp) {
|
||
fplevel = fp.fplevel;
|
||
}
|
||
if (card) {
|
||
changeid = card.resid;
|
||
}
|
||
let obj: any = {};
|
||
obj.onlyid = this.onlyid;
|
||
obj.qianneng = this.qianneng;
|
||
obj.attr1 = SKDataUtil.toJson(this.attr1, "{}");
|
||
obj.xiulevel = this.xiulevel;
|
||
obj.addattr1 = SKDataUtil.toJson(this.addattr1, "{}");
|
||
obj.addattr2 = SKDataUtil.toJson(this.addattr2, "{}");
|
||
obj.skill = SKDataUtil.toJson(this.skill_list, "{}");
|
||
obj.level = this.level;
|
||
obj.exp = this.exp;
|
||
obj.bangid = this.bangid;
|
||
obj.race = this.race;
|
||
obj.sex = this.sex;
|
||
obj.maxexp = this.maxexp;
|
||
obj.money = this.money;
|
||
obj.jade = this.jade;
|
||
obj.bangscore = this.bangscore;
|
||
obj.shiscore = this.shiscore;
|
||
obj.discore = this.discore;
|
||
obj.xiuscore = this.xiuscore;
|
||
obj.guoscore = this.guoscore;
|
||
obj.bindjade = this.bind_jade;
|
||
obj.gmlevel = this.gmlevel;
|
||
obj.chargesum = ChargeSum.shared.getPlayerChargeSum(this.roleid);
|
||
obj.rewardrecord = this.rewardrecord;
|
||
obj.sprewardrecord = this.sprewardrecord;
|
||
obj.levelreward = this.level_reward;
|
||
obj.shuilugj = this.shuilu.gongji;
|
||
obj.titleval = this.titleVal;
|
||
obj.titletype = this.titleType;
|
||
obj.titleid = this.titleId;
|
||
obj.color1 = this.color1;
|
||
obj.color2 = this.color2;
|
||
obj.schemename = this.schemeName;
|
||
obj.wingId = this.wingId;
|
||
obj.sat_integral = this.sat_integral;
|
||
obj.fplevel = fplevel;
|
||
obj.changeid = changeid;
|
||
obj.jpoint = this.arena.jpoint;
|
||
obj.tianti_integral = this.tianti_integral;
|
||
obj.iconList = this.iconList;
|
||
return obj;
|
||
}
|
||
|
||
setLevel(level: any, issend?: any) {//等级改变
|
||
let maxlevel = ExpUtil.getUserMaxGrade(this.relive);
|
||
this.level = Math.min(level, maxlevel);
|
||
SKLogger.debug(`玩家[${this.name}${this.roleid}]等级改变，当前${this.level}级`);
|
||
this.maxexp = ExpUtil.getPlayerUpgradeExp(this.relive, this.level);
|
||
this.calQianNeng();
|
||
this.calculateAttr();
|
||
if (this.partnerMgr) {
|
||
this.partnerMgr.checkAndAddPartner();
|
||
if (this.level <= GameUtil.limitPartnerLevel) {
|
||
this.partnerMgr.UpdatePartnerLevelAsPlayer();
|
||
}
|
||
}
|
||
PaiHangMgr.shared.CheckAndInsertLevelPaihang(this.roleid, this.name, this.relive, this.level, this.money);
|
||
// 更新红名榜数据
|
||
PaiHangMgr.shared.updateMurderRankDataInfo(this.roleid, this.name, 0, this.level, this.relive);
|
||
if (issend) {
|
||
this.send('s2c_level_up', {
|
||
onlyid: this.onlyid,
|
||
curlevel: this.level,
|
||
});
|
||
}
|
||
if (this.bangid > 0) {
|
||
let bang = BangMgr.shared.getBang(this.bangid)
|
||
if (bang) {
|
||
for (const roleInfo of bang.rolelist) {
|
||
if (this.roleid == roleInfo.roleid) {
|
||
roleInfo.relive = this.relive;
|
||
roleInfo.level = this.level;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
// 刷新队伍信息
|
||
this.refresh_team_data();
|
||
|
||
}
|
||
|
||
taskStateToJson(): string {
|
||
let mapValue: any = {};
|
||
let vecData = [];
|
||
if (this.getTaskMgr()) {
|
||
if (this.getTaskMgr().mapTaskState) {
|
||
for (let it in this.getTaskMgr().mapTaskState) {
|
||
let stTaskState = this.getTaskMgr().mapTaskState[it];
|
||
let nCurStep = 0;
|
||
|
||
for (let it2 in stTaskState.vecEventState) {
|
||
if (stTaskState.vecEventState[it2].nState == 1)
|
||
nCurStep = Number(it2);
|
||
}
|
||
vecData.push({
|
||
nTaskID: stTaskState.nTaskID,
|
||
nCurStep: nCurStep
|
||
});
|
||
}
|
||
}
|
||
mapValue['RecordList'] = this.getTaskMgr().recordList;
|
||
mapValue['DailyCnt'] = this.getTaskMgr().mapDailyCnt;
|
||
mapValue['FuBenCnt'] = this.getTaskMgr().mapFuBenCnt;
|
||
mapValue['DailyStart'] = this.getTaskMgr().mapDailyStart;
|
||
mapValue['mapActiveScore'] = this.getTaskMgr().mapActiveScore;
|
||
mapValue['szBeenTake'] = this.getTaskMgr().szBeenTake;
|
||
}
|
||
mapValue['StateList'] = vecData;
|
||
return mapValue;
|
||
}
|
||
|
||
////////////////////////////// 物品 相关 /////////////////////////////
|
||
|
||
// 清理背包
|
||
clear_bag(msg: string) {
|
||
// if (msg == "清理背包"){
|
||
// this.bag_list = {}
|
||
// this.send('s2c_bagitem', {
|
||
// info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
// });
|
||
// }
|
||
if (msg == "分解配饰") {
|
||
this.clear_acc(2);
|
||
} else if (msg == "打开五行礼包") {
|
||
this.openGoods("50033");
|
||
} else if (msg == "打开变身卡礼包") {
|
||
this.openGoods("50034");
|
||
}
|
||
// else if (msg == "退出本次战斗") {
|
||
// if(this.battle_id > 0){
|
||
// let battle = BattleMgr.shared.getBattle(this.battle_id);
|
||
// if(battle.battle_type != BattleType.Force && battle.battle_type != BattleType.PK && battle.battle_type != BattleType.ShuiLu && battle.battle_type != BattleType.AREAN && battle.battle_type != BattleType.Sat){
|
||
// if(this.teamid > 0){
|
||
// if (this.isleader){
|
||
// BattleMgr.shared.destroyBattle(this.battle_id)
|
||
// }else {
|
||
// this.send_notice("您不是队长！");
|
||
// }
|
||
// }else {
|
||
// BattleMgr.shared.destroyBattle(this.battle_id)
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
}
|
||
|
||
openGoods(item: any) {
|
||
let obj: any = {};
|
||
let num = this.getBagItemNum(item);
|
||
if (num > 0) {
|
||
for (let i = 0; i < num; i++) {
|
||
let randomSelect = BoxMgr.shared.randomSelect(item);
|
||
let goods = this.bag_list[randomSelect.item_id]
|
||
if (goods == null || goods == undefined) {
|
||
this.bag_list[randomSelect.item_id] = randomSelect.count;
|
||
} else {
|
||
this.bag_list[randomSelect.item_id] += randomSelect.count;
|
||
}
|
||
if (obj[randomSelect.item_id] == null || obj[randomSelect.item_id] == undefined) {
|
||
obj[randomSelect.item_id] = randomSelect.count;
|
||
} else {
|
||
obj[randomSelect.item_id] += randomSelect.count;
|
||
}
|
||
}
|
||
this.bag_list[item] -= num;
|
||
if (this.bag_list[item] <= 0) {
|
||
delete this.bag_list[item];
|
||
}
|
||
|
||
let msg = "本次开启礼包获得：";
|
||
for (let key in obj) {
|
||
let itemData = ItemUtil.getItemData(key);
|
||
let count = obj[key];
|
||
msg += `[color=#ff0000]${itemData.name}[/color]：${count}、`;
|
||
}
|
||
this.send_notice(msg);
|
||
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
} else {
|
||
this.send_notice("抱歉，您背包没有该道具！");
|
||
}
|
||
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param flag :1 全部清理、2 只分解配饰
|
||
*/
|
||
clear_acc(flag: number) {
|
||
let equipAcc: any = [];
|
||
for (let i = 0; i < this.listEquips.length; i++) {
|
||
let equip = this.listEquips[i];
|
||
if (equip.EquipType == 5) {
|
||
let equip_: Equip = this.equipObjs[equip.EquipID];
|
||
equipAcc.push(equip_);
|
||
}
|
||
}
|
||
//let count_score = 0;
|
||
for (const acc of equipAcc) {
|
||
// let score = 1;
|
||
// if (acc.BaseAttr.length != 0 ){
|
||
// if (acc.Grade == 2) {
|
||
// score = 2;
|
||
// } else if (acc.Grade == 3) {
|
||
// score = 5;
|
||
// }
|
||
// }
|
||
// count_score += score;
|
||
//this.shuilu.gongji += score;
|
||
this.delEquipByTo(acc.EquipID, false, "佩饰分解");
|
||
this.sendEquipList();
|
||
}
|
||
|
||
// this.send('s2c_you_money', {
|
||
// nKind: GameUtil.goldKind.SLDH_Score,
|
||
// nNum: this.shuilu.gongji,
|
||
// nChange: count_score
|
||
// });
|
||
// let info = `本次分解获得[color=#ff0000][${count_score}][/color]功绩`;
|
||
// this.send('s2c_notice', {
|
||
// strRichText: info
|
||
// });
|
||
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
}
|
||
|
||
// 批量分解配饰
|
||
delEquipByTo(equipid: any, uninlay = true, source = '') {
|
||
if (!equipid || equipid <= 0) {
|
||
return;
|
||
}
|
||
let delequip = null;
|
||
for (let index = 0; index < this.currentEquips.length; index++) { //已经装备的不能删，所以注释掉以下代码
|
||
if (this.currentEquips[index].EquipID == equipid) {
|
||
delequip = this.currentEquips[index];
|
||
this.currentEquips.splice(index, 1);
|
||
continue;
|
||
}
|
||
}
|
||
for (let index = 0; index < this.listEquips.length; index++) {
|
||
if (this.listEquips[index].EquipID == equipid) {
|
||
delequip = this.listEquips[index];
|
||
this.listEquips.splice(index, 1);
|
||
continue;
|
||
}
|
||
}
|
||
if (delequip != null) {
|
||
delequip.pos = EEquipPos.UNKNOW;
|
||
let equipfulldata = delequip.getFullData();
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]删除装备[${delequip.EquipID}:${equipfulldata.EName}]:${source}]`);
|
||
if (uninlay) {
|
||
this.unInLay(delequip);
|
||
}
|
||
delequip.state = 0;
|
||
delequip.save();
|
||
delete this.equipObjs[delequip.EquipID];
|
||
EquipMgr.shared.delEquip(delequip.EquipID);
|
||
this.schemeMgr.deleteCurEquips(delequip.EquipID);
|
||
}
|
||
}
|
||
|
||
update_bagitem(data: any) {
|
||
if (data.operation == 0) {
|
||
if (this.bag_list[data.itemid] == null || this.bag_list[data.itemid] < data.count) {
|
||
this.send('s2c_operation_result', {
|
||
code: MsgCode.ITEM_OPERATION_ERROR
|
||
});
|
||
} else {
|
||
this.bag_list[data.itemid] -= data.count;
|
||
if (this.bag_list[data.itemid] <= 0) {
|
||
delete this.bag_list[data.itemid];
|
||
}
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
}
|
||
} else {
|
||
if (this.bag_list[data.itemid] == null) {
|
||
this.bag_list[data.itemid] = data.count;
|
||
} else {
|
||
this.bag_list[data.itemid] += data.count;
|
||
}
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
}
|
||
}
|
||
|
||
update_lockeritem(data: any) {
|
||
if (data.operation == 1) {
|
||
if (this.getLockerItemAllKindNum() >= this.lockerKindNum) {
|
||
this.send_notice(`仓库已满`);
|
||
return;
|
||
}
|
||
} else if (data.operation == 0) {
|
||
if (this.getBagItemAllKindNum() >= this.bagKindNum) {
|
||
this.send_notice(`背包已满`);
|
||
return;
|
||
}
|
||
|
||
}
|
||
if (data.type == 0) {
|
||
if (data.operation == 0) {
|
||
if (this.locker_list[data.operateid] > 0) {
|
||
if (this.bag_list[data.operateid] == null) this.bag_list[data.operateid] = 0;
|
||
this.bag_list[data.operateid] += this.locker_list[data.operateid];
|
||
}
|
||
delete this.locker_list[data.operateid];
|
||
} else {
|
||
if (this.bag_list[data.operateid] > 0) {
|
||
if (this.locker_list[data.operateid] == null) this.locker_list[data.operateid] = 0;
|
||
this.locker_list[data.operateid] += this.bag_list[data.operateid];
|
||
}
|
||
delete this.bag_list[data.operateid];
|
||
}
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
} else if (data.type == 1) {
|
||
if (data.operation == 0) {
|
||
for (let index = 0; index < this.lockerEquips.length; index++) {
|
||
let equip = this.lockerEquips[index];
|
||
if (data.operateid == equip.EquipID) {
|
||
equip.pos = EEquipPos.BAG;
|
||
this.lockerEquips.splice(index, 1);
|
||
this.addEquipList(equip);
|
||
break;
|
||
}
|
||
}
|
||
} else {
|
||
for (let index = 0; index < this.listEquips.length; index++) {
|
||
let equip = this.listEquips[index];
|
||
if (data.operateid == equip.EquipID) {
|
||
equip.pos = EEquipPos.BANK;
|
||
this.listEquips.splice(index, 1);
|
||
this.lockerEquips.push(equip);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
this.sendEquipList();
|
||
}
|
||
}
|
||
|
||
getBagItemNum(itemid: any): any {
|
||
if (this.bag_list.hasOwnProperty(itemid) == false)
|
||
return 0;
|
||
|
||
return this.bag_list[itemid];
|
||
}
|
||
// 加经验值
|
||
addExp(exp: number) {
|
||
if (exp == 0) {
|
||
return;
|
||
}
|
||
//检查星阵是否装备赤马阵, 经验获得加成
|
||
if (exp > 0 && this.StarMgr.EquipID == 5) {
|
||
let star = this.StarMgr.GetStarByID(5)
|
||
let buf = star.Level * 0.003
|
||
exp = Math.floor(exp * (1 + buf))
|
||
}
|
||
|
||
super.addExp(exp);//经验改变
|
||
if (this.relive == 0 && this.level > 28) {
|
||
let score = 0;
|
||
for (let equip of this.currentEquips) {
|
||
let full = equip.getFullData(this.roleid);
|
||
if (full) {
|
||
score += Number(full.BaseScore);
|
||
}
|
||
}
|
||
//角色大于28级加入竞技场
|
||
let jingjilist = PaiHangMgr.shared.jingjilist;
|
||
let isexit = false;
|
||
for (let index = 0; index < jingjilist.length; index++) {
|
||
let brole = jingjilist[index];
|
||
if (brole.roleId == this.roleid) {
|
||
isexit = true;
|
||
jingjilist.splice(index, 1, {//存在，替换
|
||
roleId: this.roleid,
|
||
resid: this.resid,
|
||
name: this.name,
|
||
count: this.arena.count,
|
||
jpoint: this.arena.jpoint,
|
||
relive: this.relive,
|
||
level: this.level,
|
||
ranking: index + 1,
|
||
baseSource: score,
|
||
});
|
||
this.arena.ranking = index + 1
|
||
}
|
||
}
|
||
if (isexit == false) {//不存在加入
|
||
jingjilist.push({
|
||
roleId: this.roleid,
|
||
resid: this.resid,
|
||
name: this.name,
|
||
count: this.arena.count,
|
||
jpoint: this.arena.jpoint,
|
||
relive: this.relive,
|
||
level: this.level,
|
||
ranking: jingjilist.length + 1,
|
||
baseSource: score,
|
||
});
|
||
this.arena.ranking = jingjilist.length + 1
|
||
}
|
||
}
|
||
if (this.relive == 1 && this.level >= 80) { //达到1转80级开启五行修炼
|
||
let playerfp = FivePhases.shared.getFivePhasesByRoleid(this.roleid);
|
||
if (playerfp == undefined) {
|
||
let fp = {
|
||
roleid: this.roleid,//角色id
|
||
fplevel: 0, //五行等级
|
||
jinlevel: 0, //金等级
|
||
jinexp: 0, //金经验
|
||
mulevel: 0, //木等级
|
||
muexp: 0, //木经验
|
||
shuilevel: 0, //水等级
|
||
shuiexp: 0, //水经验
|
||
huolevel: 0, //火等级
|
||
huoexp: 0, //火经验
|
||
tulevel: 0, //土等级
|
||
tuexp: 0, //土经验
|
||
count: 1000000 //次数
|
||
}
|
||
FivePhases.shared.fplist.push(fp);
|
||
DB.insertFivePhasesById(this.roleid);
|
||
}
|
||
}
|
||
if (exp > 0) {
|
||
this.send('s2c_add_exp', {
|
||
onlyid: this.onlyid,
|
||
curexp: this.exp,
|
||
addexp: exp,
|
||
maxexp: this.maxexp,
|
||
});
|
||
}
|
||
this.send('s2c_player_data', this.getData());
|
||
}
|
||
|
||
addItem(itemId: number, count: number, isNotice = false, source = ''): boolean {
|
||
count = SKDataUtil.numberBy(count);
|
||
if (isNaN(count)) {
|
||
SKLogger.warn(`玩家[${this.roleid}:${this.name}]:获得物品[${itemId}]数量无效!`);
|
||
return false;
|
||
}
|
||
let itemData = ItemUtil.getItemData(itemId);
|
||
if (itemData == null) { // 无此道具
|
||
SKLogger.warn(`玩家[${this.roleid}:${this.name}]获得物品[${itemId}]找不到!`);
|
||
return false;
|
||
}
|
||
if (itemData.type < 4) {
|
||
this.addBagItem(itemId, count, isNotice);
|
||
} else if (itemData.type == 4) {
|
||
this.addExp(count);
|
||
} else if (itemData.type == 5) {
|
||
this.addMoney(0, count, source, isNotice == true ? MsgCode.SUCCESS : MsgCode.FAILED);
|
||
} else if (itemData.type == 6) {
|
||
this.addMoney(1, count, source, isNotice == true ? MsgCode.SUCCESS : MsgCode.FAILED);
|
||
} else if (itemData.type == 7 || itemData.type == 8) { // 7 神器 8 仙器
|
||
let info = itemData.json;
|
||
if (itemData.id) {
|
||
info.resid = itemData.id;
|
||
}
|
||
info.roleid = this.roleid;
|
||
this.addEquip(info);
|
||
} else if (itemData.type == 9) {
|
||
if (this.petList.length >= GameUtil.limitPetNum) {
|
||
this.send_notice("当前携带宠物已上限")
|
||
return false;
|
||
}
|
||
this.createPet(itemData.json, source, isNotice);
|
||
} else if (itemData.type == 10) {
|
||
this.addBagItem(itemId, count, isNotice);
|
||
} else if (itemData.type == 11) {
|
||
let itemlist = itemData.json;
|
||
if (itemlist) {
|
||
let index = Math.floor(Math.random() * itemlist.length);
|
||
let tempId = itemlist[index];
|
||
if (tempId != null) {
|
||
itemId = tempId;
|
||
}
|
||
this.addBagItem(itemId, 1, isNotice);
|
||
}
|
||
} else if (itemData.type == 12) {
|
||
this.addMoney(GameUtil.goldKind.BindJade, count, source, MsgCode.SUCCESS);
|
||
} else if (itemData.type == 13) { // 宝箱
|
||
this.addBagItem(itemId, count, isNotice);
|
||
} else if (itemData.type == 14) { // 钥匙
|
||
this.addBagItem(itemId, count, isNotice);
|
||
} else if (itemData.type == 15) { // 变身卡
|
||
this.addBagItem(itemId, count, isNotice);
|
||
} else if (itemData.type == 16) { // 特效
|
||
//获取特效类型
|
||
let effecttype = SpecialEffect.shared.getSeffectType(itemId);
|
||
SpecialEffect.shared.seffectlist.push({
|
||
roleid: this.roleid,
|
||
effectid: itemId,
|
||
effecttype: effecttype,
|
||
usestate: 0
|
||
})
|
||
DB.insertSeffect(itemId, this.roleid, 0, effecttype, 1);
|
||
//this.addBagItem(itemId, count, isNotice);
|
||
} else if (itemData.type == 17) {
|
||
let info = itemData.json;
|
||
info.id = itemData.id;
|
||
info.roleid = this.roleid;
|
||
this.addMagicWeapon(info);
|
||
} else if (18 == itemData.type) {
|
||
if (this.XWMgr.buildNewXw(itemId)) {
|
||
this.addBagItem(itemId, count, isNotice);
|
||
}
|
||
} else if (19 == itemData.type) {
|
||
this.addBagItem(itemId, count, isNotice);
|
||
}
|
||
let info = `玩家[(${this.roleid}:${this.name}]`;
|
||
if (count < 0) {
|
||
info += `物品[${itemData.id}:${itemData.name}]减少${count}个，${source}`;
|
||
} else {
|
||
info += `获得物品[${itemData.id}:${itemData.name}]${count}个，${source}`;
|
||
}
|
||
SKLogger.debug(info);
|
||
return true;
|
||
}
|
||
|
||
getBagItemAllKindNum() {
|
||
let count: number = 0;
|
||
for (const item in this.bag_list) {
|
||
let data = ItemUtil.getItemData(item);
|
||
if (data != null) { // 无此道具
|
||
if (data.type != 15 && data.type != 18) {
|
||
if (GameUtil.flagGoods.indexOf(data.id) == -1) {
|
||
count++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return this.listEquips.length + count;
|
||
}
|
||
|
||
getLockerItemAllKindNum() {
|
||
return this.lockerEquips.length + Object.keys(this.locker_list).length;
|
||
}
|
||
|
||
addBagItem(nItem: any, nNum: any, bNotice: any) {
|
||
nNum = SKDataUtil.numberBy(nNum);
|
||
if (isNaN(nNum)) {
|
||
return;
|
||
}
|
||
if (this.bag_list[nItem] == null) {
|
||
if (nNum > 0) {
|
||
if (this.getBagItemAllKindNum() >= this.bagKindNum) {
|
||
this.send_notice(`背包已满`)
|
||
return;
|
||
}
|
||
}
|
||
this.bag_list[nItem] = 0;
|
||
}
|
||
let nNewNum = parseInt(this.bag_list[nItem]) + parseInt(nNum);
|
||
if (nNewNum < 0) {
|
||
return;
|
||
}
|
||
let itemData = ItemUtil.getItemData(nItem);
|
||
if (itemData == null) {
|
||
return;
|
||
}
|
||
this.bag_list[nItem] = nNewNum;
|
||
if (this.bag_list[nItem] == 0) {
|
||
delete this.bag_list[nItem];
|
||
}
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
if (bNotice) {
|
||
this.send('s2c_you_get_item', {
|
||
nItem: nItem,
|
||
nNum: nNum
|
||
});
|
||
}
|
||
//cxf背包物品变动
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.ITEM,
|
||
operateDepict: "背包物品变动",
|
||
operateResSerial: itemData.id,
|
||
operateResName: itemData.name,
|
||
operateContent: `${itemData.name} :数量${nNum},背包剩余数量${nNewNum}`
|
||
})
|
||
// if (itemData.notice != 0 && nNum > 0) {
|
||
// let strRichText = `<color=#00ff00 > ${this.name}</c > <color=#ffffff > 获得了</c ><color=#0fffff > ${itemData.name}</color >，<color=#ffffff > 真是太幸运了</c >`;
|
||
// PlayerMgr.shared.broadcast('s2c_screen_msg', {
|
||
// strRichText: strRichText,
|
||
// bInsertFront: 0
|
||
// });
|
||
// }
|
||
return;
|
||
}
|
||
|
||
/**
|
||
* 所有金币类消耗的入口
|
||
* @param {number} nKind 消耗类型
|
||
* @param {number} nNum 数量
|
||
* @param {String} strText 消耗日志
|
||
* @param {Boolen} usebind 是否使用绑定类型
|
||
*/
|
||
CostFee(nKind: any, nNum: any, strText?: any, usebind = true) {
|
||
let vecMsg = ['银两不足', '仙玉不足', '绑定仙玉不足', '水陆功绩不足', '', '竞技点不足'];
|
||
|
||
let money = this.GetMoney(nKind);
|
||
// let bindjade = this.GetMoney(GameUtil.goldKind.BindJade);
|
||
// if (nKind == GameUtil.goldKind.Jade && usebind) {
|
||
// money += bindjade;
|
||
// }
|
||
if (money < nNum) {
|
||
return vecMsg[nKind];
|
||
}
|
||
this.addMoney(nKind, -nNum, strText, MsgCode.SUCCESS);
|
||
return '';
|
||
}
|
||
|
||
GetMoney(nKind: any) {
|
||
let money = 0;
|
||
switch (nKind) {
|
||
case GameUtil.goldKind.Money:
|
||
money = this.money;
|
||
break;
|
||
case GameUtil.goldKind.Jade:
|
||
money = this.jade;
|
||
break;
|
||
case GameUtil.goldKind.BindJade:
|
||
money = this.bind_jade;
|
||
break;
|
||
case GameUtil.goldKind.SLDH_Score:
|
||
money = this.shuilu.gongji;
|
||
break;
|
||
case GameUtil.goldKind.arena_Score:
|
||
money = this.arena.jpoint;
|
||
break;
|
||
case GameUtil.goldKind.bang_Score:
|
||
money = this.bangscore;
|
||
break;
|
||
case GameUtil.goldKind.shi_Score:
|
||
money = this.shiscore;
|
||
break;
|
||
case GameUtil.goldKind.di_Score:
|
||
money = this.discore;
|
||
break;
|
||
case GameUtil.goldKind.xiu_Score:
|
||
money = this.xiuscore;
|
||
break;
|
||
case GameUtil.goldKind.guo_Score:
|
||
money = this.guoscore;
|
||
break;
|
||
}
|
||
return money;
|
||
}
|
||
// 加银两或仙玉
|
||
addMoney(kind: any, count: number, msg: string = "", flag: number = MsgCode.SUCCESS) {
|
||
if (kind == GameUtil.goldKind.Money) {
|
||
let money = this.money + count;
|
||
if (money > 2000000000) {
|
||
money = 2000000000;
|
||
}
|
||
this.money = money;
|
||
PaiHangMgr.shared.CheckAndInsertMoneyPaihang(this.roleid, this.name, this.relive, this.level, this.money);
|
||
if (count != 0) {
|
||
this.send('s2c_you_money', {
|
||
nKind: kind,
|
||
nNum: this.money,
|
||
nChange: count,
|
||
flag: flag
|
||
});
|
||
SKLogger.debug(`玩家[${this.name}(${this.roleid})]银两改变[${count}]，当前[${this.money},消息:${msg}]`);
|
||
}
|
||
return;
|
||
|
||
}
|
||
if (kind == GameUtil.goldKind.Jade) { // 仙玉
|
||
let jade = this.jade + count;
|
||
if (jade > 1000000000) {
|
||
jade = 1000000000;
|
||
}
|
||
this.jade = jade;
|
||
if (count != 0) {
|
||
this.send('s2c_you_money', {
|
||
nKind: kind,
|
||
nNum: this.jade,
|
||
nChange: count,
|
||
flag: flag
|
||
});
|
||
//cxf仙玉变动
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.ITEM,
|
||
operateDepict: "仙玉改变",
|
||
operateResSerial: "",
|
||
operateResName: "",
|
||
operateContent: `${this.name}]仙玉改变[${count}]，当前[${this.jade}],消息:${msg}`
|
||
})
|
||
SKLogger.info(`玩家[${this.roleid}:${this.name}]仙玉改变[${count}]，当前[${this.jade}],消息:${msg}`);
|
||
}
|
||
return;
|
||
}
|
||
if (kind == GameUtil.goldKind.bang_Score) { // 帮贡
|
||
let bangscore = this.bangscore + count;
|
||
if (bangscore > 10000000000) {
|
||
bangscore = 10000000000;
|
||
}
|
||
this.bangscore = bangscore;
|
||
if (count != 0) {
|
||
this.send('s2c_you_money', {
|
||
nKind: kind,
|
||
nNum: this.bangscore,
|
||
nChange: count,
|
||
flag: flag
|
||
});
|
||
//cxf仙玉变动
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.ITEM,
|
||
operateDepict: "帮贡改变",
|
||
operateResSerial: "",
|
||
operateResName: "",
|
||
operateContent: `${this.name}]帮贡改变[${count}]，当前[${this.bangscore}],消息:${msg}`
|
||
})
|
||
SKLogger.info(`玩家[${this.roleid}:${this.name}]帮贡改变[${count}]，当前[${this.bangscore}],消息:${msg}`);
|
||
DB.updateMoney({ bind_jade: this.bind_jade, shiscore: this.shiscore, bangscore: this.bangscore, discore: this.discore, xiuscore: this.xiuscore, guoscore: this.guoscore, roleid: this.roleid });
|
||
}
|
||
return;
|
||
}
|
||
if (kind == GameUtil.goldKind.shi_Score) { // 师贡
|
||
let shiscore = this.shiscore + count;
|
||
if (shiscore > 10000000000) {
|
||
shiscore = 10000000000;
|
||
}
|
||
this.shiscore = shiscore;
|
||
if (count != 0) {
|
||
this.send('s2c_you_money', {
|
||
nKind: kind,
|
||
nNum: this.shiscore,
|
||
nChange: count,
|
||
flag: flag
|
||
});
|
||
//cxf仙玉变动
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.ITEM,
|
||
operateDepict: "师贡改变",
|
||
operateResSerial: "",
|
||
operateResName: "",
|
||
operateContent: `${this.name}]师贡改变[${count}]，当前[${this.shiscore}],消息:${msg}`
|
||
})
|
||
SKLogger.info(`玩家[${this.roleid}:${this.name}]师贡改变[${count}]，当前[${this.shiscore}],消息:${msg}`);
|
||
DB.updateMoney({ bind_jade: this.bind_jade, shiscore: this.shiscore, bangscore: this.bangscore, discore: this.discore, xiuscore: this.xiuscore, guoscore: this.guoscore, roleid: this.roleid });
|
||
}
|
||
return;
|
||
}
|
||
if (kind == GameUtil.goldKind.di_Score) { // 地宫积分
|
||
let discore = this.discore + count;
|
||
if (discore > 10000000000) {
|
||
discore = 10000000000;
|
||
}
|
||
this.discore = discore;
|
||
if (count != 0) {
|
||
this.send('s2c_you_money', {
|
||
nKind: kind,
|
||
nNum: this.discore,
|
||
nChange: count,
|
||
flag: flag
|
||
});
|
||
//cxf仙玉变动
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.ITEM,
|
||
operateDepict: "地宫积分改变",
|
||
operateResSerial: "",
|
||
operateResName: "",
|
||
operateContent: `${this.name}]地宫积分改变[${count}]，当前[${this.discore}],消息:${msg}`
|
||
})
|
||
SKLogger.info(`玩家[${this.roleid}:${this.name}]地宫积分改变[${count}]，当前[${this.discore}],消息:${msg}`);
|
||
DB.updateMoney({ bind_jade: this.bind_jade, shiscore: this.shiscore, bangscore: this.bangscore, discore: this.discore, xiuscore: this.xiuscore, guoscore: this.guoscore, roleid: this.roleid });
|
||
}
|
||
return;
|
||
}
|
||
if (kind == GameUtil.goldKind.xiu_Score) { // 除魔积分
|
||
let xiuscore = this.xiuscore + count;
|
||
if (xiuscore > 10000000000) {
|
||
xiuscore = 10000000000;
|
||
}
|
||
this.xiuscore = xiuscore;
|
||
if (count != 0) {
|
||
this.send('s2c_you_money', {
|
||
nKind: kind,
|
||
nNum: this.xiuscore,
|
||
nChange: count,
|
||
flag: flag
|
||
});
|
||
//cxf仙玉变动
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.ITEM,
|
||
operateDepict: "除魔积分改变",
|
||
operateResSerial: "",
|
||
operateResName: "",
|
||
operateContent: `${this.name}]除魔积分改变[${count}]，当前[${this.xiuscore}],消息:${msg}`
|
||
})
|
||
SKLogger.info(`玩家[${this.roleid}:${this.name}]除魔积分改变[${count}]，当前[${this.xiuscore}],消息:${msg}`);
|
||
DB.updateMoney({ bind_jade: this.bind_jade, shiscore: this.shiscore, bangscore: this.bangscore, discore: this.discore, xiuscore: this.xiuscore, guoscore: this.guoscore, roleid: this.roleid });
|
||
}
|
||
return;
|
||
}
|
||
if (kind == GameUtil.goldKind.guo_Score) { // 郭氏积分
|
||
let guoscore = this.guoscore + count;
|
||
if (guoscore > 10000000000) {
|
||
guoscore = 10000000000;
|
||
}
|
||
this.guoscore = guoscore;
|
||
if (count != 0) {
|
||
this.send('s2c_you_money', {
|
||
nKind: kind,
|
||
nNum: this.guoscore,
|
||
nChange: count,
|
||
flag: flag
|
||
});
|
||
//cxf仙玉变动
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.ITEM,
|
||
operateDepict: "郭氏积分改变",
|
||
operateResSerial: "",
|
||
operateResName: "",
|
||
operateContent: `${this.name}]郭氏积分改变改变[${count}]，当前[${this.guoscore}],消息:${msg}`
|
||
})
|
||
SKLogger.info(`玩家[${this.roleid}:${this.name}]郭氏积分改变[${count}]，当前[${this.guoscore}],消息:${msg}`);
|
||
DB.updateMoney({ bind_jade: this.bind_jade, shiscore: this.shiscore, bangscore: this.bangscore, discore: this.discore, xiuscore: this.xiuscore, guoscore: this.guoscore, roleid: this.roleid });
|
||
}
|
||
return;
|
||
}
|
||
if (kind == GameUtil.goldKind.BindJade) { // 绑定仙玉
|
||
this.bind_jade += count;
|
||
if (count != 0) {
|
||
this.send('s2c_you_money', {
|
||
nKind: kind,
|
||
nNum: this.bind_jade,
|
||
nChange: count,
|
||
flag: flag
|
||
});
|
||
SKLogger.info(`玩家[${this.roleid}:${this.name}]绑定仙玉改变[${count}]，当前[${this.bind_jade}],消息:${msg}`);
|
||
DB.updateMoney({ bind_jade: this.bind_jade, shiscore: this.shiscore, bangscore: this.bangscore, discore: this.discore, xiuscore: this.xiuscore, guoscore: this.guoscore, roleid: this.roleid });
|
||
}
|
||
return;
|
||
}
|
||
if (kind == GameUtil.goldKind.SLDH_Score) { // 水陆大会功绩
|
||
this.shuilu.gongji += count;
|
||
if (count != 0) {
|
||
this.send('s2c_you_money', {
|
||
nKind: kind,
|
||
nNum: this.shuilu.gongji,
|
||
nChange: count,
|
||
flag: flag
|
||
});
|
||
SKLogger.debug(`玩家[${this.name}(${this.roleid})]水陆大会功绩改变[${count}]，当前[${this.shuilu.gongji},,消息:${msg}]`);
|
||
}
|
||
return;
|
||
}
|
||
if (kind == GameUtil.goldKind.arena_Score) { // 竞技场积分
|
||
this.arena.jpoint += count;
|
||
if (count != 0) {
|
||
this.send('s2c_you_money', {
|
||
nKind: kind,
|
||
nNum: this.arena.jpoint,
|
||
nChange: count,
|
||
flag: flag
|
||
});
|
||
SKLogger.debug(`玩家[${this.name}(${this.roleid})]竞技场积分改变[${count}]，当前[${this.arena.jpoint},,消息:${msg}]`);
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* 充值成功
|
||
* @param jade 增加的仙玉
|
||
* @param money 充值的money
|
||
*/
|
||
chargeSuccess(jade: any, money: any) {
|
||
this.addMoney(GameUtil.goldKind.Jade, jade, '仙玉充值', MsgCode.SUCCESS);
|
||
let money_n = Number(money);
|
||
let chargesum = ChargeSum.shared.getPlayerChargeSum(this.roleid);
|
||
this.send('s2c_charge', {
|
||
money: money_n,
|
||
jade: Number(this.jade),
|
||
chargesum: chargesum,
|
||
dayMap: SKDataUtil.toJson(this.dayMap, "{}")
|
||
});
|
||
}
|
||
|
||
aoi_enter(obj: BattleObj) {
|
||
if (obj.isNpc() && this.canPlayerSeeNpc(<Npc>obj) == false) {
|
||
return;
|
||
}
|
||
if (this.offline) {
|
||
return;
|
||
}
|
||
this.aoi_obj_list[obj.onlyid] = obj;
|
||
this.send('s2c_aoi_pinfo', {
|
||
list: [obj.toObj()]
|
||
});
|
||
}
|
||
|
||
aoi_update(obj: BattleObj) {
|
||
if (obj.isNpc() && this.canPlayerSeeNpc(<Npc>obj) == false) {
|
||
return;
|
||
}
|
||
//离线时返回不发送
|
||
if (this.offline) {
|
||
return;
|
||
}
|
||
this.aoi_obj_list[obj.onlyid] = obj;
|
||
this.send('s2c_aoi_pinfo', {
|
||
list: [obj.toObj()]
|
||
});
|
||
}
|
||
|
||
aoi_exit(obj: any) {
|
||
delete this.aoi_obj_list[obj.onlyid];
|
||
if (this.offline) {
|
||
return;
|
||
}
|
||
this.send('s2c_aoi_exit', {
|
||
onlyid: obj.onlyid,
|
||
});
|
||
}
|
||
// 发送消息
|
||
send(event: string, obj?: any) {
|
||
if (this.offline) {
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]已离线,消息[${event}:${obj}]不发送`);
|
||
return;
|
||
}
|
||
if (this.agent) {
|
||
this.agent.send(event, obj);
|
||
} else {
|
||
// 机器人不发送消息
|
||
if (this.isRobot()) {
|
||
return;
|
||
}
|
||
// SKLogger.warn(`玩家[${this.roleid}:${this.name}]发送[${event}]失败`);
|
||
}
|
||
}
|
||
//玩家登录
|
||
playerLogined() {
|
||
if (this.offline) {
|
||
this.offline = false;
|
||
}
|
||
PlayerMgr.shared.addPlayer(this);
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
if (this.offlineTimer) {
|
||
clearInterval(this.offlineTimer);
|
||
this.offlineTimer = null;
|
||
}
|
||
if (this.mapid == 1201) {
|
||
this.inPrison = true;
|
||
}
|
||
this.send('s2c_login', {
|
||
errorcode: MsgCode.SUCCESS,
|
||
info: this.toObj(),
|
||
});
|
||
this.babyPracticeConfig()
|
||
this.calcOnlineTime();
|
||
this.mailList.check();
|
||
this.activateScheme();
|
||
this.calculateAttr()
|
||
this.send('s2c_player_data', this.getData());
|
||
}
|
||
// 玩家重新登录
|
||
playerRelogin() {
|
||
if (this.offline) {
|
||
this.offline = false;
|
||
}
|
||
if (this.offlineTimer) {
|
||
clearInterval(this.offlineTimer);
|
||
this.offlineTimer = null;
|
||
}
|
||
|
||
this.calcOnlineTime();
|
||
}
|
||
// 计算在线时长
|
||
calcOnlineTime() {
|
||
if (this.onlineTime < 1) {
|
||
this.onlineTime = new Date().getTime();
|
||
} else {
|
||
let nowTime = new Date().getTime();
|
||
let time = nowTime - this.onlineTime;
|
||
let days = Math.floor(time / (24 * 3600 * 1000)); //相差天数
|
||
let leave1 = time % (24 * 3600 * 1000); //计算天数后剩余的毫秒数
|
||
let hours = Math.floor(leave1 / (3600 * 1000)); // 相差小时数
|
||
let leave2 = leave1 % (3600 * 1000); //计算小时数后剩余的毫秒数
|
||
let minutes = Math.floor(leave2 / (60 * 1000)); // 相差分钟数
|
||
let leave3 = leave2 % (60 * 1000); //计算分钟数后剩余的毫秒数
|
||
let seconds = Math.round(leave3 / 1000); // 相差秒数
|
||
SKLogger.info(`玩家[${this.roleid}:${this.name}]在线时长:${days}天${hours}小时${minutes}分钟${seconds}秒`);
|
||
this.onlineTime = 0;
|
||
}
|
||
}
|
||
// 进入地图
|
||
onEnterMap() {
|
||
this.stopIncense();
|
||
let mapModel: MapModel = MapMgr.shared.getMap(this);
|
||
if (mapModel) {
|
||
let playerList = mapModel.enterMap(this, ELiveingType.PLAYER);
|
||
let mList = [];
|
||
for (const oid in playerList) {
|
||
if (playerList.hasOwnProperty(oid)) {
|
||
const player = playerList[oid];
|
||
if (player.isNpc() && this.canPlayerSeeNpc(player) == false)
|
||
continue;
|
||
if (player.nFuBenID > 0 && player.nFuBenID != this.bangid)
|
||
continue;
|
||
this.aoi_obj_list[player.onlyid] = player;
|
||
let prefix: string = `${player.isRobot ? `机器人` : `玩家`}`;
|
||
SKLogger.debug(`${prefix}[${player.roleid}:${player.name}]进入地图[${mapModel.map_name}]!`);
|
||
mList.push(player.toObj());
|
||
}
|
||
}
|
||
this.send('s2c_aoi_pinfo', {
|
||
list: mList
|
||
});
|
||
// 进入比武场后 检查水路大会情况
|
||
let activity = ActivityMgr.shared.getActivity(ActivityDefine.activityKindID.ShuiLuDaHui);
|
||
if (activity && activity.activity_state != ActivityDefine.activityState.Close) {
|
||
if (activity.checkSign(this.teamid) && activity.checkFinish(this.teamid) == false) {
|
||
if (this.mapid == 1213) {
|
||
this.send('s2c_shuilu_sign', {
|
||
errorcode: MsgCode.SUCCESS,
|
||
shuilustate: activity.sldh_state,
|
||
});
|
||
} else {
|
||
activity.playerUnsign(this);
|
||
this.send('s2c_shuilu_unsign', {
|
||
errorcode: MsgCode.SUCCESS,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
onEnterGame() {
|
||
if (this.ShanEChange()) {
|
||
SKLogger.warn(`玩家[${this.roleid}:${this.name}]进入游戏错误`);
|
||
return;
|
||
}
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]进入游戏`);
|
||
this.onEnterMap();
|
||
// 发送角色数据
|
||
this.send('s2c_player_data', this.getData());
|
||
if (this.getpet == 0) {
|
||
this.send('s2c_new_pet', {});
|
||
} else {
|
||
this.sendPetList();
|
||
}
|
||
// 任务系统初始化放置在进入场景之后进行！
|
||
if (this.dbData) {
|
||
this.initTaskMgr(this.dbData.taskstate ? this.dbData.taskstate : '{}');
|
||
delete this.dbData;
|
||
}
|
||
if (this.teamid > 0) {
|
||
TeamMgr.shared.sendInfoToMember(this.teamid);
|
||
}
|
||
if (this.battle_id != 0) {
|
||
BattleMgr.shared.playerBackToBattle(this.battle_id, this.onlyid);
|
||
}
|
||
let ltime = new Date(this.lastonline);
|
||
this.CheckNewDay(ltime);
|
||
DB.updateLastOnlineTime(this.roleid);
|
||
this.lastonline = new Date(GameUtil.gameTime);
|
||
this.checkFriendInfo();
|
||
}
|
||
|
||
// 整理被删除的好友
|
||
checkFriendInfo() {
|
||
for (const key in this.friendList) {
|
||
if (this.friendList.hasOwnProperty(key)) {
|
||
let roleId = SKDataUtil.numberBy(key);
|
||
let target = PlayerMgr.shared.getPlayerByRoleId(roleId);
|
||
if (target) {
|
||
if (target.friendList[this.roleid] == null) {
|
||
delete this.friendList[target.roleid];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// NPC是否可见
|
||
canPlayerSeeNpc(npc: Npc) {
|
||
// 系统创建的NPC可见
|
||
if (npc.stCreater.nKind == NpcCreater.SYSTEM) {
|
||
return true;
|
||
}
|
||
// 玩家创建的并且是这个玩家可见
|
||
if (npc.stCreater.nKind == NpcCreater.PLAYER && npc.stCreater.nID == this.roleid) {
|
||
return true;
|
||
}
|
||
// 组队创建的NPC并且是这个队伍可见
|
||
if (npc.stCreater.nKind == NpcCreater.TEAM && npc.stCreater.nID == this.teamid && this.teamid > 0) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
playerMove(data: any, stop = false) {
|
||
if (this.usingIncense) {
|
||
this.anleiCnt--;
|
||
if (this.anleiCnt <= 0) {
|
||
this.triggerAnLei();
|
||
this.anleiCnt = Math.ceil(Math.random() * 15) + 15;
|
||
}
|
||
}
|
||
if (this.teamid > 0 && this.isleader && !stop) {
|
||
TeamMgr.shared.updateTeamPos(this.teamid, {
|
||
x: data.x,
|
||
y: data.y
|
||
});
|
||
}
|
||
let map: MapModel = MapMgr.shared.getMap(this);
|
||
if (map) {
|
||
let playerList: any[] = map.move(this.onlyid, data.x, data.y);
|
||
let memberList = [];
|
||
if (playerList) {
|
||
if (this.teamid > 0 && !this.isleader) {
|
||
playerList.push(this);
|
||
SKLogger.debug(`队友${this.name}加入列表`);
|
||
}
|
||
for (let player of playerList) {
|
||
if (player.isNpc() && this.canPlayerSeeNpc(player) == false) {
|
||
continue;
|
||
}
|
||
memberList.push(player.toObj());
|
||
};
|
||
}
|
||
this.send('s2c_aoi_pinfo', {
|
||
list: memberList
|
||
});
|
||
}
|
||
}
|
||
|
||
playerStop(data: any) {
|
||
this.playerMove(data, true);
|
||
if (this.teamid > 0 && this.isleader) {
|
||
TeamMgr.shared.setTeamPath(this.teamid, SKDataUtil.jsonBy(data.path));
|
||
}
|
||
}
|
||
|
||
enterPrison() {
|
||
this.inPrison = true;
|
||
if (this.teamid > 0) {
|
||
TeamMgr.shared.leaveTeam(this);
|
||
}
|
||
this.send('s2c_change_map', {
|
||
mapid: 1201,
|
||
pos: SKDataUtil.toJson({
|
||
x: 59,
|
||
y: 4
|
||
}, "{}")
|
||
});
|
||
this.changeMap({
|
||
mapid: 1201,
|
||
x: 59,
|
||
y: 4
|
||
});
|
||
}
|
||
|
||
leavePrison() {
|
||
if (this.shane > 0) {
|
||
return;
|
||
}
|
||
this.inPrison = false;
|
||
this.send('s2c_change_map', {
|
||
mapid: 1011,
|
||
pos: SKDataUtil.toJson({
|
||
x: 112,
|
||
y: 78
|
||
}, "{}")
|
||
});
|
||
this.changeMap({
|
||
mapid: 1011,
|
||
x: 112,
|
||
y: 78
|
||
});
|
||
}
|
||
|
||
changeMap(data: any) {
|
||
if (data.mapid == 1011 && this.shane > 0) {
|
||
this.enterPrison();
|
||
this.send('s2c_prison_time', {
|
||
onlyid: this.onlyid,
|
||
time: this.inPrison ? Math.ceil(this.shane / 4) : 0
|
||
});
|
||
return;
|
||
}
|
||
if (data.mapid == 3002 && this.bangid <= 0) {
|
||
this.send_notice("你还没有帮派，快去加入吧！");
|
||
return;
|
||
}
|
||
let map: MapModel = MapMgr.shared.getMap(this);
|
||
if (map) {
|
||
map.exitMap(this);
|
||
}
|
||
this.mapid = data.mapid;
|
||
this.x = data.x;
|
||
this.y = data.y;
|
||
this.onEnterMap();
|
||
if (this.teamid > 0 && this.isleader) {
|
||
TeamMgr.shared.changeTeamMap(this.teamid, this.mapid);
|
||
}
|
||
}
|
||
|
||
useIncense(time: any) {
|
||
this.stopIncense();
|
||
this.send('s2c_incense_state', {
|
||
ltime: time
|
||
});
|
||
this.usingIncense = true;
|
||
this.anleiCnt = Math.ceil(Math.random() * 20) + 20;
|
||
let self = this;
|
||
this.incenseTimer = SKTimeUtil.delay(() => {
|
||
self.usingIncense = false;
|
||
self.send('s2c_incense_state', {
|
||
ltime: 0
|
||
});
|
||
}, time * 1000);
|
||
return true;
|
||
}
|
||
|
||
stopIncense() {
|
||
this.usingIncense = false;
|
||
if (this.incenseTimer) {
|
||
SKTimeUtil.cancelDelay(this.incenseTimer);
|
||
this.incenseTimer = null;
|
||
}
|
||
}
|
||
|
||
triggerAnLei() { //触发暗雷怪
|
||
let map: MapModel = MapMgr.shared.getMap(this);
|
||
if (map) {
|
||
let groupid = map.getAnleiGroup();
|
||
if (groupid) {
|
||
this.monsterBattle(groupid, 0, BattleType.Normal, true);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 召唤兽转生
|
||
relivePet(data: any) {
|
||
let operationPet = null;
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
for (let pet of this.petList) {
|
||
if (pet.petid == data.petid) {
|
||
operationPet = pet;
|
||
break;
|
||
}
|
||
}
|
||
if (operationPet == null) {
|
||
console.warn(`$警告:[${this.roleid}:${this.name}]找不到转宝召唤兽:${data.petid}`);
|
||
return;
|
||
}
|
||
operationPet.petRelive();
|
||
if (player) {
|
||
//cxf宠物转生
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "宠物转生",
|
||
operateResSerial: data.petid,
|
||
operateResName: operationPet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
this.send('s2c_update_pet', {
|
||
info: operationPet.toObj()
|
||
});
|
||
}
|
||
|
||
// 开启宠物技能格子
|
||
openPetSkillGrid(data: any) {
|
||
// 道具编号
|
||
let prop: number = 10115;
|
||
|
||
let pet = this.getPetByID(data.petId);
|
||
|
||
let item_count = this.getBagItemNum(prop);
|
||
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
|
||
if (pet != null) {
|
||
|
||
let max: number = 4 * pet.getSkillNum();
|
||
// 必定开启
|
||
if (data.type == 2) {
|
||
if (item_count < max) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `缺少[${ItemUtil.getItemName(prop)}]`,
|
||
});
|
||
return;
|
||
}
|
||
pet.openSkillGrid(data.index);
|
||
//pet.learnSkill(3007);
|
||
this.addBagItem(prop, -max, false);
|
||
if (player) {
|
||
//cxf宠物格子
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "宠物格子",
|
||
operateResSerial: pet.petid,
|
||
operateResName: pet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
}
|
||
// 几率开启
|
||
else {
|
||
let min: number = 2 * pet.getSkillNum();
|
||
if (item_count < min) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `缺少[${ItemUtil.getItemName(prop)}]`,
|
||
});
|
||
return;
|
||
}
|
||
// 开启成功
|
||
let random = SKDataUtil.random(0, 10);
|
||
this.addBagItem(prop, -min, false);
|
||
if (random < 3) {
|
||
pet.openSkillGrid(data.index);
|
||
if (player) {
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "宠物格子",
|
||
operateResSerial: data.petid,
|
||
operateResName: pet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
} else {
|
||
if (player) {
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "宠物格子",
|
||
operateResSerial: data.petid,
|
||
operateResName: pet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
// 开启失败
|
||
this.send("s2c_pet_skill_grid", {
|
||
petInfo: SKDataUtil.toJson(pet.toObj(), "{}"),
|
||
type: 2
|
||
})
|
||
let info = `消耗[color=#ED4BFA][聚魂丹][/color]，开启失败，少侠再接再厉！`;
|
||
this.send_notice(info);
|
||
}
|
||
}
|
||
|
||
} else {
|
||
this.send_notice("获取宠物数据失败！")
|
||
}
|
||
|
||
}
|
||
|
||
/*
|
||
* 洗练宠物属性
|
||
*/
|
||
washProperty(data: any) {
|
||
let jll_count = this.bag_list[10118] || 0; /* 金柳露数量 */
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (data.washtaype == 1 && jll_count < 3) {
|
||
this.send_notice("金柳露数量不足！")
|
||
return;
|
||
}
|
||
if (data.washtaype == 2 && jll_count < 30) {
|
||
this.send_notice("金柳露数量不足！")
|
||
return;
|
||
}
|
||
let operationPet = null;
|
||
for (const pet of this.petList) {
|
||
if (pet.petid == data.petid) {
|
||
operationPet = pet;
|
||
break;
|
||
}
|
||
}
|
||
if (operationPet == null) {
|
||
return;
|
||
}
|
||
if (data.washtaype == 1) {
|
||
this.update_bagitem({
|
||
itemid: 10118,
|
||
count: 3,
|
||
operation: 0
|
||
});
|
||
operationPet.washProperty();
|
||
}
|
||
if (data.washtaype == 2) {
|
||
this.update_bagitem({
|
||
itemid: 10118,
|
||
count: 30,
|
||
operation: 0
|
||
});
|
||
operationPet.highWashProperty();
|
||
}
|
||
if (player) {
|
||
//cxf宠物洗练属性
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "洗练属性",
|
||
operateResSerial: data.petid,
|
||
operateResName: operationPet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
}
|
||
|
||
savePetProperty(data: any) {
|
||
let operationPet = null;
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
for (const pet of this.petList) {
|
||
if (pet.petid == data.petid) {
|
||
operationPet = pet;
|
||
break;
|
||
}
|
||
}
|
||
if (operationPet == null) {
|
||
return;
|
||
}
|
||
operationPet.saveProperty(data);
|
||
if (player) {
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "保存洗练属性",
|
||
operateResSerial: data.petid,
|
||
operateResName: operationPet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
}
|
||
// 合成召唤兽
|
||
hechengPet(data: any) {
|
||
let conf = PetMgr.shared.getPetData(data.petid);
|
||
if (conf.gettype != 1 || conf.needitem == null || conf.needitem.length < 1) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `该召唤兽[${conf.name}]未开放合成!`
|
||
});
|
||
return;
|
||
}
|
||
if (PetMgr.shared.canHeCheng(this, data.petid)) {
|
||
this.createPet(data, `召唤兽[${conf.name}]合成`);
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
} else {
|
||
this.send('s2c_notice', {
|
||
strRichText: `召唤兽[${conf.name}]无法合成!`
|
||
});
|
||
}
|
||
}
|
||
|
||
createPet(data: any, source = '', isNotice: boolean = true) {
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
PetMgr.shared.createPet(this, data.petid, (pet: any) => {
|
||
if (pet != null) {
|
||
this.addPet(pet, false);
|
||
if (this.curPet == null) {
|
||
this.changePet(pet.petid, false);
|
||
}
|
||
this.getPetlist();
|
||
if (this.getpet != 1) {
|
||
DB.getPet(this.roleid);
|
||
this.getpet = 1;
|
||
}
|
||
SKLogger.debug(`玩家[${this.roleid}:s${this.name}]获得召唤兽[${pet.petid}:${pet.name}]${source}`);
|
||
if (player) {
|
||
//cxf合成宠物
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "合成宠物",
|
||
operateResSerial: pet.petid,
|
||
operateResName: pet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
if (isNotice) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `恭喜您获得了${pet.name}`
|
||
});
|
||
}
|
||
} else {
|
||
this.send_notice("获取宠物信息失败！");
|
||
}
|
||
|
||
});
|
||
}
|
||
|
||
addPet(pet: any, issend = true) {
|
||
pet.setOwner(this);
|
||
this.petList.push(pet);
|
||
if (issend) {
|
||
this.getPetlist();
|
||
}
|
||
}
|
||
|
||
getPetByID(petid: any) {
|
||
for (let pet of this.petList) {
|
||
if (pet.petid == petid) {
|
||
return pet;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
sendPetList() {
|
||
if (this.offline) {
|
||
return;
|
||
}
|
||
if (this.loaded == false) {
|
||
return;
|
||
}
|
||
this.getPetlist();
|
||
}
|
||
// 获得召唤兽列表
|
||
getPetlist(data?: any) {
|
||
let listInfo: any = {};
|
||
listInfo.curid = 0;
|
||
if (this.curPet != null) {
|
||
listInfo.curid = this.curPet.petid;
|
||
}
|
||
listInfo.list = [];
|
||
let repeat = SKDataUtil.removeRepeat(this.petList, "petid");
|
||
if (repeat.length > 0) {
|
||
for (let pet of repeat) {
|
||
SKLogger.warn(`玩家:[${this.roleid}:${this.name}]召唤兽[${pet.petid}:${pet.name}:${pet.state}]重复`);
|
||
}
|
||
}
|
||
for (let pet of this.petList) {
|
||
let conf = PetMgr.shared.getPetData(pet.dataid);
|
||
// if (pet.name != conf.name) {
|
||
// SKLogger.warn(`玩家:[${this.roleid}:${this.name}]召唤兽[${pet.petid}:${pet.name}]修复dataid:${pet.name}->${conf.name}`);
|
||
// pet.name = conf.name;
|
||
// }
|
||
if (pet.resid != conf.resid) {
|
||
SKLogger.warn(`玩家:[${this.roleid}:${this.name}]召唤兽[${pet.petid}:${pet.name}]修复resid:${pet.resid}->${conf.resid}`);
|
||
pet.resid = conf.resid;
|
||
}
|
||
listInfo.list.push(pet.toObj());
|
||
}
|
||
this.send('s2c_get_petlist', listInfo);
|
||
SKLogger.debug(`发送玩家[${this.roleid}:${this.name}]召唤兽列表`);
|
||
}
|
||
|
||
updatePetPoint(data: any) {
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (!data) {
|
||
return;
|
||
}
|
||
let sumpoint = 0;
|
||
let addpoint: any = {};
|
||
if (data.type > 1) {
|
||
addpoint = SKDataUtil.jsonBy(data.info);
|
||
for (let key in addpoint) {
|
||
sumpoint += addpoint[key];
|
||
}
|
||
}
|
||
let operationPet = null;
|
||
for (let pet of this.petList) {
|
||
if (pet.petid == data.petid) {
|
||
operationPet = pet;
|
||
break;
|
||
}
|
||
}
|
||
if (operationPet == null) {
|
||
return;
|
||
}
|
||
if (data.type == 0) {
|
||
for (const key in operationPet.ppoint) {
|
||
operationPet.ppoint[key] = 0;
|
||
}
|
||
} else if (data.type == 1) {
|
||
for (const key in operationPet.dpoint) {
|
||
operationPet.dpoint[key] = 0;
|
||
}
|
||
} else if (data.type == 2) {
|
||
let curpoint = 0;
|
||
for (const key in operationPet.ppoint) {
|
||
curpoint += operationPet.ppoint[key];
|
||
}
|
||
if (sumpoint + curpoint > operationPet.level * 4) {
|
||
return;
|
||
}
|
||
for (const key in addpoint) {
|
||
if (!operationPet.ppoint[key]) {
|
||
operationPet.ppoint[key] = 0;
|
||
}
|
||
operationPet.ppoint[key] += addpoint[key];
|
||
}
|
||
} else if (data.type == 3) {
|
||
let curpoint = 0;
|
||
for (let key in operationPet.dpoint) {
|
||
curpoint += operationPet.dpoint[key];
|
||
}
|
||
if (sumpoint + curpoint > PetPracticeMgr.shared.GetLevelPoint(operationPet.relive, operationPet.xlevel)) { //超过最大修炼点
|
||
return;
|
||
}
|
||
for (let key in addpoint) {
|
||
if (!operationPet.dpoint[key]) {
|
||
operationPet.dpoint[key] = 0;
|
||
}
|
||
operationPet.dpoint[key] += addpoint[key];
|
||
}
|
||
}
|
||
operationPet.calculateAttribute();
|
||
if (player) {
|
||
//cxf宠物加点
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "宠物加点",
|
||
operateResSerial: operationPet.petid,
|
||
operateResName: operationPet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
this.send('s2c_update_pet', {
|
||
info: operationPet.toObj()
|
||
});
|
||
// 如果在队伍需要刷新队伍信息
|
||
this.refresh_team_data();
|
||
}
|
||
|
||
petLockSkill(petid: any, skillid: any) {
|
||
// this.send('s2c_notice', {
|
||
// strRichText: '功能暂未开放'
|
||
// });
|
||
// return;
|
||
|
||
let pet = this.getPetByID(petid);
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (!pet) {
|
||
return;
|
||
}
|
||
let skillinfo = pet.skill_list[skillid];
|
||
if (!skillinfo) {
|
||
return;
|
||
}
|
||
if (skillinfo.lck == 1) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '技能已经被锁定，仙玉不变'
|
||
});
|
||
return;
|
||
}
|
||
|
||
let n = pet.getLockedSkillNum();
|
||
let cost = Math.pow(2, n) * GameUtil.petLockSkillJade;
|
||
let strErr = this.CostFee(1, cost, '宠物技能锁定');
|
||
if (strErr != '') {
|
||
this.send('s2c_notice', {
|
||
strRichText: strErr
|
||
});
|
||
return;
|
||
}
|
||
|
||
pet.lockSkill(skillid);
|
||
if (player) {
|
||
//cxf宠物技能加锁
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "宠物技能加锁",
|
||
operateResSerial: pet.petid,
|
||
operateResName: pet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
}
|
||
|
||
petForgetSkill(petid: any, skillid: any) {
|
||
let pet = this.getPetByID(petid);
|
||
if (pet) {
|
||
pet.forgetSkill(skillid);
|
||
//cxf宠物遗忘技能
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "宠物遗忘技能",
|
||
operateResSerial: pet.petid,
|
||
operateResName: pet.name,
|
||
operateContent: SKDataUtil.toJson(pet.toObj(), "{}")
|
||
})
|
||
}
|
||
}
|
||
|
||
petShenShouSkill(petid: any, skillid: any) {
|
||
let pet = this.getPetByID(petid);
|
||
if (!pet) {
|
||
return;
|
||
}
|
||
if (pet.grade < GameUtil.petGrade.Shen) {
|
||
return;
|
||
}
|
||
// if (skillid == GameUtil.skillIds.RuHuTianYi) {
|
||
// this.send('s2c_notice', {
|
||
// strRichText: '该技能稍后开放！'
|
||
// });
|
||
// return;
|
||
// }
|
||
|
||
let strErr = this.CostFee(GameUtil.goldKind.Money, 50000000);
|
||
if (strErr != '') {
|
||
this.send('s2c_notice', {
|
||
strRichText: strErr
|
||
});
|
||
return;
|
||
}
|
||
|
||
pet.changeShenShouSkill(skillid);
|
||
|
||
this.send('s2c_pet_changeSskill', {
|
||
errorcode: MsgCode.SUCCESS,
|
||
petid: petid,
|
||
skillid: skillid,
|
||
});
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "改变神兽技能",
|
||
operateResSerial: pet.petid,
|
||
operateResName: pet.name,
|
||
operateContent: SKDataUtil.toJson(pet.toObj(), "{}")
|
||
})
|
||
}
|
||
|
||
levelReward(level: any) {
|
||
|
||
if (this.level_reward.split(':').indexOf(level + '') != -1)
|
||
return;
|
||
let level_reward = GameUtil.require_ex('../../conf/prop_data/prop_level.json');
|
||
let item = level_reward[level];
|
||
if (item) {
|
||
if (this.examine(item.relive, level)) {
|
||
if (this.level_reward == '') {
|
||
this.level_reward += level;
|
||
} else {
|
||
this.level_reward += ':' + level;
|
||
}
|
||
|
||
let reward_list = item.reward_item.split(';');
|
||
for (let item of reward_list) {
|
||
let reward = item.split(':');
|
||
this.addItem(reward[0], reward[1], false, '等级奖励');
|
||
}
|
||
let send_data = {
|
||
level: level,
|
||
};
|
||
this.send('s2c_level_reward', send_data);
|
||
}
|
||
}
|
||
}
|
||
|
||
examine(relive: any, level: any): boolean {
|
||
if (this.relive > relive) {
|
||
return true
|
||
} else {
|
||
if (this.level >= level) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
changePet(petid: any, issend = true) {
|
||
for (const pet of this.petList) {
|
||
if (pet.petid == petid) {
|
||
this.curPet = pet;
|
||
this.curPetId = petid;
|
||
// 刷新队伍信息
|
||
this.refresh_team_data();
|
||
if (issend) {
|
||
this.send('s2c_change_pet', {
|
||
curid: this.curPet.petid
|
||
});
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
delPet(data: any) {
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (this.curPet != null && this.curPet.petid == data.petid) {
|
||
this.curPet.state = 0;
|
||
this.curPet = null;
|
||
}
|
||
for (let index = 0; index < this.petList.length; index++) {
|
||
let pet: Pet = this.petList[index];
|
||
if (pet.petid == data.petid) {
|
||
pet.state = 0;
|
||
this.petList.splice(index, 1);
|
||
for (let skillid in pet.skill_list) {
|
||
if (Number(skillid) == 2110 || Number(skillid) == 2010) {
|
||
PetSupport.shared.deletePet(this.roleid, pet.petid);
|
||
}
|
||
}
|
||
DB.delPet(pet.petid, this.roleid, (code: number) => {
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]放生召唤兽[${pet.petid}:${pet.name}]${code == MsgCode.SUCCESS ? "成功" : "失败"}`);
|
||
if (player) {
|
||
//cxf宠物放生
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "宠物放生",
|
||
operateResSerial: pet.petid,
|
||
operateResName: pet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
})
|
||
break;
|
||
}
|
||
}
|
||
let params: any = {};
|
||
if (this.curPet == null) {
|
||
params.curid = -1;
|
||
} else {
|
||
params.curid = this.curPet.petid;
|
||
}
|
||
params.delid = data.petid;
|
||
this.send('s2c_del_pet', params);
|
||
}
|
||
|
||
/**
|
||
* type 装备类型，0:新手装备，1:高级装备，2:神兵，3:仙器 4:翅膀, 5:配饰
|
||
* index 装备位置：
|
||
* resid 装备编号
|
||
* roleid 角色id
|
||
* @param data
|
||
*/
|
||
addEquip(data: any) {
|
||
|
||
if (this.getBagItemAllKindNum() >= this.bagKindNum) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `背包已满`
|
||
});
|
||
return;
|
||
}
|
||
let equipAttr = EquipMgr.shared.makeEquipAttr(data);
|
||
|
||
if (data.type == EEquipType.BALDRIC) {
|
||
equipAttr.BaseAttr = '[]';
|
||
}
|
||
if (!equipAttr) {
|
||
SKLogger.warn(`玩家[${this.roleid}:${this.name}]加装备失败${data.resid}`);
|
||
this.send('s2c_operation_result', {
|
||
code: 0,
|
||
});
|
||
return;
|
||
}
|
||
let equip = new Equip(equipAttr, this);
|
||
this.addEquipList(equip);
|
||
this.equipObjs[equip.EquipID] = equip;
|
||
EquipMgr.shared.addEquip(equip);
|
||
// this.send('s2c_bagitem', {
|
||
// info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
// });
|
||
this.sendEquipList();
|
||
let equipInfo = equip.toObj();
|
||
let params = {
|
||
equip: SKDataUtil.toJson(equipInfo, "{}")
|
||
};
|
||
this.send("s2c_equip_info", params);
|
||
this.send('s2c_notice', {
|
||
strRichText: `恭喜你获得了[img]ui://main_ui/${equipInfo.Shape}[/img][color=#E96E29][${equipInfo.EName}][/color]`
|
||
});
|
||
/* 神兵 仙器广播 */
|
||
if (data.type > 1) {
|
||
if (data.type == 2) {
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]获得神兵[${equipAttr.EquipID}:${equipInfo.EName}]`);
|
||
} else if (data.type == 3) {
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]获得仙器[${equipAttr.EquipID}:${equipInfo.EName}]`);
|
||
}
|
||
if (data.type == 3 && equipInfo.Grade == 1) {
|
||
} else {
|
||
let strRichText = `<color=#00ff00 > ${this.name}</c > <color=#ffffff > 获得了</c ><color=#0fffff > ${equipInfo.EDesc}:${equipInfo.EName}</color >，<color=#ffffff > 真是太幸运了</c >`;
|
||
PlayerMgr.shared.broadcast('s2c_screen_msg', {
|
||
strRichText: strRichText,
|
||
bInsertFront: 0
|
||
});
|
||
}
|
||
}
|
||
DB.createEquip(this.roleid, equipInfo, (code: MsgCode) => {
|
||
if (code != MsgCode.SUCCESS) {
|
||
SKLogger.debug(`存档:玩家[${this.roleid}:${this.name}]加入装备属性[${equipAttr}]失败!`);
|
||
}
|
||
});
|
||
//cxf合成装备
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "合成装备",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
}
|
||
|
||
/**
|
||
* type 类型：6 法宝
|
||
* index 装备位置：
|
||
* roleid 角色id
|
||
* @param data
|
||
*/
|
||
addMagicWeapon(data: any) {
|
||
|
||
if (this.getBagItemAllKindNum() >= this.bagKindNum) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `背包已满`
|
||
});
|
||
return;
|
||
}
|
||
let magicWeapon = MagicWeaponMgr.shared.getMagicWeaponAttr(data);
|
||
if (!magicWeapon) {
|
||
SKLogger.warn(`玩家[${this.roleid}:${this.name}]加装备失败${data.resid}`);
|
||
this.send('s2c_operation_result', {
|
||
code: 0,
|
||
});
|
||
return;
|
||
}
|
||
|
||
let weapon = new MagicWeapon(magicWeapon, this);
|
||
this.addMagicWeaponList(weapon);
|
||
this.magicWeaponObjs[weapon.efId] = weapon;
|
||
|
||
MagicWeaponMgr.shared.addMagicWeapon(weapon);
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
this.sendMagicWeaponList();
|
||
let weaponInfo = weapon.toObj();
|
||
let params = {
|
||
weapon: SKDataUtil.toJson(weaponInfo, "{}")
|
||
};
|
||
this.send("s2c_magic_weapon", params);
|
||
this.send('s2c_notice', {
|
||
strRichText: `恭喜您获得了${SKDataUtil.noToChinese(weaponInfo.efType)}阶法宝:${weaponInfo.efName}`
|
||
});
|
||
//
|
||
DB.createMagicWeapon(this.roleid, weaponInfo, (code: MsgCode) => {
|
||
if (code != MsgCode.SUCCESS) {
|
||
SKLogger.info(`存档:玩家[${this.roleid}:${this.name}]加入法宝属性[${weaponInfo}]失败!`);
|
||
}
|
||
});
|
||
|
||
}
|
||
|
||
createEquip(data: any) {
|
||
if (this.getBagItemAllKindNum() >= this.bagKindNum) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `背包已满`
|
||
});
|
||
return;
|
||
}
|
||
if (data.is > 0 || data.is == undefined) {
|
||
if (data.type == 2) {
|
||
if (!this.bag_list[10408] || this.bag_list[10408] < 50) {
|
||
return; //神兵碎片不足
|
||
}
|
||
this.bag_list[10408] -= 50;
|
||
SKLogger.debug(`玩家[${this.name}${this.roleid}]消耗 神兵碎片 50 个`);
|
||
} else if (data.type == 3) {
|
||
if (!this.bag_list[10406] || this.bag_list[10406] < 40) {
|
||
return; //八荒遗风不足
|
||
}
|
||
this.bag_list[10406] -= 40;
|
||
SKLogger.debug(`玩家[${this.name}${this.roleid}]消耗 八荒遗风 40 个`);
|
||
}
|
||
} else {
|
||
data.type = EEquipType.XianQi;
|
||
}
|
||
this.addEquip(data);
|
||
}
|
||
|
||
sendEquipList() {
|
||
let listInfo: any = {};
|
||
listInfo.use = {};
|
||
listInfo.score = 0;
|
||
listInfo.list = [];
|
||
listInfo.info = {};
|
||
for (let equip of this.currentEquips) {
|
||
let full = equip.getFullData();
|
||
if (full) {
|
||
listInfo.score += Number(full.BaseScore);
|
||
listInfo.use[equip.EIndex] = equip.EquipID;
|
||
listInfo.info[equip.EquipID] = equip.getSendInfo();
|
||
PaiHangMgr.shared.updateEquipRank(this.roleid, this.sex, this.name, equip.EIndex, this.level, full.BaseScore, this.relive, equip.name);
|
||
}
|
||
}
|
||
for (let equip of this.listEquips) {
|
||
listInfo.list.push(equip.EquipID);
|
||
listInfo.info[equip.EquipID] = equip.getSendInfo();
|
||
}
|
||
// 更新装备评价排行榜
|
||
PaiHangMgr.shared.updateEquipRankData(this.roleid, this.sex, this.name, this.race, this.level, listInfo.score, this.relive);
|
||
this.send("s2c_equip_list", {
|
||
list: SKDataUtil.toJson(listInfo, "{}")
|
||
});
|
||
}
|
||
|
||
sendMagicWeaponList() {
|
||
let listInfo: any = {};
|
||
listInfo.use = {};
|
||
listInfo.score = 0;
|
||
listInfo.list = [];
|
||
listInfo.info = {};
|
||
// 获取穿戴的法宝
|
||
for (let magicWeapon of this.currentMagicWeapons) {
|
||
let full = magicWeapon.getSendInfo();
|
||
if (full) {
|
||
listInfo.score += Number(full.BaseScore);
|
||
listInfo.use[magicWeapon.efIndex] = magicWeapon.efId;
|
||
listInfo.info[magicWeapon.efId] = full;
|
||
}
|
||
}
|
||
for (let magicWeapon of this.listMagicWeapons) {
|
||
listInfo.list.push(magicWeapon.efId);
|
||
listInfo.info[magicWeapon.efId] = magicWeapon.getSendInfo;
|
||
}
|
||
// 更新法宝评价排行榜
|
||
// PaiHangMgr.shared.updateEquipRankData(this.roleid, this.sex, this.name, this.race, this.level, listInfo.score, this.relive);
|
||
this.send("s2c_magic_weapon_list", {
|
||
list: SKDataUtil.toJson(listInfo, "{}")
|
||
});
|
||
}
|
||
|
||
getLockerEquipInfo() {
|
||
let rInfo: any = {};
|
||
rInfo.locker = [];
|
||
rInfo.list = [];
|
||
for (let equip of this.listEquips) {
|
||
rInfo.list.push(equip.getSendInfo());
|
||
}
|
||
for (let equip of this.lockerEquips) {
|
||
rInfo.locker.push(equip.getSendInfo());
|
||
}
|
||
return rInfo;
|
||
}
|
||
// 发送装备信息
|
||
sendEquipInfo(equipId: string) {
|
||
if (this.equipObjs[equipId]) {
|
||
let equip: Equip = this.equipObjs[equipId];
|
||
let params = {
|
||
equip: SKDataUtil.toJson(equip.toObj(), "{}")
|
||
};
|
||
this.send("s2c_equip_info", params);
|
||
}
|
||
}
|
||
// 获取属性评分
|
||
attributeScore(data: any) {
|
||
let score: number = 0;
|
||
// 判断装备是否存在
|
||
if (this.equipObjs[data.equipId]) {
|
||
// 获取装备
|
||
let equip: Equip = this.equipObjs[data.equipId];
|
||
let info = equip.toObj();
|
||
// 配饰属性评分
|
||
if (EEquipType.BALDRIC == info.EquipType) {
|
||
score = GameUtil.getBasicsListAttrScore(info.Race, info.Sex, info.BaseAttr)
|
||
}
|
||
// 翅膀属性评分
|
||
else if (EEquipType.WING == info.EquipType) {
|
||
score = GameUtil.getBasicsListAttrScore(info.Race, info.Sex, info.LianhuaAttr)
|
||
}
|
||
// 装备属性评分
|
||
else {
|
||
// 炼化
|
||
if (data.type == 0) {
|
||
score = GameUtil.getBasicsListAttrScore(info.Race, info.Sex, SKDataUtil.jsonBy(info.LianhuaAttr))
|
||
}
|
||
// 重铸
|
||
else {
|
||
score = GameUtil.calculate(JSON.parse(info.BaseAttr), info.Race, info.Sex, true);
|
||
}
|
||
}
|
||
}
|
||
// 返回属性评分
|
||
this.send('s2c_attribute_score', {
|
||
attributeScore: score
|
||
});
|
||
}
|
||
|
||
changeWeapon(weapon: any) {
|
||
if (weapon) {
|
||
let fullEquipData = weapon.getFullData(this.roleid);
|
||
let weaponstr = SKDataUtil.toJson({
|
||
gemcnt: fullEquipData.GemCnt,
|
||
type: fullEquipData.EquipType,
|
||
level: fullEquipData.Grade
|
||
}, "{}");
|
||
this.send('s2c_change_weapon', {
|
||
weapon: weaponstr
|
||
});
|
||
} else {
|
||
this.send('s2c_change_weapon', {
|
||
weapon: ''
|
||
});
|
||
}
|
||
}
|
||
|
||
upgradeEquip(data: any) {
|
||
let equip = this.equipObjs[data.equipid];
|
||
if (equip == null) {
|
||
return;
|
||
}
|
||
if (equip.EquipType > EEquipType.HIGH) {
|
||
return;
|
||
}
|
||
let itemid = 10405;
|
||
if (this.bag_list[itemid] && this.bag_list[itemid] > 0) {
|
||
let up = equip.upgrade(data);
|
||
if (!up) return; //升级失败
|
||
this.addItem(itemid, -1, false, '装备升级消耗');
|
||
if (this.bag_list[itemid] <= 0) {
|
||
delete this.bag_list[itemid];
|
||
}
|
||
} else { //没有盘古精铁
|
||
return;
|
||
}
|
||
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
this.sendEquipInfo(data.equipid);
|
||
|
||
if (equip.EIndex == 1 && this.currentEquips.indexOf(equip) != -1) {
|
||
this.changeWeapon(equip);
|
||
}
|
||
this.send('s2c_notice', {
|
||
strRichText: `升级成功`
|
||
});
|
||
}
|
||
|
||
shenbignUpgrade(data: any) {
|
||
let equip = this.equipObjs[data.equipid];
|
||
if (equip == null) {
|
||
return;
|
||
}
|
||
|
||
if (equip.EquipType > EEquipType.ShenBing) {
|
||
return;
|
||
}
|
||
|
||
if (data.use > 0 && this.equipObjs[data.use] == null) return;
|
||
if (equip.canUpgrade() == false) {
|
||
return;
|
||
}
|
||
// 是否失败
|
||
if (equip.checkUpgradeBroke() == false) {
|
||
if (equip.Grade == 1) {
|
||
this.delEquip(data.equipid, true, '神兵升级破碎');
|
||
} else {
|
||
this.delEquip(data.use, true, '神兵升级破碎');
|
||
}
|
||
|
||
this.sendEquipList();
|
||
// 神兵破碎 给 神兵碎片
|
||
this.addItem(10408, 5, false, '神兵升级破碎');
|
||
this.send('s2c_notice', {
|
||
strRichText: `神兵升级失败`
|
||
});
|
||
} else {
|
||
equip.upgrade(data);
|
||
this.delEquip(data.use, true, '神兵升级');
|
||
this.sendEquipList();
|
||
this.sendEquipInfo(data.equipid);
|
||
|
||
if (equip.EIndex == 1 && this.currentEquips.indexOf(equip) != -1) {
|
||
this.changeWeapon(equip);
|
||
}
|
||
this.send('s2c_notice', {
|
||
strRichText: `神兵升级成功`
|
||
});
|
||
}
|
||
}
|
||
|
||
xianqiUpGrade(data: any) {
|
||
let equip: Equip = this.equipObjs[data.equipid];
|
||
if (equip == null || equip == undefined) {
|
||
return;
|
||
}
|
||
if (equip.Grade == 1) { //一阶升阶需要3个
|
||
if ((data.use1 > 0 && this.equipObjs[data.use1] == null) || (data.use2 > 0 && this.equipObjs[data.use2] == null)) {
|
||
this.send_notice("数量不够")
|
||
return;
|
||
}
|
||
if (equip.pos == undefined) {
|
||
equip.pos = 0;
|
||
}
|
||
if (this.equipObjs[data.use1].pos == undefined) {
|
||
this.equipObjs[data.use1].pos = 0;
|
||
}
|
||
if (this.equipObjs[data.use2].pos == undefined) {
|
||
this.equipObjs[data.use2].pos = 0;
|
||
}
|
||
} else {//大于一阶需要两个
|
||
if ((data.use1 > 0 && this.equipObjs[data.use1] == undefined) || data.use1 <= 0) {
|
||
this.send_notice("数量不够")
|
||
return;
|
||
}
|
||
if (equip.pos == undefined) {
|
||
equip.pos = 0;
|
||
}
|
||
if (this.equipObjs[data.use1].pos == undefined) {
|
||
this.equipObjs[data.use1].pos = 0;
|
||
}
|
||
if (this.equipObjs[data.use1].pos == undefined) {
|
||
this.equipObjs[data.use1].pos = 0;
|
||
}
|
||
}
|
||
let up = equip.canUpgrade();
|
||
if (!up) {
|
||
SKLogger.warn(`仙器[${equip.name}(${equip.EquipID})]不能升阶!`);
|
||
return;
|
||
} else if (equip.pos == 2 || this.equipObjs[data.use1].pos == 2 || (this.equipObjs[data.use2] != null && this.equipObjs[data.use2].pos == 2)) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `已穿戴装备[${equip.EquipID}:${equip.name}]不能升阶`
|
||
});
|
||
return;
|
||
} else if (equip.EIndex != this.equipObjs[data.use1].EIndex && (this.equipObjs[data.use2] != null && equip.EIndex != this.equipObjs[data.use2].EIndex)) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `不同类型装备不能升阶`
|
||
});
|
||
return;
|
||
} else if (equip.pos == 4 || this.equipObjs[data.use1].pos == 4 || (this.equipObjs[data.use2] != null && this.equipObjs[data.use2].pos == 4)) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `仓库中装备不能升阶`
|
||
});
|
||
return;
|
||
}
|
||
this.delEquip(data.use1, true, `仙器升阶`);
|
||
this.delEquip(data.use2, true, `仙器升阶`);
|
||
equip.upgrade(data);
|
||
this.sendEquipList();
|
||
this.sendEquipInfo(data.equipid);
|
||
if (equip.EIndex == 1 && this.currentEquips.indexOf(equip) != -1) {
|
||
this.changeWeapon(equip);
|
||
}
|
||
this.send('s2c_notice', {
|
||
strRichText: `仙器:${equip.name}升${equip.Grade}阶成功`
|
||
});
|
||
|
||
//cxf仙器升阶
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "仙器升阶",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
}
|
||
|
||
delEquip(equipid: any, uninlay = true, source = '') {
|
||
if (!equipid || equipid <= 0) {
|
||
return;
|
||
}
|
||
let delequip = null;
|
||
for (let index = 0; index < this.currentEquips.length; index++) { //已经装备的不能删，所以注释掉以下代码
|
||
if (this.currentEquips[index].EquipID == equipid) {
|
||
delequip = this.currentEquips[index];
|
||
this.currentEquips.splice(index, 1);
|
||
break;
|
||
}
|
||
}
|
||
for (let index = 0; index < this.listEquips.length; index++) {
|
||
if (this.listEquips[index].EquipID == equipid) {
|
||
delequip = this.listEquips[index];
|
||
this.listEquips.splice(index, 1);
|
||
break;
|
||
}
|
||
}
|
||
if (delequip != null) {
|
||
delequip.pos = EEquipPos.UNKNOW;
|
||
let equipfulldata = delequip.getFullData();
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]删除装备[${delequip.EquipID}:${equipfulldata.EName}]:${source}]`);
|
||
if (uninlay) {
|
||
this.unInLay(delequip);
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
}
|
||
delequip.state = 0;
|
||
delequip.save();
|
||
delete this.equipObjs[delequip.EquipID];
|
||
EquipMgr.shared.delEquip(delequip.EquipID);
|
||
this.schemeMgr.deleteCurEquips(delequip.EquipID);
|
||
}
|
||
}
|
||
|
||
updateEquip(data: any) {
|
||
if (!data) {
|
||
return;
|
||
}
|
||
let ret = false;
|
||
if (data.operation == 0) {
|
||
this.delEquip(data.equipid, true, '装备删除');
|
||
this.sendEquipList();
|
||
return;
|
||
} else if (data.operation == 1 && this.equipObjs[data.equipid]) {
|
||
//装备
|
||
let equip: Equip = this.equipObjs[data.equipid];
|
||
let fullEquipData = equip.getFullData(this.roleid);
|
||
let flag = true
|
||
if (fullEquipData.OwnerRoleId > 0 && fullEquipData.OwnerRoleId != this.resid) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色不匹配，不能使用！'
|
||
});
|
||
return;
|
||
} else if (fullEquipData.Sex != 9 && fullEquipData.Sex != this.sex) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色不匹配，不能使用！'
|
||
});
|
||
return;
|
||
}
|
||
if (Array.isArray(fullEquipData.Race)) {//如果是数组，多种族通用
|
||
for (let race of fullEquipData.Race) {
|
||
if (race == this.race) {
|
||
flag = false;
|
||
}
|
||
}
|
||
if (flag) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色不匹配，不能使用！'
|
||
});
|
||
return;
|
||
}
|
||
} else if (fullEquipData.Race != 9 && fullEquipData.Race != this.race) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色不匹配，不能使用！'
|
||
});
|
||
return;
|
||
}
|
||
if (fullEquipData.NeedGrade > this.level || fullEquipData.NeedRei > this.relive) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色等级不足，尚不能使用！'
|
||
});
|
||
return;//转生或等级不符合
|
||
}
|
||
if (fullEquipData.Shuxingxuqiu) { //属性需求不符合
|
||
for (const key in fullEquipData.Shuxingxuqiu) {
|
||
if (this.getAttr1(key) < fullEquipData.Shuxingxuqiu[key]) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色属性不足，尚不能使用！'
|
||
});
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
for (let index = 0; index < this.currentEquips.length; index++) {
|
||
let item = this.currentEquips[index];
|
||
if (item.EIndex == equip.EIndex) {
|
||
item.pos = EEquipPos.BAG;
|
||
this.addEquipList(item);
|
||
this.currentEquips.splice(index, 1);
|
||
}
|
||
}
|
||
equip.pos = EEquipPos.USE;
|
||
this.currentEquips.push(equip);
|
||
for (let index = 0; index < this.listEquips.length; index++) {
|
||
let item = this.listEquips[index];
|
||
if (item.EquipID == data.equipid) {
|
||
this.listEquips.splice(index, 1);
|
||
break;
|
||
}
|
||
}
|
||
this.sendEquipList();
|
||
if (equip.EIndex == 1) {
|
||
this.changeWeapon(equip);
|
||
} else if (equip.EIndex == 6) {
|
||
let conf = EquipMgr.shared.getXianQiBy(equip.Type);
|
||
this.wingId = conf.Shape;
|
||
}
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]穿上装备[${equip.name}]`);
|
||
ret = true;
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
} else if (data.operation == 2 && this.equipObjs[data.equipid]) {
|
||
//卸下
|
||
let equip = this.equipObjs[data.equipid];
|
||
let finduse = false;
|
||
for (let index = 0; index < this.currentEquips.length; index++) {
|
||
if (this.currentEquips[index].EquipID == data.equipid) {
|
||
this.currentEquips[index].pos = EEquipPos.BAG;
|
||
this.currentEquips.splice(index, 1);
|
||
finduse = true;
|
||
break;
|
||
}
|
||
}
|
||
if (finduse) {
|
||
this.addEquipList(equip);
|
||
this.sendEquipList();
|
||
if (equip.EIndex == 1) {
|
||
this.changeWeapon(null);
|
||
} else if (equip.EIndex == 6) {
|
||
this.wingId = 0;
|
||
}
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]卸下装备[${equip.name}]`);
|
||
ret = true;
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
}
|
||
}
|
||
if (ret) {
|
||
this.calculateAttr();
|
||
//this.send('s2c_player_data', this.getData());
|
||
//将通过背包修改的装备信息，同步修改方案装备信息
|
||
let curEqupsData: any = {}
|
||
this.currentEquips.forEach((e: any) => {
|
||
curEqupsData[e.EIndex] = e.EquipID;
|
||
});
|
||
if ((data.operation == 1 || data.operation == 2) && this.schemeMgr) {
|
||
this.schemeMgr.syncSchemeEquips(curEqupsData);
|
||
}//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
} else {
|
||
this.send('s2c_operation_result', {
|
||
code: MsgCode.FAILED
|
||
});
|
||
}
|
||
}
|
||
// 拆卸
|
||
unInLay(equip: Equip) {
|
||
if (equip == null) {
|
||
return;
|
||
}
|
||
let itemList = equip.getGemList();
|
||
for (let itemId in itemList) {
|
||
if (itemList[itemId] <= 0) {
|
||
continue;
|
||
}
|
||
if (this.bag_list[itemId] == null) {
|
||
this.bag_list[itemId] = itemList[itemId];
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]装备[${equip.name}]拆卸返回道具[${ItemUtil.getItemName(itemId)}]`);
|
||
} else {
|
||
this.bag_list[itemId] += itemList[itemId];
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]装备[${equip.name}]拆卸返回道具[${ItemUtil.getItemName(itemId)}]${itemList[itemId]}个`);
|
||
}
|
||
}
|
||
equip.GemCnt = 0;
|
||
// 刷新装备
|
||
this.sendEquipList();
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]装备拆卸[${equip.name}]`);
|
||
}
|
||
|
||
// 宝石镶嵌
|
||
equipInlay(data: any) {
|
||
let equip: Equip = this.equipObjs[data.equipid];
|
||
if (equip == null) {
|
||
SKLogger.warn(`玩家[${this.roleid}:${this.name}]宝石镶嵌找不到装备${data.equipid}`);
|
||
return;
|
||
}
|
||
if (data.operation == 0) {
|
||
this.unInLay(equip);
|
||
if (equip.EIndex == 1 && this.currentEquips.indexOf(equip) != -1) {
|
||
this.changeWeapon(equip);
|
||
}
|
||
} else {
|
||
let fullData = equip.getFullData();
|
||
if (fullData) {
|
||
let maxEmbed = fullData.MaxEmbedGemCnt;
|
||
if (equip.GemCnt >= maxEmbed) {
|
||
this.send_notice(`您的装备${equip.name}已经镶嵌到顶级!`);
|
||
return;
|
||
}
|
||
}
|
||
let itemid = equip.getInlayGemID();
|
||
let conf = ItemUtil.getItemData(itemid);
|
||
if (conf == null) {
|
||
SKLogger.warn(`玩家[${this.roleid}:${this.name}]装备[${equip.name}]宝石镶嵌找不到道具[${itemid}]定义!`);
|
||
this.send_notice(`您的装备${equip.name}]无法镶嵌宝石!`);
|
||
return;
|
||
}
|
||
if (this.bag_list[itemid] && this.bag_list[itemid] > 0) {
|
||
this.bag_list[itemid] -= 1;
|
||
if (this.bag_list[itemid] <= 0) {
|
||
delete this.bag_list[itemid];
|
||
}
|
||
equip.GemCnt += 1;
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]装备[${equip.name}]镶嵌宝石[${conf.name}]成功!`);
|
||
equip.calculateAttribute();
|
||
if (equip.EIndex == 1 && this.currentEquips.indexOf(equip) != -1) {
|
||
this.changeWeapon(equip);
|
||
}
|
||
} else {
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]装备[${equip.name}]镶嵌,缺少[${conf.name}]!`);
|
||
this.send_notice(`您的装备${equip.name}]无法镶嵌宝石:[${conf.name}]数量不足!`);
|
||
return;
|
||
}
|
||
}
|
||
equip.calculateAttribute();
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
this.sendEquipInfo(data.equipid);
|
||
this.calculateAttr();
|
||
this.send('s2c_player_data', this.getData());
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
// 刷新装备
|
||
this.sendEquipList();
|
||
//cxf宝石镶嵌
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "宝石镶嵌",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
}
|
||
|
||
// 装备炼化 (装备和翅膀)
|
||
equipRefine(data: any) {
|
||
let equip = this.equipObjs[data.equipid];
|
||
if (equip == null) {
|
||
return;
|
||
}
|
||
if (data.refine) {
|
||
let refine = SKDataUtil.jsonBy(data.refine);
|
||
equip.refine = refine // 选择替换的属性， 其他炼化为空
|
||
}
|
||
if (data.operation == 1) {// 0获取，1确认
|
||
if (equip.refine == null) {
|
||
return;
|
||
}
|
||
equip.LianhuaAttr = equip.refine.slice(0);
|
||
equip.refine = null;
|
||
equip.calculateAttribute();
|
||
this.sendEquipInfo(data.equipid);
|
||
this.calculateAttr();
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
this.send_notice(`炼化成功`);
|
||
// 刷新装备
|
||
this.sendEquipList();
|
||
//cxf装备炼化
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "装备炼化",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
} else {
|
||
// 如果是翅膀,则需要10个翅膀精华10411练化一次
|
||
if (equip.EIndex == 6) {
|
||
let needitem = 10411;
|
||
if (this.bag_list[needitem] && this.bag_list[needitem] > 1) {
|
||
this.bag_list[needitem] -= 10;
|
||
if (this.bag_list[needitem] <= 0) {
|
||
delete this.bag_list[needitem];
|
||
}
|
||
} else { //
|
||
this.send('s2c_notice', {
|
||
strRichText: `炼化材料不足，至少需要10个翅膀精华`
|
||
});
|
||
return;
|
||
}
|
||
} else {
|
||
let needitem = 10404;
|
||
if (data.level == 3) { needitem = 10410; }//超级九彩云龙珠
|
||
//if (data.level == 4) { needitem = 10411; }//翅膀精华
|
||
if (this.bag_list[needitem]) {
|
||
if (needitem == 10404 && this.bag_list[needitem] > 30) {
|
||
this.bag_list[needitem] -= 30;
|
||
if (this.bag_list[needitem] <= 0) {
|
||
delete this.bag_list[needitem];
|
||
}
|
||
} else if (needitem == 10404 && this.bag_list[needitem] < 30) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `需要30个高级九彩云龙珠不足`
|
||
});
|
||
return;
|
||
}
|
||
if (needitem == 10410 && this.bag_list[needitem] >= 5) {
|
||
this.bag_list[needitem] -= 5;
|
||
if (this.bag_list[needitem] <= 0) {
|
||
delete this.bag_list[needitem];
|
||
}
|
||
} else if (needitem == 10410 && this.bag_list[needitem] < 5) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `需要5个超级九彩云龙珠`
|
||
});
|
||
return;
|
||
}
|
||
} else {
|
||
this.send('s2c_notice', {
|
||
strRichText: `炼化材料不足`
|
||
});
|
||
return;
|
||
}
|
||
}
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
equip.refine = null;
|
||
SKLogger.debug(`炼化数据:` + data.level)
|
||
if (data.level == 2) {
|
||
let list = [];
|
||
let refinelist = EquipMgr.shared.getLianhuaData(equip.EIndex, data.level);
|
||
for (let attr of refinelist) {
|
||
equip.refine = attr;
|
||
let score = GameUtil.getBasicsListAttrScore(equip.Race, equip.Sex, equip.refine);
|
||
let obj = {
|
||
property: equip.refine,
|
||
score: score
|
||
}
|
||
list.push(obj)
|
||
}
|
||
this.send('s2c_high_refine', {
|
||
list: SKDataUtil.toJson(list, "[]")
|
||
});
|
||
} else if (data.level == 3) {
|
||
equip.refine = EquipMgr.shared.getMaxLianhuaData(equip.EIndex, data.level);//超级九彩炼化数据
|
||
this.send('s2c_equip_property', {
|
||
property: SKDataUtil.toJson(equip.refine, "[]"),
|
||
score: GameUtil.getBasicsListAttrScore(equip.Race, equip.Sex, equip.refine)
|
||
});
|
||
|
||
|
||
} else if (data.level == 4) {
|
||
equip.refine = EquipMgr.shared.getWingLianhuaData();//炼化翅膀
|
||
this.send('s2c_equip_property', {
|
||
property: SKDataUtil.toJson(equip.refine, "[]"),
|
||
score: GameUtil.getBasicsListAttrScore(equip.Race, equip.Sex, equip.refine)
|
||
});
|
||
}
|
||
else {
|
||
let list = [];
|
||
let refinelist = EquipMgr.shared.getLianhuaData(equip.EIndex, data.level);
|
||
for (let attr of refinelist) {
|
||
equip.refine = attr;
|
||
let score = GameUtil.getBasicsListAttrScore(equip.Race, equip.Sex, equip.refine);
|
||
let obj = {
|
||
property: equip.refine,
|
||
score: score
|
||
}
|
||
list.push(obj)
|
||
}
|
||
this.send('s2c_high_refine', {
|
||
list: SKDataUtil.toJson(list, "[]")
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
// 道具分解
|
||
itemResolve(data: any) {
|
||
let itemData = ItemUtil.getItemData(data.itemId);
|
||
if (itemData == null) { // 无此道具
|
||
SKLogger.warn(`玩家[${this.roleid}:${this.name}]物品[${data.itemId}]分解找不到定义!`);
|
||
return;
|
||
}
|
||
let count = ItemUtil.getBagItemCount(this, itemData.id);
|
||
if (count < 1) {
|
||
SKLogger.warn(`玩家[${this.roleid}:${this.name}]背包无此物品[${data.itemId}]!`);
|
||
return;
|
||
}
|
||
if (itemData && itemData.type == 10 && itemData.level == 2) {
|
||
//let count = data.count * 10;
|
||
this.addBagItem(10102, 10, true);
|
||
}
|
||
this.addItem(data.itemId, -1, false, `道具[${itemData.name}]分解`);
|
||
//let score = ItemUtil.canResolve(itemData);
|
||
// if (score < 1) {
|
||
// this.send('s2c_notice', {
|
||
// strRichText: `物品[${data.itemId}]无法分解!`
|
||
// });
|
||
// return;
|
||
// }
|
||
// this.shuilu.gongji += score;
|
||
// this.send('s2c_you_money', {
|
||
// nKind: GameUtil.goldKind.SLDH_Score,
|
||
// nNum: this.shuilu.gongji,
|
||
// nChange: score
|
||
// });
|
||
// let info = `消耗[color=#b94bd1][${itemData.name}][/color]X1得到功绩${score}`;
|
||
// this.send('s2c_notice', {
|
||
// strRichText: info
|
||
// });
|
||
}
|
||
// 佩饰重铸
|
||
baldricRecast(data: any) {
|
||
let equip: Equip = this.equipObjs[data.equipid];
|
||
if (equip == null) {
|
||
return;
|
||
}
|
||
if (!ItemUtil.isBaldric(equip.EIndex)) {
|
||
return;
|
||
}
|
||
let item_1 = 10406;
|
||
let item_2 = 10409;
|
||
if (data.operation == 1) {
|
||
if (equip.recast == null) {
|
||
return;
|
||
}
|
||
if (data.locks) {
|
||
let total = 0;
|
||
for (let lock of data.locks) {
|
||
if (lock == 1) {
|
||
total++;
|
||
}
|
||
}
|
||
if (total > 0) {
|
||
let hasCnt = ItemUtil.getBagItemCount(this, 70004)
|
||
total = SKDataUtil.clamp(total, 1, 3);
|
||
let jade = GameUtil.lockJade[total - 1];
|
||
if (hasCnt < jade) {
|
||
this.send_notice(`您的碎片不足,佩饰重铸锁住${total}条属性需消耗碎片${jade}`);
|
||
return;
|
||
}
|
||
this.addItem(70004, -jade, false, `佩饰重铸锁住${total}属性,消耗碎片${jade}`);
|
||
}
|
||
let source = equip.BaseAttr;
|
||
let target = SKDataUtil.jsonBy(equip.recast);
|
||
let index = 0;
|
||
for (let lock of data.locks) {
|
||
if (lock == 0) {
|
||
source[index] = target[index];
|
||
}
|
||
index++;
|
||
}
|
||
} else {
|
||
equip.BaseAttr = SKDataUtil.jsonBy(equip.recast);
|
||
}
|
||
equip.calculateAttribute();
|
||
equip.recast = null;
|
||
this.sendEquipInfo(data.equipid);
|
||
this.calculateAttr();
|
||
this.send('s2c_player_data', this.getData());
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
this.send_notice(`重铸替属性成功`);
|
||
// 刷新装备
|
||
this.sendEquipList();
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player) {
|
||
//cxf配饰重铸
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "配饰重铸",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
}
|
||
} else {
|
||
if (this.money < 300000) {
|
||
this.send_notice(`佩饰重铸需要300000银两!`);
|
||
return;
|
||
}
|
||
let item_count_1 = this.getBagItemNum(item_1);
|
||
if (item_count_1 < 5) {
|
||
this.send_notice(`缺少重铸材料[${ItemUtil.getItemName(item_1)}至少5个]`);
|
||
return;
|
||
}
|
||
let item_count_2 = this.getBagItemNum(item_2);
|
||
if (item_count_2 < 1) {
|
||
this.send_notice(`缺少重铸材料[${ItemUtil.getItemName(item_2)}至少1个]`);
|
||
return;
|
||
}
|
||
let recastData = EquipMgr.shared.getBaldricRecast(equip);
|
||
if (recastData) {
|
||
equip.recast = recastData.BaseAttr;
|
||
this.addMoney(0, -300000, "", MsgCode.SUCCESS);
|
||
this.addBagItem(item_1, -5, false);
|
||
this.addBagItem(item_2, -1, false);
|
||
let info = equip.toObj();
|
||
//cxf配饰重铸
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "配饰重铸",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
this.send('s2c_equip_property', {
|
||
property: equip.recast,
|
||
score: GameUtil.getBasicsListAttrScore(info.Race, info.Sex, SKDataUtil.jsonBy(info.recast))
|
||
});
|
||
|
||
}
|
||
}
|
||
}
|
||
// 佩饰分解
|
||
baldricResolve(data: any) {
|
||
let equip: Equip = this.equipObjs[data.equipid];
|
||
if (equip == null) {
|
||
SKLogger.debug(`[${this.roleid}:${this.name}]佩饰分解找不到装备${data.equipid}`);
|
||
return;
|
||
}
|
||
if (!ItemUtil.isBaldric(equip.EIndex)) {
|
||
return;
|
||
}
|
||
let score = 1;
|
||
if (equip.BaseAttr.length != 0) {
|
||
if (equip.Grade == 2) {
|
||
score = 2;
|
||
} else if (equip.Grade == 3) {
|
||
score = 5;
|
||
}
|
||
}
|
||
this.shuilu.gongji += score;
|
||
this.delEquip(equip.EquipID, true, "佩饰分解");
|
||
this.sendEquipList();
|
||
this.send('s2c_you_money', {
|
||
nKind: GameUtil.goldKind.SLDH_Score,
|
||
nNum: this.shuilu.gongji,
|
||
nChange: score
|
||
});
|
||
let info = `消耗[color=${ItemUtil.getBaldricColor(equip.Grade)}][${equip.name}][/color]X1得到功绩${score}`;
|
||
|
||
//cxf配饰分解
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "配饰分解",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
this.send('s2c_notice', {
|
||
strRichText: info
|
||
});
|
||
}
|
||
|
||
// 配饰鉴定
|
||
accAuthenticate(data: any) {
|
||
let equip: Equip = this.equipObjs[data.equipid];
|
||
if (equip == null) {
|
||
SKLogger.debug(`[${this.roleid}:${this.name}]佩饰鉴定找不到装备${data.equipid}`);
|
||
return;
|
||
}
|
||
if (!ItemUtil.isBaldric(equip.EIndex)) {
|
||
return;
|
||
}
|
||
// 玉符,盘古精铁,补天神石,银两
|
||
let need_goods: any = [{ itemId: 10409, num: 1, type: GameUtil.goldKind.Goods }, { itemId: 10405, num: 1, type: GameUtil.goldKind.Goods }, { itemId: 10407, num: 1, type: GameUtil.goldKind.Goods }, { itemId: 90003, num: 230000, type: GameUtil.goldKind.Money }];
|
||
for (const need of need_goods) {
|
||
if (need.type == GameUtil.goldKind.Goods) {
|
||
let item_count = this.getBagItemNum(need.itemId);
|
||
if (item_count < need.num) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `缺少鉴定材料[${ItemUtil.getItemName(need.itemId)}至少${need.num}个]`,
|
||
});
|
||
return;
|
||
}
|
||
} else {
|
||
if (this.money < need.num) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `佩饰鉴定需要${ItemUtil.getItemName(need.num)}银两!`,
|
||
});
|
||
return;
|
||
}
|
||
}
|
||
|
||
}
|
||
for (const need of need_goods) {
|
||
if (need.type == GameUtil.goldKind.Goods) {
|
||
this.addBagItem(need.itemId, -need.num, false);
|
||
} else {
|
||
this.addMoney(GameUtil.goldKind.Money, -need.num, "", MsgCode.FAILED);
|
||
}
|
||
}
|
||
let recastData = EquipMgr.shared.getBaldricRecast(equip);
|
||
if (recastData) {
|
||
// 赋值装备属性
|
||
equip.BaseAttr = SKDataUtil.jsonBy(recastData.BaseAttr);
|
||
equip.calculateAttribute();
|
||
// 发送装备信息
|
||
this.sendEquipInfo(data.equipid);
|
||
// 核对属性
|
||
this.calculateAttr();
|
||
// 更新装备属性
|
||
this.send('s2c_player_data', this.getData());
|
||
this.send('s2c_acc_authenticate', {
|
||
attribute: recastData.BaseAttr
|
||
});
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
}
|
||
//cxf配饰鉴定
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "配饰鉴定",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
}
|
||
// 装备重铸
|
||
equipRecast(data: any) {
|
||
let equip: any = this.equipObjs[data.equipid];
|
||
if (equip == null) {
|
||
return;
|
||
}
|
||
if (equip.EquipType == 0 || equip.EquipType == 2) {
|
||
return;
|
||
}
|
||
if (data.operation == 1) {
|
||
if (equip.recast == null) {
|
||
return;
|
||
}
|
||
equip.setDB(equip.recast);
|
||
equip.calculateAttribute();
|
||
equip.recast = null;
|
||
this.sendEquipInfo(data.equipid);
|
||
this.calculateAttr();
|
||
this.send('s2c_player_data', this.getData());
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
this.send_notice(`重铸成功`);
|
||
// 刷新装备
|
||
this.sendEquipList();
|
||
//cxf装备重铸
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "装备重铸",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
} else {
|
||
let itemid = 10405;
|
||
if (equip.EquipType == 3) {
|
||
itemid = 10401;
|
||
}
|
||
let itemnum = this.getBagItemNum(itemid);
|
||
if (itemnum == 0) {
|
||
this.send_notice(`缺少重铸材料`);
|
||
return;
|
||
}
|
||
equip.recast = null;
|
||
let recastData = EquipMgr.shared.getRecastData({
|
||
type: equip.EquipType,
|
||
grade: equip.Grade,
|
||
role: this,
|
||
ower: equip.OwnerRoleId,
|
||
pos: equip.EIndex,
|
||
resid: equip.Type
|
||
});
|
||
equip.recast = recastData;
|
||
if (equip.recast) {
|
||
this.addBagItem(itemid, -1, false);
|
||
this.send('s2c_equip_property', {
|
||
property: equip.recast.BaseAttr,
|
||
score: GameUtil.calculate(JSON.parse(equip.recast.BaseAttr), equip.Race, equip.Sex, true)
|
||
});
|
||
}
|
||
}
|
||
}
|
||
// 装备分解
|
||
equipResolve(data: any) {
|
||
let equip = this.equipObjs[data.equipid];
|
||
if (equip == null) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `分解的装备不存在!`
|
||
});
|
||
return;
|
||
}
|
||
if (equip.EIndex == 6) {
|
||
this.addItem(10411, 10, false, `${equip.name}分解`);
|
||
this.delEquip(equip.EquipID, true, "翅膀分解");
|
||
this.sendEquipList();
|
||
let info = `消耗翅膀[color=${ItemUtil.getBaldricColor(equip.Grade)}][${equip.name}][/color]X1得到10个[img]ui://main_ui/10411[/img]翅膀精华`;
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player) {
|
||
//cxf仙器分解
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "翅膀分解",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
}
|
||
this.send('s2c_notice', {
|
||
strRichText: info
|
||
});
|
||
return;
|
||
}
|
||
|
||
if (equip.EquipType != 3 && equip.Grade < 2) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `只有二阶及以上的仙器才能分解!`
|
||
});
|
||
return;
|
||
}
|
||
let count = ItemUtil.getEquipResolve(equip.Grade);
|
||
if (count < 1) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `仙器[color=${ItemUtil.getBaldricColor(equip.Grade)}][${equip.name}][/color]无法分解!`
|
||
});
|
||
}
|
||
this.addItem(10406, count, false, `${equip.name}分解`);
|
||
this.delEquip(equip.EquipID, true, "仙器分解");
|
||
this.sendEquipList();
|
||
let info = `消耗仙器[color=${ItemUtil.getBaldricColor(equip.Grade)}][${equip.name}][/color]X1得到${count}个[img]ui://main_ui/10406[/img]八荒遗风`;
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player) {
|
||
//cxf仙器分解
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.EQUIP,
|
||
operateDepict: "仙器分解",
|
||
operateResSerial: equip.EquipID,
|
||
operateResName: equip.name,
|
||
operateContent: SKDataUtil.toJson(equip.cxfEquip(this.roleid), "{}")
|
||
})
|
||
}
|
||
this.send('s2c_notice', {
|
||
strRichText: info
|
||
});
|
||
}
|
||
|
||
buyEquip(info: any) {
|
||
}
|
||
|
||
sellEquip(info: any) {
|
||
|
||
}
|
||
////////////////////////////// 装备 结束 /////////////////////////////
|
||
|
||
getPartnerOnBattle(): any {
|
||
let battlelist: any = [];
|
||
if (this.partnerMgr == null) {
|
||
return battlelist;
|
||
}
|
||
|
||
for (var it in this.partnerMgr.vecChuZhan) {
|
||
let nPartnerID = this.partnerMgr.vecChuZhan[it];
|
||
if (0 == nPartnerID)
|
||
continue;
|
||
|
||
let pPartner = this.partnerMgr.mapPartner[nPartnerID];
|
||
if (null == pPartner)
|
||
continue;
|
||
|
||
battlelist.push(pPartner);
|
||
}
|
||
|
||
return battlelist;
|
||
}
|
||
// 获得战斗召唤兽
|
||
getBattlePet(pos: any): any {
|
||
let pets = [];
|
||
let btlpet = null;
|
||
for (let petid in this.petList) {
|
||
let pet: Pet = this.petList[petid];
|
||
let battlePet = new BattleRole();
|
||
battlePet.setObj(pet);
|
||
battlePet.bindid = this.onlyid;
|
||
if (this.curPet && pet.onlyid == this.curPet.onlyid) {
|
||
battlePet.pos = pos;
|
||
btlpet = battlePet;
|
||
} else {
|
||
battlePet.pos = 0;
|
||
}
|
||
pets.push(battlePet);
|
||
}
|
||
let result = {
|
||
pets: pets,
|
||
btlpet: btlpet
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 获取自己的战斗队伍
|
||
* @param {number} type 是否有伙伴上场 0 上场 1 不上场
|
||
*/
|
||
getBattleTeam(type = BattleType.Normal) {
|
||
let btlteam: any = [];
|
||
let teamid = this.teamid;
|
||
if (teamid != 0) {
|
||
let team_players = TeamMgr.shared.getTeamPlayer(teamid);
|
||
let count = 0;
|
||
for (let i = 0; i < team_players.length; i++) {
|
||
let player = team_players[i];
|
||
if (player.pause == 1) {
|
||
count++;
|
||
continue;
|
||
}
|
||
let brole = new BattleRole();
|
||
brole.pos = i + 1;
|
||
brole.setObj(player);
|
||
let pPets = player.getBattlePet(i + 6);
|
||
if (pPets.btlpet) {
|
||
brole.bindid = pPets.btlpet.onlyid;
|
||
}
|
||
btlteam.push(brole);
|
||
btlteam = btlteam.concat(pPets.pets);
|
||
}
|
||
if (type == BattleType.Normal || type == BattleType.PK) {
|
||
let partnerlist = TeamMgr.shared.getTeamLeaderPartner(teamid);
|
||
let index = 1;
|
||
for (const partner of partnerlist) {
|
||
let bpartner = new BattleRole();
|
||
bpartner.pos = (team_players.length - count) + index;
|
||
bpartner.setObj(partner);
|
||
btlteam.push(bpartner);
|
||
index++;
|
||
}
|
||
}
|
||
} else {
|
||
let brole = new BattleRole();
|
||
brole.pos = 1;
|
||
brole.setObj(this);
|
||
let petData = this.getBattlePet(6);
|
||
if (petData.btlpet) {
|
||
brole.bindid = petData.btlpet.onlyid;
|
||
}
|
||
btlteam.push(brole);
|
||
btlteam = btlteam.concat(petData.pets);
|
||
if (type == BattleType.Normal || type == BattleType.PK || type == BattleType.AREAN) {
|
||
let partnerlist = this.getPartnerOnBattle();
|
||
let index = 1;
|
||
for (const partner of partnerlist) {
|
||
let bpartner = new BattleRole();
|
||
bpartner.pos = 1 + index;
|
||
bpartner.setObj(partner);
|
||
btlteam.push(bpartner);
|
||
index++;
|
||
}
|
||
}
|
||
}
|
||
return btlteam;
|
||
}
|
||
|
||
forcedBattle(p1: any, battle: any) {
|
||
if (this.teamid != 0) {
|
||
let plist = TeamMgr.shared.getTeamPlayer(this.teamid);
|
||
for (const pPlayer of plist) {
|
||
if (pPlayer.pause == 1) {
|
||
continue;
|
||
}
|
||
pPlayer.send('s2c_btl', {
|
||
btlid: battle.battle_id,
|
||
teamS: battle.getTeamData(2),
|
||
teamE: battle.getTeamData(),
|
||
});
|
||
pPlayer.battle_id = battle.battle_id;
|
||
}
|
||
} else {
|
||
this.send('s2c_btl', {
|
||
btlid: battle.battle_id,
|
||
teamS: battle.getTeamData(2),
|
||
teamE: battle.getTeamData(),
|
||
});
|
||
this.battle_id = battle.battle_id;
|
||
}
|
||
}
|
||
|
||
// type 0 正常 1 pk 2 切磋
|
||
playerBattle(onlyid: any, type = BattleType.Normal) {
|
||
if (this.battle_id != 0 || this.onlyid == onlyid) {
|
||
return null;
|
||
}
|
||
let p2 = PlayerMgr.shared.getPlayerByOnlyId(onlyid);
|
||
if (p2 == null || p2.battle_id != 0) {
|
||
return null;
|
||
}
|
||
if (this.teamid != 0 && this.isleader == false) {
|
||
return null;
|
||
}
|
||
if (p2.teamid != 0 && this.teamid == p2.teamid) {
|
||
return null;
|
||
}
|
||
if (type == BattleType.Force) {
|
||
if (this.level < GameUtil.PKLevelLimit || p2.level < GameUtil.PKLevelLimit) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '强制pk等级不足' + GameUtil.PKLevelLimit + '级!'
|
||
});
|
||
return null;
|
||
}
|
||
|
||
let mapsi = GameUtil.cantPKMaps.indexOf(this.mapid);
|
||
let mapti = GameUtil.cantPKMaps.indexOf(p2.mapid);
|
||
if (mapsi != -1 || mapti != -1) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '此处为安全区域,无法强制PK！'
|
||
});
|
||
return null;
|
||
}
|
||
if (!this.bag_list[10003] || this.bag_list[10003] < 1) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '夺命香数量不足！'
|
||
});
|
||
return null;
|
||
}
|
||
this.bag_list[10003] -= 1;
|
||
if (this.bag_list[10003] <= 0) {
|
||
delete this.bag_list[10003];
|
||
}
|
||
this.send('s2c_bagitem', {
|
||
info: SKDataUtil.toJson(this.bag_list, "{}")
|
||
});
|
||
console.log(`玩家[${this.name}${this.roleid}]消耗 夺命香 1 个`);
|
||
}
|
||
|
||
let t1 = this.getBattleTeam(type);
|
||
let t2 = p2.getBattleTeam(type);
|
||
|
||
let battle = BattleMgr.shared.createBattle();
|
||
battle.setBattleType(type);
|
||
battle.setTeamBRole(t1, t2);
|
||
battle.source = this.onlyid;
|
||
|
||
let senddata = {
|
||
btlid: battle.battle_id,
|
||
teamS: battle.getTeamData(),
|
||
teamE: battle.getTeamData(2),
|
||
};
|
||
if (this.teamid != 0) {
|
||
let plist = TeamMgr.shared.getTeamPlayer(this.teamid);
|
||
for (const pPlayer of plist) {
|
||
if (pPlayer.pause == 1) {
|
||
continue;
|
||
}
|
||
pPlayer.battle_id = battle.battle_id;
|
||
pPlayer.send('s2c_btl', senddata);
|
||
pPlayer.synInfoToWatcher();
|
||
}
|
||
} else {
|
||
this.battle_id = battle.battle_id;
|
||
this.send('s2c_btl', senddata);
|
||
this.synInfoToWatcher();
|
||
}
|
||
|
||
if (type != BattleType.AREAN) {
|
||
p2.forcedBattle(this.onlyid, battle);
|
||
}
|
||
|
||
if (type == BattleType.Force) {
|
||
//显示强制PK的 通知title
|
||
this.send('s2c_pktitle', {
|
||
info: '正在强制PK对方,您失败将扣除经验【2亿】,每次胜利将获赠一次监牢30分钟旅游的机会!'
|
||
});
|
||
p2.send('s2c_pktitle', {
|
||
info: '正在被对方强制PK,您失败将扣除经验【2亿】,战胜对方是不会进监牢的,加油干掉对面吧!'
|
||
});
|
||
}
|
||
|
||
setTimeout(() => {
|
||
battle.begin();
|
||
}, 1 * 1000);
|
||
return battle;
|
||
}
|
||
|
||
monsterBattle(mongroupid?: any, taskGrop?: number, battletype = BattleType.Normal, yewai = false) {
|
||
if (this.battle_id != 0)
|
||
return null;
|
||
|
||
if (mongroupid == null || isNaN(mongroupid)) {
|
||
mongroupid = 10048;
|
||
}
|
||
let mongroup = MonsterMgr.shared.getGroupData(mongroupid);
|
||
if (mongroup == null) {
|
||
return null;
|
||
}
|
||
|
||
let monsterlist = MonsterMgr.shared.getMonGroup(mongroupid);
|
||
if (monsterlist == null) {
|
||
return null;
|
||
}
|
||
if (this.teamid != 0 && this.isleader == false) {
|
||
return null;
|
||
}
|
||
|
||
if (this.mapid == 1003) { //北俱芦洲 没有宝宝
|
||
yewai = false;
|
||
}
|
||
let t1 = this.getBattleTeam(mongroup.partner);
|
||
let maxlevel = 0;
|
||
for (let key in t1) {
|
||
let player = t1[key];
|
||
if (!player.isPet()) {
|
||
if (player.level > maxlevel) {
|
||
maxlevel = player.level
|
||
}
|
||
}
|
||
}
|
||
let t2 = [];
|
||
for (let i = 0; i < monsterlist.length; i++) {
|
||
const monster = monsterlist[i];
|
||
let brole = new BattleRole();
|
||
brole.pos = parseInt(monster.pos);
|
||
brole.setObj(monster);
|
||
let lev = maxlevel - brole.level;
|
||
if (lev > 0) {
|
||
// brole.setAttr(EAttrTypeL1.HP, 1);
|
||
// brole.setAttr(EAttrTypeL1.HP_MAX, 1);
|
||
// brole.setAttr(EAttrTypeL1.ATK, 1);
|
||
// brole.setAttr(EAttrTypeL1.SPD, 1);
|
||
brole.setAttr(EAttrTypeL1.HP, brole.roleattr[EAttrTypeL1.HP] + Math.floor(brole.roleattr[EAttrTypeL1.HP] * (lev / 100)));
|
||
brole.setAttr(EAttrTypeL1.HP_MAX, brole.roleattr[EAttrTypeL1.HP_MAX] + Math.floor(brole.roleattr[EAttrTypeL1.HP_MAX] * (lev / 100)));
|
||
brole.setAttr(EAttrTypeL1.ATK, brole.roleattr[EAttrTypeL1.ATK] + Math.floor(brole.roleattr[EAttrTypeL1.ATK] * (lev / 100)));
|
||
brole.setAttr(EAttrTypeL1.SPD, brole.roleattr[EAttrTypeL1.SPD] + Math.floor(brole.roleattr[EAttrTypeL1.SPD] * (lev / 100)));
|
||
}
|
||
t2.push(brole);
|
||
}
|
||
if (yewai && t2.length < 10) {
|
||
let r = GameUtil.random(1, 10000);
|
||
if (r < 10000) {
|
||
let list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||
for (const key in t2) {
|
||
const brole = t2[key];
|
||
let t = list.indexOf(brole.pos);
|
||
list.splice(t, 1);
|
||
}
|
||
if (list.length > 0) {
|
||
let bb = MonsterMgr.shared.getRandomBB();
|
||
let brole = new BattleRole();
|
||
brole.is_bb = true;
|
||
brole.pos = list[GameUtil.random(0, list.length - 1)];
|
||
brole.setObj(bb);
|
||
t2.push(brole);
|
||
}
|
||
}
|
||
}
|
||
|
||
let battle = BattleMgr.shared.createBattle();
|
||
battle.setBattleType(battletype);
|
||
battle.setTeamBRole(t1, t2);
|
||
battle.monster_group_id = mongroupid;
|
||
battle.taskGroup = taskGrop;
|
||
let senddata = {
|
||
btlid: battle.battle_id,
|
||
teamS: battle.getTeamData(),
|
||
teamE: battle.getTeamData(2),
|
||
};
|
||
if (this.teamid != 0) {
|
||
let plist = TeamMgr.shared.getTeamPlayer(this.teamid);
|
||
for (const pPlayer of plist) {
|
||
if (pPlayer.pause == 1) {
|
||
continue;
|
||
}
|
||
pPlayer.battle_id = battle.battle_id;
|
||
pPlayer.send('s2c_btl', senddata);
|
||
pPlayer.synInfoToWatcher();
|
||
}
|
||
} else {
|
||
this.battle_id = battle.battle_id;
|
||
this.send('s2c_btl', senddata);
|
||
this.synInfoToWatcher();
|
||
}
|
||
|
||
setTimeout(() => {
|
||
battle.begin();
|
||
}, 1 * 1000);
|
||
|
||
return battle;
|
||
}
|
||
|
||
// 战斗结束
|
||
exitBattle(iswin: any) {
|
||
|
||
let battle = BattleMgr.shared.getBattle(this.battle_id);
|
||
if (battle == null) {
|
||
this.battle_id = 0;
|
||
return;
|
||
}
|
||
if (battle.battle_type == BattleType.AREAN && iswin == 1) {
|
||
this.send('s2c_btl_end', {
|
||
btlid: this.battle_id,
|
||
result: iswin,
|
||
});
|
||
} else {
|
||
this.send('s2c_btl_end', {
|
||
btlid: this.battle_id,
|
||
result: iswin,
|
||
});
|
||
}
|
||
|
||
// 奖励相关
|
||
let mgdata = MonsterMgr.shared.getGroupData(battle.monster_group_id);
|
||
if (iswin == 1 && mgdata && battle.battle_type != BattleType.AREAN) {
|
||
this.addExp(mgdata.exp);
|
||
this.addMoney(0, mgdata.gold, '战斗奖励', MsgCode.SUCCESS);
|
||
if (this.curPet) {
|
||
this.curPet.addExp(mgdata.exp);
|
||
}
|
||
|
||
let itemlist = MonsterMgr.shared.makeGroupDrop(battle.monster_group_id);
|
||
for (const iteminfo of itemlist) {
|
||
this.addItem(iteminfo.itemid, iteminfo.itemnum, true, '战斗奖励');
|
||
}
|
||
}
|
||
|
||
// 任务相关
|
||
if (iswin == 1) {
|
||
if (battle.battle_type == BattleType.Force && battle.source == this.onlyid) {
|
||
if (this.teamid > 0) {
|
||
let team_players = TeamMgr.shared.getTeamPlayer(this.teamid);
|
||
// TeamMgr.shared.destroyTeam(this.teamid);
|
||
for (let i = 0; i < team_players.length; i++) {
|
||
const pPlayer = team_players[i];
|
||
pPlayer.shane += 1440 * 5;
|
||
pPlayer.ShanEChange();
|
||
pPlayer.send('s2c_aoi_pinfo', {
|
||
list: [this.toObj()]
|
||
});
|
||
}
|
||
} else {
|
||
this.shane += 1440 * 5;
|
||
this.ShanEChange();
|
||
this.send('s2c_aoi_pinfo', {
|
||
list: [this.toObj()]
|
||
});
|
||
this.send('s2c_notice', {
|
||
strRichText: '恭喜您获得30分钟监牢旅游一次的机会,进入长安才会触发！'
|
||
});
|
||
}
|
||
// 杀人记录
|
||
this.syncMurder(battle);
|
||
}
|
||
if (battle.battle_type == BattleType.Normal) {
|
||
let pNpc = NpcMgr.shared.findNpc(battle.source);
|
||
if (pNpc) {
|
||
this.OnKillNpc(pNpc.configid, pNpc.onlyid, battle);
|
||
}
|
||
}
|
||
/* 胜利宠物加10点亲密值 */
|
||
if (this.teamid > 0) {
|
||
let team_players = TeamMgr.shared.getTeamPlayer(this.teamid);
|
||
for (let player of team_players) {
|
||
if (player && player.curPet) {
|
||
player.curPet.addqinmi(10);
|
||
}
|
||
}
|
||
} else {
|
||
if (this.curPet) {
|
||
this.curPet.addqinmi(10);
|
||
}
|
||
}
|
||
} else {
|
||
// 战斗失败了
|
||
if (battle.battle_type == BattleType.Force && this.roleid) {
|
||
if (this.teamid > 0) {
|
||
let team_players = TeamMgr.shared.getTeamPlayer(this.teamid);
|
||
for (let i = 0; i < team_players.length; i++) {
|
||
const pPlayer = team_players[i];
|
||
pPlayer.addExp(-200000000);
|
||
console.log(`队伍玩家[${pPlayer.name}${pPlayer.roleid}]被强制pk 扣除经验 2亿`);
|
||
}
|
||
} else {
|
||
let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
pPlayer.addExp(-200000000);
|
||
pPlayer.send('s2c_notice', {
|
||
strRichText: '角色经验被扣除2亿'
|
||
});
|
||
}
|
||
}
|
||
this.getTaskMgr().OnFailEvent(EEventType.PLAYER_DEAD, 0);
|
||
let pNpc = NpcMgr.shared.findNpc(battle.source);
|
||
if (pNpc) {
|
||
// 天地星
|
||
World.shared.starMgr.ChallengeFail(pNpc.onlyid, battle);
|
||
// 证道恶鬼
|
||
World.shared.magicWorldMgr.ChallengeFail(pNpc.onlyid, battle);
|
||
// 海盗
|
||
World.shared.pirateMgr.ChallengeFail(pNpc.onlyid);
|
||
}
|
||
}
|
||
// 水路大会
|
||
if (battle.battle_type == BattleType.ShuiLu) {
|
||
let activity = ActivityMgr.shared.getActivity(ActivityDefine.activityKindID.ShuiLuDaHui);
|
||
if (activity) {
|
||
let matchteam = activity.getMatchTeamInfo(this.teamid);
|
||
if (matchteam) {
|
||
activity.battleEnd(this.teamid, iswin);
|
||
}
|
||
}
|
||
}
|
||
// 皇城pk
|
||
else if (battle.battle_type == BattleType.PALACE) {
|
||
if (iswin && ((this.teamid != 0 && this.isleader) || this.teamid == 0)) {
|
||
PalaceFight.shared.pkWin(this.roleid);
|
||
}
|
||
}
|
||
// 竞技场
|
||
else if (battle.battle_type == BattleType.AREAN) {
|
||
let tcamp = battle.plist;
|
||
let brole = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
for (let i in tcamp) {
|
||
let trole = tcamp[i];
|
||
if (trole.onlyid != brole.onlyid) {
|
||
if (trole.living_type == 1) {
|
||
JingJiChang.shared.JingJiInfo(this.roleid, trole.onlyid, iswin);
|
||
JingJiChang.shared.battleEnd(this.roleid, iswin, trole.onlyid);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 证道大会
|
||
else if (battle.battle_type == BattleType.Sat) {
|
||
if (SatAssembly.shared.activity_state != ActivityDefine.activityState.Close) {
|
||
let match_team = SatAssembly.shared.getMatchTeamInfo(this.teamid);
|
||
if (match_team) {
|
||
SatAssembly.shared.battleEnd(this.teamid, iswin);
|
||
}
|
||
}
|
||
}
|
||
// 帮战比武
|
||
else if (battle.battle_type == BattleType.FactionWarContest) {
|
||
if (FactionWar.shared.activity_state != ActivityDefine.activityState.Close) {
|
||
FactionWar.shared.contestResult(this, iswin);
|
||
}
|
||
}
|
||
// 帮战战斗
|
||
else if (battle.battle_type == BattleType.FactionWarFight) {
|
||
if (FactionWar.shared.activity_state != ActivityDefine.activityState.Close) {
|
||
FactionWar.shared.fightResult(this, iswin, battle);
|
||
}
|
||
}
|
||
|
||
this.battle_id = 0;
|
||
this.synInfoToWatcher();
|
||
}
|
||
|
||
// 杀人记录
|
||
syncMurder(battle: any) {
|
||
// 死亡玩家编号数组
|
||
let list: any = [];
|
||
for (let role of battle.campB.broles) {
|
||
// 如果是玩家 并且死亡
|
||
if (role.living_type == 1) {
|
||
if (role.source != null && role.source != undefined) {
|
||
let data: any = {
|
||
defier_role_id: this.roleid,
|
||
by_defier_role_id: role.source.roleid,
|
||
server_id: GameUtil.serverId
|
||
};
|
||
PaiHangMgr.shared.updateMurderRankData(this.roleid, this.name, this.race, this.level, this.relive)
|
||
list.push(data);
|
||
}
|
||
}
|
||
}
|
||
// 通过CXF 同步到数据库
|
||
console.log(`胜利玩家：${this.name}死亡玩家:${SKDataUtil.toJson(list, "[]")}`)
|
||
SKCxfUtil.getCxfMurder(list);
|
||
|
||
}
|
||
|
||
ShanEChange() {
|
||
let change = false;
|
||
// 如果玩家牢狱时间小于=0 并且玩家在牢房，将其释放
|
||
if (this.mapid == 1201 && this.shane <= 0) {
|
||
this.leavePrison();
|
||
this.send('s2c_prison_time', {
|
||
onlyid: this.onlyid,
|
||
time: 0
|
||
});
|
||
change = true;
|
||
}
|
||
// 如果玩家牢狱时间大于=0 并且玩家不在牢房，将其传送进牢房
|
||
if (this.mapid == 1011 && this.shane > 0) {
|
||
this.enterPrison();
|
||
change = true;
|
||
}
|
||
if (this.shane != 0) {
|
||
this.send('s2c_prison_time', {
|
||
onlyid: this.onlyid,
|
||
time: this.inPrison ? Math.ceil(this.shane / 4) : -1
|
||
});
|
||
}
|
||
// 更新监牢犯人数据
|
||
PaiHangMgr.shared.updateDaysPrisonerData(this.roleid, this.name, this.race, this.level, this.relive, this.shane);
|
||
return change;
|
||
}
|
||
|
||
getWorldStar() {
|
||
return this.star;
|
||
}
|
||
|
||
OnKillNpc(nConfigID: any, nOnlyID: any, battle: any = null) {
|
||
let pNpc = NpcMgr.shared.findNpc(nOnlyID);
|
||
if (null == pNpc)
|
||
return;
|
||
|
||
let pConfig = NpcConfigMgr.shared.getConfig(nConfigID);
|
||
if (null == pConfig)
|
||
return;
|
||
|
||
this.getTaskMgr().onGameEvent(EEventType.PLAYER_KILL_NPC, nOnlyID);
|
||
if (pNpc.stCreater.nKind != ENpcCreater.SYSTEM) {
|
||
NpcMgr.shared.CheckAndDeleteNpc(nOnlyID, this);
|
||
}
|
||
if (World.shared.starMgr.IsStar(nOnlyID)) {
|
||
this.star++;
|
||
}
|
||
// 天地星
|
||
World.shared.OnKillNpc(this.accountid, nOnlyID, battle);
|
||
// 天元盛典
|
||
DWorld.shared.OnKillNpc(this.accountid, nOnlyID);
|
||
}
|
||
// 加入到装备列表
|
||
addEquipList(value: Equip) {
|
||
this.listEquips.push(value);
|
||
}
|
||
// 加入到法宝列表
|
||
addMagicWeaponList(value: MagicWeapon) {
|
||
this.listMagicWeapons.push(value);
|
||
}
|
||
|
||
playerRelive(data: any) {
|
||
let nextlive = this.relive + 1;
|
||
let relivedata = GameUtil.reliveLimit[nextlive];
|
||
if (relivedata == null) {
|
||
this.send('s2c_relive', {
|
||
result: MsgCode.FAILED,
|
||
info: this.toObj(),
|
||
data: this.getData()
|
||
});
|
||
return;
|
||
}
|
||
if (this.level < relivedata.level) {
|
||
return;
|
||
}
|
||
//处理装备
|
||
for (const equip of this.currentEquips) {
|
||
this.addEquipList(equip);
|
||
}
|
||
this.currentEquips = [];
|
||
this.sendEquipList();
|
||
this.schemeMgr.reset();
|
||
this.changeWeapon(null);
|
||
//清理加点
|
||
for (const key in this.addattr2) {
|
||
this.addattr2[key] = 0;
|
||
}
|
||
this.relivelist[this.relive] = [this.race, this.sex];
|
||
this.relive = nextlive;
|
||
this.resid = data.resid;
|
||
this.race = SKDataUtil.clamp(data.race, ERaceType.HUMEN, ERaceType.DRAGON);
|
||
this.sex = data.sex;
|
||
this.setLevel(relivedata.tolevel);
|
||
this.resetSkill();
|
||
this.addExp(0);
|
||
this.calculateAttr();
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player.bangid > 0) {
|
||
let bang = BangMgr.shared.getBang(player.bangid)
|
||
if (bang) {
|
||
for (const roleInfo of bang.rolelist) {
|
||
if (player.roleid == roleInfo.roleid) {
|
||
roleInfo.resid = player.resid;
|
||
roleInfo.race = player.race;
|
||
roleInfo.relive = player.relive;
|
||
roleInfo.level = player.level;
|
||
roleInfo.sex = player.sex;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
this.send('s2c_relive', {
|
||
result: MsgCode.SUCCESS,
|
||
info: this.toObj(),
|
||
data: this.getData()
|
||
});
|
||
// 更新红名榜数据
|
||
PaiHangMgr.shared.updateMurderRankDataInfo(this.roleid, this.name, this.race, this.level, this.relive);
|
||
//cxf玩家转生
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.EXP,
|
||
operateDepict: "玩家转生",
|
||
operateResSerial: "",
|
||
operateResName: "",
|
||
operateContent: `${this.name}]转生后：[${this.relive}转，${this.level}级]`
|
||
})
|
||
}
|
||
|
||
playerFlyUp(data: any) {
|
||
if (this.relive != 3) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `你才{${this.relive}}转,需要3转180级后才可以飞升`
|
||
});
|
||
return;
|
||
}
|
||
let nextlive = this.relive + 1;
|
||
let relivedata = GameUtil.reliveLimit[nextlive];
|
||
if (relivedata == null) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `没有开放飞升配置,请稍候重试!`
|
||
});
|
||
return;
|
||
}
|
||
if (this.level < relivedata.level) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `需要达到等级:${relivedata.level}才可以飞升!`
|
||
});
|
||
return;
|
||
}
|
||
//处理装备
|
||
for (const equip of this.currentEquips) {
|
||
this.addEquipList(equip);
|
||
}
|
||
this.currentEquips = [];
|
||
this.sendEquipList();
|
||
this.changeWeapon(null);
|
||
//清理加点
|
||
for (const key in this.addattr2) {
|
||
this.addattr2[key] = 0;
|
||
}
|
||
this.relivelist[this.relive] = [this.race, this.sex];
|
||
this.relive = nextlive;
|
||
this.setLevel(relivedata.tolevel);
|
||
this.resetSkill();
|
||
this.addExp(0);
|
||
this.calculateAttr();
|
||
this.send('s2c_relive', {
|
||
result: MsgCode.SUCCESS,
|
||
info: this.toObj(),
|
||
data: this.getData()
|
||
});
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
}
|
||
// 玩家改变种族
|
||
playerChangeRace(data: any) {
|
||
if (this.jade < 300) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '仙玉不足'
|
||
});
|
||
return;
|
||
}
|
||
this.addMoney(1, -300, `玩家[${this.roleid}:${this.name}]改变种族`, MsgCode.SUCCESS);
|
||
for (let equip of this.currentEquips) {
|
||
this.addEquipList(equip);
|
||
equip.pos = EEquipPos.BAG
|
||
}
|
||
this.currentEquips = [];
|
||
this.sendEquipList();
|
||
this.changeWeapon(null);
|
||
this.resid = data.resid;
|
||
this.race = RoleUtil.checkRace(data.race, data.resid);
|
||
this.sex = RoleUtil.checkSex(data.sex, data.resid);
|
||
//重置加点
|
||
this.addattr2[EAttrTypeL2.GENGU] = 0;
|
||
this.addattr2[EAttrTypeL2.LINGXING] = 0;
|
||
this.addattr2[EAttrTypeL2.MINJIE] = 0;
|
||
this.addattr2[EAttrTypeL2.LILIANG] = 0;
|
||
this.addXiulianPoint({ type: 0 })
|
||
this.setRoleColor(this.color_one_serial, this.color_two_serial);
|
||
this.resetSkill();
|
||
this.addExp(0);
|
||
this.calculateAttr();
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
this.horseList.changeRace(this.race);
|
||
let params = {
|
||
result: MsgCode.SUCCESS,
|
||
info: this.toObj(),
|
||
data: this.getData()
|
||
};
|
||
this.send("s2c_changerace", params);
|
||
this.syncChangeRace();
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player.bangid > 0) {
|
||
let bang = BangMgr.shared.getBang(player.bangid)
|
||
if (bang) {
|
||
for (const roleInfo of bang.rolelist) {
|
||
if (player.roleid == roleInfo.roleid) {
|
||
roleInfo.resid = player.resid;
|
||
roleInfo.race = player.race;
|
||
roleInfo.sex = player.sex;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 同步种族改变
|
||
syncChangeRace() {
|
||
let playerList = this.getWatcherPlayer();
|
||
if (playerList) {
|
||
for (let key in playerList) {
|
||
let player = playerList[key];
|
||
if (player.isPlayer()) {
|
||
player.send('s2c_sync_race', {
|
||
info: this.toObj(),
|
||
data: this.getData()
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* 修改角色名称
|
||
* @param data
|
||
*/
|
||
playerChangeName(data: any) {
|
||
if (this.jade < 600) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '仙玉不足'
|
||
});
|
||
return;
|
||
}
|
||
if (!GameUtil.checkLimitWord(data.name)) {
|
||
this.send_notice("再想一个独一无二的名字吧，仙玉未扣除！");
|
||
return;
|
||
}
|
||
let rag = /[\u4e00-\u9fa5a-zA-Z]{3,5}$/;
|
||
|
||
if (rag.test(data.name) == false) {
|
||
this.send_notice("名字不符合规则(3~5个中文字符)");
|
||
return;
|
||
}
|
||
let callback = (ret: any) => {
|
||
if (ret == MsgCode.SUCCESS) {
|
||
this.addMoney(1, -600, '玩家改变名字', MsgCode.SUCCESS);
|
||
this.send_notice("改名成功，西游欢迎您重新归来！");
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player) {
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PLAYER,
|
||
operateDepict: "玩家改名",
|
||
operateResSerial: this.roleid,
|
||
operateResName: player.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
this.name = data.name;
|
||
if (this.bangid > 0) {
|
||
let bang = BangMgr.shared.getBang(this.bangid)
|
||
if (bang) {
|
||
if (bang.masterid == this.roleid) {
|
||
bang.mastername = this.name;
|
||
}
|
||
for (const roleInfo of bang.rolelist) {
|
||
if (this.roleid == roleInfo.roleid) {
|
||
roleInfo.name = this.name;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 更新红名榜数据
|
||
PaiHangMgr.shared.updateMurderRankDataInfo(this.roleid, this.name, this.race, this.level, this.relive);
|
||
this.send('s2c_aoi_pinfo', {
|
||
list: [this.toObj()]
|
||
});
|
||
this.synInfoToWatcher();
|
||
} else {
|
||
this.send_notice("再想一个独一无二的名字吧，仙玉未扣除！");
|
||
}
|
||
callback = null;
|
||
}
|
||
DB.changeName(data, callback);
|
||
}
|
||
|
||
/**
|
||
* 修改宠物名字
|
||
* @param data
|
||
*/
|
||
playerChangePetName(data: any) {
|
||
if (this.jade < 600) {
|
||
this.send_notice("仙玉不足");
|
||
return;
|
||
}
|
||
if (!GameUtil.checkLimitWord(data.name)) {
|
||
this.send_notice("再想一个独一无二的名字吧，仙玉未扣除！");
|
||
return;
|
||
}
|
||
let rag = /^[\u4e00-\u9fa5]{3,5}$/;
|
||
if (rag.test(data.name) == false) {
|
||
this.send_notice("名字不符合规则(3~5个中文字符)");
|
||
return;
|
||
}
|
||
let callback = (ret: any) => {
|
||
if (ret == MsgCode.SUCCESS) {
|
||
this.addMoney(1, -600, '宠物改变名字', MsgCode.SUCCESS);
|
||
this.send_notice("改名成功！");
|
||
let operationPet = null;
|
||
for (const pet of this.petList) {
|
||
if (pet.petid == data.petId) {
|
||
operationPet = pet;
|
||
break;
|
||
}
|
||
}
|
||
operationPet.playerChangePetName(data.name);
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player) {
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "宠物改名",
|
||
operateResSerial: operationPet.petid,
|
||
operateResName: operationPet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
} else {
|
||
this.send_notice("修改失败！");
|
||
}
|
||
callback = null;
|
||
}
|
||
// 如果在队伍刷新宠物名称
|
||
this.refresh_team_data();
|
||
DB.changePetName(data, callback);
|
||
}
|
||
|
||
|
||
resetPoint() {
|
||
//重置加点
|
||
this.resetRolePoint();
|
||
this.sendEquipList();
|
||
|
||
this.calculateAttr();
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
this.currentEquips = [];
|
||
//this.send('s2c_player_data', this.getData());
|
||
this.send('s2c_notice', {
|
||
strRichText: '角色加点重置成功！'
|
||
});
|
||
}
|
||
|
||
sendReliveList() {
|
||
this.send('s2c_relive_list', {
|
||
strJson: SKDataUtil.toJson(this.relivelist, "[]")
|
||
});
|
||
}
|
||
|
||
changeReliveList(data: any) {
|
||
if (this.getBagItemNum(10201) <= 0) {
|
||
this.send('s2c_notice', {
|
||
strRichText: '回梦丹不足'
|
||
});
|
||
return;
|
||
}
|
||
this.addItem(10201, -1, false, '转生修正消耗');
|
||
let vecLiveInfo = SKDataUtil.jsonBy(data.strJson);
|
||
if (vecLiveInfo.length != 4)
|
||
return;
|
||
|
||
this.relivelist = [];
|
||
for (var nLive in vecLiveInfo) {
|
||
let stLive = vecLiveInfo[nLive];
|
||
let vecInfo = [GameUtil.getDefault(stLive.nRace, 0), GameUtil.getDefault(stLive.nSex, 0)];
|
||
this.relivelist.push(vecInfo);
|
||
}
|
||
this.calculateAttr();
|
||
this.send('s2c_player_data', this.getData());
|
||
//检查变身卡效果
|
||
ChangeCard.shared.checkCard(this.roleid);
|
||
this.send('s2c_notice', {
|
||
strRichText: '修改成功'
|
||
});
|
||
}
|
||
|
||
getWatcherPlayer() {
|
||
let pMap = MapMgr.shared.getMap(this);
|
||
if (pMap == null) return;
|
||
return pMap.getWatcher(this.onlyid);
|
||
}
|
||
|
||
synPosToWatcher() {
|
||
let mPlayers = this.getWatcherPlayer();
|
||
if (mPlayers) {
|
||
mPlayers[this.onlyid] = this;
|
||
for (const key in mPlayers) {
|
||
let p = mPlayers[key];
|
||
if (p.isPlayer())
|
||
p.send('s2c_player_pos', {
|
||
onlyid: this.onlyid,
|
||
x: this.x,
|
||
y: this.y
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
addShuiluScore(jifen: any, gongji: any, iswin: any) {
|
||
this.shuilu.gongji += parseInt(gongji);
|
||
this.shuilu.score += parseInt(jifen);
|
||
if (iswin == 1) {
|
||
this.shuilu.wtime++;
|
||
} else {
|
||
this.shuilu.ltime++;
|
||
}
|
||
}
|
||
|
||
addJingjiScore(jpoint: any, jtime: any) {
|
||
this.arena.jpoint += parseInt(jpoint);
|
||
this.arena.jtime += parseInt(jtime);
|
||
}
|
||
|
||
synInfoToWatcher() {
|
||
let mPlayers = this.getWatcherPlayer();
|
||
if (mPlayers) {
|
||
for (const key in mPlayers) {
|
||
let p = mPlayers[key];
|
||
if (p.isPlayer())
|
||
p.send('s2c_aoi_pinfo', {
|
||
list: [this.toObj()]
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
* 充值奖励
|
||
*/
|
||
chargeReward(data: any) {
|
||
let rewardid = data.rewardid;
|
||
let choose_item = null;
|
||
let num = 1 << (rewardid - 1);
|
||
if ((num & this.rewardrecord) != 0) {
|
||
this.send_notice("你已领过该阶段的奖励了");
|
||
return;
|
||
}
|
||
let list = ChargeConfig.shared.reward_list;
|
||
for (let item of list) {
|
||
if (item.id == rewardid) {
|
||
choose_item = item;
|
||
break;
|
||
}
|
||
}
|
||
let chargesum = ChargeSum.shared.getPlayerChargeSum(this.roleid);
|
||
if (!choose_item || chargesum < choose_item.money) {
|
||
this.send_notice("你的充值积分不够");
|
||
this.send("s2c_charge_reward", { flag: MsgCode.FAILED });
|
||
return;
|
||
}
|
||
this.send("s2c_charge_reward", { flag: MsgCode.SUCCESS });
|
||
for (let item of choose_item.reward) {
|
||
this.addItem(item.gid, item.count, true, '充值奖励');
|
||
}
|
||
this.rewardrecord |= num;
|
||
this.send('s2c_player_data', this.getData());
|
||
}
|
||
|
||
/*
|
||
* 充值奖励
|
||
*/
|
||
spChargeReward(data: any) {
|
||
let rewardid = data.rewardid;
|
||
let choose_item = null;
|
||
let num = 1 << (rewardid - 1);
|
||
if ((num & this.sprewardrecord) != 0) {
|
||
this.send_notice("你已领过该阶段的奖励了");
|
||
return;
|
||
}
|
||
let list = ChargeConfig.shared.spreward_list;
|
||
for (let item of list) {
|
||
if (item.id == rewardid) {
|
||
choose_item = item;
|
||
break;
|
||
}
|
||
}
|
||
let chargesum = ChargeSum.shared.getPlayerChargeSum(this.roleid);
|
||
if (!choose_item || chargesum < choose_item.money) {
|
||
this.send_notice("你的充值积分不够");
|
||
this.send("s2c_charge_reward", { flag: MsgCode.FAILED });
|
||
return;
|
||
}
|
||
this.send("s2c_charge_reward", { flag: MsgCode.SUCCESS });
|
||
for (let item of choose_item.reward) {
|
||
this.addItem(item.gid, item.count, true, '充值奖励');
|
||
}
|
||
this.sprewardrecord |= num;
|
||
this.send('s2c_player_data', this.getData());
|
||
}
|
||
|
||
// 领取首充奖励
|
||
reGetGift() {
|
||
if (this.getgift == 0) {
|
||
return MsgCode.GIFT_HAS_GOT;
|
||
}
|
||
let conf = GameUtil.game_conf.firstCharge;
|
||
if (conf) {
|
||
let message = ``;
|
||
for (let item of conf) {
|
||
message += `物品：${item.name},数量：${item.count}、`;
|
||
this.addItem(item.prop, item.count, false, "首充奖励")
|
||
}
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.ITEM,
|
||
operateDepict: "首充奖励",
|
||
operateResSerial: "",
|
||
operateResName: "",
|
||
operateContent: message
|
||
})
|
||
}
|
||
this.getgift = 0;
|
||
return MsgCode.SUCCESS;
|
||
}
|
||
|
||
getBang() {
|
||
if (this.bangid == 0) {
|
||
return null;
|
||
}
|
||
return BangMgr.shared.getBang(this.bangid);
|
||
}
|
||
// 称谓相关
|
||
addTitle(type: any, titleId: any, value = '', onload = false) {
|
||
let titlesList = this.getTitleItemByTitleId(type, titleId, value)
|
||
if (titlesList.length <= 0) {
|
||
//添加称谓
|
||
let title = { "type": type, "titleid": titleId, "value": value, "onload": onload }
|
||
this.titles.push(title);
|
||
}
|
||
}
|
||
|
||
delTitle(type: any, titleId: any, value = '') {
|
||
let delIndex = -1;
|
||
let delItem = this.titles.find((e: any, index: any): boolean => {
|
||
if (e.type == type && e.titleid == titleId && e.value == value) {
|
||
delIndex = index;
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
if (delIndex >= 0 && delItem) {
|
||
if (delItem.onload) {
|
||
this.titleId = -1;
|
||
this.titleType = -1;
|
||
this.titleVal = '';
|
||
}
|
||
this.titles.splice(delIndex, 1);
|
||
}
|
||
}
|
||
|
||
getTitles() {
|
||
this.send('s2c_title_info', {
|
||
titles: SKDataUtil.toJson(this.titles, "{}"),
|
||
});
|
||
}
|
||
|
||
//通过titleID获取title信息
|
||
getTitleItemByTitleId(type: any, titleId: any, value: any): any {
|
||
return this.titles.filter((e: any) => {
|
||
if (e.type == type && e.titleid == titleId && e.value == value) {
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
}
|
||
|
||
changeTitle(data: any) {
|
||
if (data.operatetype == 1) {
|
||
let res = this.titles.some((e: any) => {
|
||
e.onload = false;
|
||
return true;
|
||
});
|
||
if (res) {
|
||
this.titleId = -1;
|
||
this.titleType = -1;
|
||
this.titleVal = '';
|
||
this.onLoad = false;
|
||
this.send('s2c_title_change', {
|
||
ecode: MsgCode.SUCCESS,
|
||
titleid: 0,
|
||
type: -1,
|
||
value: '',
|
||
operatetype: data.operatetype
|
||
});
|
||
}
|
||
return;
|
||
} else {
|
||
this.titles.forEach((e: any) => {
|
||
if (e.type == data.type && e.titleid == data.titleid) {
|
||
if ((data.type == GameUtil.titleType.BroTitle || data.type == GameUtil.titleType.CoupleTitle) && e.value == data.value) {
|
||
e.onload = !e.onload;
|
||
this.onLoad = true;
|
||
this.titleVal = e.value;
|
||
} else {
|
||
this.onLoad = false;
|
||
e.onload = !e.onload;
|
||
this.titleVal = '';
|
||
}
|
||
this.titleId = e.titleid;
|
||
this.titleType = e.type;
|
||
}
|
||
});
|
||
this.send('s2c_title_change', {
|
||
ecode: MsgCode.SUCCESS,
|
||
title: this.titles,
|
||
titleid: this.titleId,
|
||
type: this.titleType,
|
||
value: this.titleVal,
|
||
operatetype: data.operatetype
|
||
});
|
||
}
|
||
}
|
||
|
||
/*
|
||
* 是否能进行皇城pk
|
||
*/
|
||
canPalaceFight() {
|
||
return (this.mapid == 1206 && this.battle_id == 0);
|
||
}
|
||
|
||
getIsOnline() {
|
||
return !this.offline;
|
||
}
|
||
//变身
|
||
shapeshift(data: any) {
|
||
|
||
}
|
||
|
||
setRoleColor(index1: any, index2: any) {
|
||
let rolecolor = GameUtil.require_ex('../../conf/prop_data/prop_rolecolor.json');
|
||
if (!rolecolor[this.resid]) {
|
||
SKLogger.debug(`prop_rolecolor 未找到${this.resid}`);
|
||
return;
|
||
}
|
||
let data1, data2;
|
||
let canset = true;
|
||
if (index1 != 0) {
|
||
data1 = rolecolor[this.resid]['color1_' + index1];
|
||
if (data1 && parseInt(data1.color, 16) != this.color1) {
|
||
if (!this.bag_list[data1.itemid] || this.bag_list[data1.itemid] < data1.count) {
|
||
canset = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (index2 != 0) {
|
||
data2 = rolecolor[this.resid]['color2_' + index2];
|
||
if (data2 && parseInt(data2.color, 16) != this.color2) {
|
||
if (!this.bag_list[data2.itemid] || this.bag_list[data2.itemid] < data2.count) {
|
||
canset = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (canset) {
|
||
if (data1) {
|
||
this.update_bagitem({
|
||
itemid: data1.itemid,
|
||
count: data1.count,
|
||
operation: 0,
|
||
});
|
||
this.color1 = parseInt(data1.color, 16);
|
||
}
|
||
else {
|
||
this.color1 = 0;
|
||
}
|
||
|
||
if (data2) {
|
||
this.update_bagitem({
|
||
itemid: data2.itemid,
|
||
count: data2.count,
|
||
operation: 0,
|
||
});
|
||
this.color2 = parseInt(data2.color, 16);
|
||
}
|
||
else {
|
||
this.color2 = 0;
|
||
}
|
||
SKLogger.debug(`玩家${this.roleid}成功的进行了染色color1:${this.color1},color2:${this.color2}`);
|
||
this.send('s2c_change_role_color', { color1: this.color1, color2: this.color2, });
|
||
this.send('s2c_notice', { strRichText: '玩家染色成功' });
|
||
// 更新染色部位
|
||
this.color_one_serial = index1;
|
||
this.color_two_serial = index2;
|
||
}
|
||
}
|
||
|
||
clone() {
|
||
let p: any = new Player();
|
||
for (const key in this) {
|
||
if (this.hasOwnProperty(key)) {
|
||
const info = this[key];
|
||
p[key] = info;
|
||
}
|
||
}
|
||
p.accountid = -1;
|
||
p.roleid = -1;
|
||
return p;
|
||
}
|
||
|
||
/*
|
||
* 消耗铃铛进行世界广播
|
||
*/
|
||
costBell(str: any) {
|
||
let bell_count = this.getBagItemNum(10205);
|
||
if (bell_count <= 0) {
|
||
return;
|
||
}
|
||
this.update_bagitem({
|
||
operation: 0,
|
||
count: 1,
|
||
itemid: 10205,
|
||
});
|
||
PlayerMgr.shared.broadcast('s2c_bell_msg', {
|
||
msg: str,
|
||
name: this.name,
|
||
roleid: this.roleid,
|
||
});
|
||
}
|
||
|
||
/*
|
||
* 设置玩家安全锁密码
|
||
*/
|
||
setSafePassword(pass: any, lock: any) {
|
||
this.safe_password = pass;
|
||
this.safe_lock = lock;
|
||
let safecode = this.safe_lock + ':' + this.safe_password;
|
||
DB.setSafecode(this.accountid, safecode, (ret: any) => {
|
||
if (ret == MsgCode.SUCCESS) {
|
||
this.send('s2c_safepass_msg', {
|
||
pass: this.safe_password,
|
||
lock: this.safe_lock,
|
||
});
|
||
}
|
||
else {
|
||
this.safe_password = '';
|
||
this.safe_lock = 0;
|
||
}
|
||
});
|
||
}
|
||
// 骑乘
|
||
ride(horseIndex: number) {
|
||
if (this.horseList.horseIndex == horseIndex) {
|
||
return;
|
||
}
|
||
this.horseList.horseIndex = horseIndex;
|
||
this.syncRide(horseIndex);
|
||
}
|
||
|
||
syncRide(horseIndex: number) {
|
||
let playerList = this.getWatcherPlayer();
|
||
if (playerList) {
|
||
for (const key in playerList) {
|
||
let player = playerList[key];
|
||
if (player.isPlayer()) {
|
||
player.send("s2c_sync_ride", {
|
||
onlyId: this.onlyid,
|
||
horseIndex: horseIndex,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 下马
|
||
get_down() {
|
||
if (this.horseList.horseIndex == 0) {
|
||
return;
|
||
}
|
||
this.horseList.horseIndex = 0;
|
||
this.syncGetDown();
|
||
}
|
||
// 同步下马
|
||
syncGetDown() {
|
||
let mPlayers = this.getWatcherPlayer();
|
||
if (mPlayers) {
|
||
for (const key in mPlayers) {
|
||
let p = mPlayers[key];
|
||
if (p.isPlayer()) {
|
||
p.send('s2c_sync_get_down', {
|
||
onlyId: this.onlyid,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 升级坐骑
|
||
upgradeHorse(data: any) {
|
||
this.horseList.addExp(data.itemId, data.horseIndex);
|
||
}
|
||
// 召唤兽管制改变
|
||
petControl(data: any) {
|
||
let petid = data.petid;
|
||
let control = SKDataUtil.clamp(data.control, 0, 4);
|
||
for (let pet of this.petList) {
|
||
if (pet.petid == petid) {
|
||
if (pet.control == control) {
|
||
return;
|
||
}
|
||
pet.control = control;
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]召唤兽[${pet.name}]管制改变:${control}`);
|
||
pet.calculateAttribute();
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player) {
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.PET,
|
||
operateDepict: "宠物管制",
|
||
operateResSerial: pet.petid,
|
||
operateResName: pet.name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
this.getPetlist();
|
||
return;
|
||
}
|
||
}
|
||
SKLogger.warn(`玩家[${this.roleid}:${this.name}]召唤兽管制找不到:${petid}:${control}`);
|
||
}
|
||
// 更新召唤兽管制属性
|
||
updatePetControl(control: number) {
|
||
let hasChange = false;
|
||
for (let pet of this.petList) {
|
||
if (pet.control == control) {
|
||
hasChange = true;
|
||
pet.calculateAttribute();
|
||
SKLogger.debug(`玩家[${this.name}(${this.roleid})]召唤兽[${pet.name}管制更新属性:${control}`)
|
||
}
|
||
}
|
||
if (hasChange) {
|
||
this.getPetlist();
|
||
}
|
||
}
|
||
//召唤兽天策符属性
|
||
petOfudaAttr(skill: SkillBase, addition: number, pet: any) {
|
||
let level = 0;
|
||
let bang = BangMgr.shared.getBang(this.bangid);
|
||
if (bang) {
|
||
let list = bang.rolelist;
|
||
for (let key in list) {
|
||
if (this.roleid == list[key].roleid) {
|
||
level = list[key].ofudalevel;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (pet != null) {
|
||
return pet.checkOfudaSkill(skill, addition, level);
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
getPlayerInfoById() {
|
||
let fp = FivePhases.shared.getFivePhasesByRoleid(this.roleid);
|
||
let effid = SpecialEffect.shared.getSuiEffect(this.roleid);
|
||
let effectid = 0;
|
||
let oflevel = 0;
|
||
let score = 0;
|
||
if (effid > 0) {
|
||
effectid = effid;
|
||
}
|
||
let bang = BangMgr.shared.getBang(this.bangid);
|
||
if (bang) {
|
||
let list = bang.rolelist;
|
||
for (let key in list) {
|
||
if (this.roleid == list[key].roleid) {
|
||
oflevel = list[key].ofudalevel;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
//如果是龙族就去掉逆鳞技能
|
||
if (this.race == 5) {
|
||
delete this.skill_list[1045]
|
||
}
|
||
|
||
let listInfo = [];
|
||
for (let equip of this.currentEquips) {
|
||
let full = equip.getFullData();
|
||
if (full) {
|
||
score += Number(full.BaseScore);
|
||
let equip: Equip = this.equipObjs[full.EquipID];
|
||
listInfo.push(equip.toObj());
|
||
}
|
||
}
|
||
|
||
let petInfo = [];
|
||
for (let pet of this.petList) {
|
||
petInfo.push(pet.toObj())
|
||
}
|
||
|
||
let obj = {
|
||
roleid: this.roleid,
|
||
name: this.name,
|
||
resid: this.resid,
|
||
race: this.race,
|
||
sex: this.sex,
|
||
relive: this.relive,
|
||
level: this.level,
|
||
xiulevel: this.xiulevel,
|
||
bangname: this.bangname,
|
||
score: score,
|
||
color1: this.color1,
|
||
color2: this.color2,
|
||
wingId: this.wingId,
|
||
effectlist: SKDataUtil.toJson(SpecialEffect.shared.getUseingEffect(this.roleid), "{}"),
|
||
effectid: effectid,
|
||
weapon: this.getWeapon(),
|
||
oflevel: oflevel,
|
||
fplevel: fp == null ? 0 : fp.fplevel,
|
||
jin: fp == null ? 0 : fp.jinlevel,
|
||
mu: fp == null ? 0 : fp.mulevel,
|
||
shui: fp == null ? 0 : fp.shuilevel,
|
||
huo: fp == null ? 0 : fp.huolevel,
|
||
tu: fp == null ? 0 : fp.tulevel,
|
||
skill: SKDataUtil.toJson(this.skill_list, "{}"),
|
||
currentEquips: SKDataUtil.toJson(listInfo, "{}"),
|
||
petInfo: SKDataUtil.toJson(petInfo, "{}"),
|
||
}
|
||
|
||
return obj;
|
||
}
|
||
|
||
/**
|
||
* 分享世界
|
||
* 获取道具信息
|
||
* type 1：装备，2：道具，3：宠物，4：坐骑，5：称谓
|
||
*/
|
||
goodsInfo(data: any) {
|
||
if (data.type == 1) {
|
||
// 装备信息
|
||
let callback = (ret: any, item: any) => {
|
||
if (ret == MsgCode.SUCCESS) {
|
||
item = item[0];
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(item.roleid);
|
||
let obj: any = {};
|
||
// 判断玩家是否在线（查数据库）
|
||
if (player.offline) {
|
||
let equipdata: any = EquipMgr.shared.getEquipData({ resid: item.Type, type: item.EquipType });
|
||
if (equipdata == null) {
|
||
SKLogger.warn(`装备[${item.EquipID}:${this.name}]完整信息为空!`);
|
||
this.send_notice(`获取信息失败！`);
|
||
return;
|
||
}
|
||
obj.EquipID = item.EquipID;
|
||
obj.EquipType = item.EquipType;
|
||
obj.BaseAttr = SKDataUtil.toJson(item.BaseAttr, "{}");
|
||
obj.BaseScore = equipdata.BaseScore;
|
||
obj.EDesc = equipdata.EDesc;
|
||
obj.Detail = equipdata.Detail;
|
||
obj.Dynamic = equipdata.Dynamic;
|
||
obj.Grade = item.Grade;
|
||
obj.EIndex = item.EIndex;
|
||
obj.JiLv = equipdata.JiLv;
|
||
obj.MaxEmbedGemCnt = equipdata.MaxEmbedGemCnt;
|
||
obj.MaxEndure = equipdata.MaxEndure;
|
||
obj.EName = equipdata.EName;
|
||
obj.NeedGrade = equipdata.NeedGrade;
|
||
obj.NeedRei = equipdata.NeedRei;
|
||
obj.NextType = equipdata.NextType;
|
||
obj.Overlap = equipdata.Overlap;
|
||
obj.Quan = equipdata.Quan;
|
||
obj.Race = equipdata.Race;
|
||
obj.Rarity = equipdata.Rarity;
|
||
obj.RndRange = equipdata.RndRange;
|
||
obj.RndWeight = equipdata.RndWeight;
|
||
obj.Sex = equipdata.Sex;
|
||
obj.Shape = equipdata.Shape;
|
||
obj.Shuxingxuqiu = SKDataUtil.toJson(item.Shuxingxuqiu, "{}");
|
||
obj.Type = item.Type;
|
||
obj.GemCnt = item.GemCnt;
|
||
obj.LianhuaAttr = SKDataUtil.toJson(item.LianhuaAttr, "{}");
|
||
obj.OwnerRoleId = equipdata.OwnerRoleId;
|
||
obj.refine = SKDataUtil.toJson(item.refine, "{}");
|
||
obj.recast = SKDataUtil.toJson(item.recast, "{}");
|
||
} else { // 在线则查缓存中的数据
|
||
let equip: Equip = player.equipObjs[item.EquipID];
|
||
if (equip != null && equip != undefined) {
|
||
obj = equip.toObj();
|
||
} else {
|
||
this.send_notice(`获取信息失败！`);
|
||
return;
|
||
}
|
||
|
||
}
|
||
obj.name = item.name;
|
||
obj.roleid = item.roleid;
|
||
this.send('s2s_goods_info', {
|
||
type: data.type,
|
||
info: SKDataUtil.toJson(obj, "{}")
|
||
});
|
||
} else {
|
||
this.send_notice(`获取信息失败！`);
|
||
}
|
||
callback = null;
|
||
}
|
||
DB.equipInfo(data, callback);
|
||
} else if (data.type == 3) {
|
||
// 宠物信息
|
||
let callback = (ret: any, item: any) => {
|
||
if (ret == MsgCode.SUCCESS) {
|
||
let obj: any = item[0];
|
||
if (obj) {
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(obj.roleid);
|
||
// 判断玩家是否在线（查数据库）
|
||
if (player == null || player == undefined) {
|
||
DB.loginByRoleid(obj.roleid, (code: any, info: any) => {
|
||
let pet: any = new Pet(obj.dataid);
|
||
let player = new Player();
|
||
player.setDB(info);
|
||
pet.setDB(obj);
|
||
pet.setOwner(player)
|
||
// 坐骑
|
||
player.horseList.setDB(info.horseRows);
|
||
player.horseList.horseIndex = SKDataUtil.clamp(info.horse_index, ERaceType.HUMEN, ERaceType.DRAGON);
|
||
// 坐骑技能
|
||
player.horseSkill.setDB(info.horseSkillRows);
|
||
// 发送前端
|
||
this.sendPetInfo(pet, item[0], data.type, obj.PetName, player.horseSkill.getList(obj.control));
|
||
});
|
||
} else { // 在线则查缓存中的数据
|
||
let arr = player.petList;
|
||
let pet = arr.find(function (pet) {
|
||
return pet.petid === Number(data.id)
|
||
})
|
||
// 发送前端
|
||
this.sendPetInfo(pet, item[0], data.type, obj.PetName, this.horseSkill.getList(pet.control));
|
||
}
|
||
} else {
|
||
this.send_notice(`获取信息失败！`);
|
||
}
|
||
|
||
} else {
|
||
this.send_notice(`获取信息失败！`);
|
||
}
|
||
callback = null;
|
||
}
|
||
DB.petInfo(data, callback);
|
||
} else if (data.type == 2 || data.type == 5 || data.type == 6) {
|
||
// 道具信息
|
||
let obj: any = {};
|
||
obj.id = data.id
|
||
this.send('s2s_goods_info', {
|
||
type: data.type,
|
||
info: JSON.stringify(obj)
|
||
});
|
||
}
|
||
// 查询队伍信息
|
||
else if (data.type == 9) {
|
||
this.send('s2s_goods_info', {
|
||
type: data.type,
|
||
info: SKDataUtil.toJson(TeamMgr.shared.teamListInfo(data.id), "{}")
|
||
});
|
||
}
|
||
else {
|
||
this.send_notice(`该道具查询未生效！`);
|
||
return;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送宠物详情
|
||
* @param pet 宠物信息
|
||
* @param item 角色信息
|
||
* @param type 返回类型
|
||
* @param petName 角色名称
|
||
* @param horseSkill 坐骑技能
|
||
*/
|
||
sendPetInfo(pet: any, item: any, type: number, petName: string, horseSkill: any) {
|
||
let obj = pet.toObj();
|
||
obj.PetName = petName;
|
||
obj.name = item.name;
|
||
obj.roleid = item.roleid;
|
||
obj.horseSkill = horseSkill;
|
||
this.send('s2s_goods_info', {
|
||
type: type,
|
||
info: SKDataUtil.toJson(obj, "{}")
|
||
});
|
||
}
|
||
//检查是否可以兑换
|
||
checkExchange(code: any) {
|
||
if (this.exchange.hasCode(code)) {
|
||
this.send_notice(`您的兑换码[${code}]已经兑换过了!`);
|
||
return;
|
||
}
|
||
this.exchange.checkCode(code, this);
|
||
}
|
||
// 获得坐骑技能列表
|
||
getHorseSkill() {
|
||
let params = this.horseSkill.toObj();
|
||
this.send('s2c_horse_skill', params);
|
||
}
|
||
// 升级坐骑技能
|
||
upgradeHorseSkill(data: any) {
|
||
let skill = this.horseSkill.getSkill(data.position);
|
||
if (skill == null) {
|
||
return;
|
||
}
|
||
let exp = SKDataUtil.clamp(skill.exp + 150, 0, 20000);
|
||
if (skill.exp >= exp) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `坐骑技能[${skill.skill_name}]熟练度已升满!`
|
||
});
|
||
return;
|
||
}
|
||
let itemData = ItemUtil.getItemData(GameUtil.horseSkillUpItemId);
|
||
let count = ItemUtil.getBagItemCount(this, itemData.id);
|
||
if (count < 3) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `您需要至少3个[${itemData.name}]才能升级坐骑技能!`
|
||
});
|
||
return;
|
||
}
|
||
let old = skill.exp;
|
||
skill.exp = exp;
|
||
this.addItem(itemData.id, -3, false, "升级坐骑技能");
|
||
SKLogger.debug(`玩家[${this.roleid}:${this.name}]坐骑技能[${skill.skill_name}]升级经验:${old}->${skill.exp}`);
|
||
let player = PlayerMgr.shared.getPlayerByRoleId(this.roleid);
|
||
if (player) {
|
||
//cxf坐骑技能升级
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: player.roleid,
|
||
roleName: player.name,
|
||
operateType: Operate.HORSE,
|
||
operateDepict: "坐骑技能升级",
|
||
operateResSerial: skill.skill_id,
|
||
operateResName: skill.skill_name,
|
||
operateContent: ""
|
||
})
|
||
}
|
||
this.updatePetControl(Math.floor(data.position / 3) + 1);
|
||
let params = this.horseSkill.toObj();
|
||
this.send("s2c_horse_skill", params);
|
||
}
|
||
// 坐骑洗炼
|
||
horseRefining(data: any) {
|
||
this.horseSkill.refining(data);
|
||
}
|
||
// 领取每日充值奖励
|
||
dayReward(data: any) {
|
||
let key = data.money;
|
||
let receive = (this.dayMap[`day_${key}`] || 0);
|
||
if (receive > 0) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `您已领取每日充值${key}元奖励!`
|
||
});
|
||
return;
|
||
}
|
||
if ((this.getBagItemAllKindNum() + 4) >= this.bagKindNum) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `背包没有足够的空间，无法领取每日充值${key}元奖励!`
|
||
});
|
||
return;
|
||
}
|
||
let reward = ChargeSum.shared.dayReward[key];
|
||
let message = ``;
|
||
for (let item of reward) {
|
||
message += `物品：${item.item_name},数量：${item.count}、`;
|
||
this.addItem(item.item_id, item.count, true, `每日充值${key}元奖励`);
|
||
}
|
||
this.dayMap[`day_${key}`] = 1;
|
||
this.send(`s2c_day_reward`, {
|
||
dayMap: SKDataUtil.toJson(this.dayMap, "{}")
|
||
});
|
||
SKCxfUtil.getCxfRecordOperate({
|
||
roleId: this.roleid,
|
||
roleName: this.name,
|
||
operateType: Operate.ITEM,
|
||
operateDepict: "每日充值奖励",
|
||
operateResSerial: "",
|
||
operateResName: "",
|
||
operateContent: message
|
||
})
|
||
}
|
||
//新用户绑定
|
||
roleBinding(bPlayer: any) {
|
||
let list = PaiHangMgr.shared.bind_player_list;
|
||
for (let key in list) {
|
||
let bplayer = list[key];
|
||
if (this.roleid == bplayer.roleid) {
|
||
this.send_notice("您已经绑定过玩家了！");
|
||
return;
|
||
}
|
||
}
|
||
PaiHangMgr.shared.bind_player_list.push({
|
||
roleid: this.roleid,
|
||
name: this.name,
|
||
resid: this.resid,
|
||
relive: this.relive,
|
||
level: this.level,
|
||
bind_roleid: bPlayer.roleid,
|
||
bind_name: bPlayer.name,
|
||
bind_resid: bPlayer.resid,
|
||
bind_relive: bPlayer.relive,
|
||
bind_level: bPlayer.level
|
||
})
|
||
let sql = `INSERT INTO qy_binding(roleid, name, resid, relive, level, bind_roleid, bind_name, bind_resid, bind_relive, bind_level) VALUES(${this.roleid},'${this.name}',${this.resid},${this.relive},${this.level},${bPlayer.roleid},'${bPlayer.name}',${bPlayer.resid},${bPlayer.relive},${bPlayer.level});`;
|
||
DB.query(sql, (error: any, rows: any) => {
|
||
if (error) {
|
||
let info = DB.errorInfo(error);
|
||
SKLogger.warn(`数据插入错误[${info}]`);
|
||
return;
|
||
}
|
||
if (rows.length == 0) {
|
||
return;
|
||
}
|
||
})
|
||
this.send('s2c_notice', {
|
||
strRichText: `绑定成功！`
|
||
})
|
||
}
|
||
// 领取VIP每日奖励
|
||
vipReward(data: any) {
|
||
let type = data.type;
|
||
let vipLevel = data.vipLevel;
|
||
let chargeSum = ChargeSum.shared.getPlayerChargeSum(this.roleid);
|
||
let myVip = VIPUtil.getVipLevel(chargeSum);
|
||
if (vipLevel > myVip) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `您不能领取高于自己VIP${vipLevel}每日奖励!`
|
||
});
|
||
return;
|
||
}
|
||
let receive = (this.dayMap[`vip_${vipLevel}`] || 0);
|
||
if (receive > 0) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `您已领取VIP${vipLevel}每日奖励!`
|
||
});
|
||
return;
|
||
}
|
||
if ((this.getBagItemAllKindNum() + 4) >= this.bagKindNum) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `背包没有足够的空间，无法领取VIP${vipLevel}每日奖励!`
|
||
});
|
||
return;
|
||
}
|
||
let reward = VIPUtil.getVipReward(vipLevel);
|
||
if (reward == null) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `奖励物品错误，无法领取VIP${vipLevel}每日奖励!`
|
||
});
|
||
return;
|
||
}
|
||
for (let itemData of reward) {
|
||
this.addItem(itemData.id, itemData.count, true, `VIP${vipLevel}每日奖励`);
|
||
}
|
||
this.dayMap[`vip_${vipLevel}`] = 1;
|
||
this.send(`s2c_vip_reward`, {
|
||
dayMap: SKDataUtil.toJson(this.dayMap, "{}")
|
||
});
|
||
}
|
||
// 挖宝列表
|
||
dugList(data: any) {
|
||
let type = data.type;
|
||
let dug = this.dayMap[`dug_${type}`];
|
||
if (!DugMgr.enabled) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `今日挖宝活动已关闭,何时开启另行通知!`,
|
||
});
|
||
if (dug == null) {
|
||
this.dayMap[`dug_${type}`] = DugMgr.shared.update(type);
|
||
}
|
||
this.send(`s2c_dug_list`, {
|
||
dayMap: SKDataUtil.toJson(this.dayMap, "{}")
|
||
});
|
||
return;
|
||
};
|
||
if (dug == null) {
|
||
this.dayMap[`dug_${type}`] = DugMgr.shared.update(type);
|
||
} else {
|
||
let count = (dug.count != null ? dug.count : -1);
|
||
if (count < 0) {
|
||
// 10万仙玉刷新
|
||
let updateJade = DugMgr.updateJade;
|
||
if (this.jade < updateJade) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `挖宝刷新需要消耗${this.jade}仙玉不足`,
|
||
});
|
||
} else {
|
||
this.addMoney(GameUtil.goldKind.Jade, -100000, `挖宝刷新消耗仙玉${updateJade}`, MsgCode.SUCCESS);
|
||
this.dayMap[`dug_${type}`] = DugMgr.shared.update(type);
|
||
}
|
||
}
|
||
}
|
||
this.send(`s2c_dug_list`, {
|
||
dayMap: SKDataUtil.toJson(this.dayMap, "{}")
|
||
});
|
||
}
|
||
// 开挖
|
||
dug(data: any) {
|
||
let index = data.index;
|
||
if (!DugMgr.enabled) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `今日挖宝活动已关闭,何时开启另行通知!`,
|
||
});
|
||
this.send(`s2c_dug`, {
|
||
state: 0,
|
||
index: index
|
||
});
|
||
return;
|
||
};
|
||
let type = data.type;
|
||
let dug = this.dayMap[`dug_${type}`];
|
||
if (dug == null) {
|
||
return;
|
||
}
|
||
if (index == -1) {
|
||
this.dayMap[`dug_${type}`] = DugMgr.shared.start(dug);
|
||
this.send(`s2c_dug_list`, {
|
||
dayMap: SKDataUtil.toJson(this.dayMap, "{}")
|
||
});
|
||
} else {
|
||
// 已挖处理
|
||
if (dug.list[index].done == 1) {
|
||
this.send('s2c_notice', {
|
||
strRichText: `您第${dug.count + 1}次挖宝奖励已挖!`,
|
||
});
|
||
return;
|
||
}
|
||
// 扣除仙玉
|
||
let reward = dug.list[index];
|
||
let itemData = ItemUtil.getItemData(reward.item_id);
|
||
if (itemData == null) {
|
||
this.send_notice(`您第${dug.count + 1}次挖宝奖励不存在!`);
|
||
this.send(`s2c_dug`, {
|
||
state: 0,
|
||
index: index
|
||
});
|
||
return;
|
||
}
|
||
let jade = DugMgr.shared.getJade(dug.count);
|
||
if (this.jade < jade) {
|
||
this.send_notice(`您第${dug.count + 1}次挖宝消耗仙玉${jade}不足`);
|
||
this.send(`s2c_dug`, {
|
||
state: 0,
|
||
index: index
|
||
});
|
||
return;
|
||
}
|
||
this.addMoney(GameUtil.goldKind.Jade, -jade, `您第${dug.count + 1}次挖宝消耗仙玉${jade}`, MsgCode.SUCCESS);
|
||
dug.count = dug.count + 1;
|
||
dug.list[index].done = 1;
|
||
this.addItem(reward.item_id, reward.count, true, `挖宝奖励`);
|
||
SKLogger.info(`玩家[${this.roleid}:${this.name}]第${dug.count + 1}次挖宝消耗仙玉${jade},获得奖励[${itemData.name}]${reward.count}个`);
|
||
this.send(`s2c_dug`, {
|
||
state: 1,
|
||
index: index
|
||
});
|
||
}
|
||
}
|
||
|
||
// ------------------------------------------------------- 公共方法 ---------------------------------------------------
|
||
/**
|
||
* 发送信息
|
||
* @param msg 内容
|
||
*/
|
||
send_notice(msg: string) {
|
||
this.send('s2c_notice', {
|
||
strRichText: msg,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 发送信息 - 信息
|
||
* @param msg 内容
|
||
*/
|
||
send_message(msg: string) {
|
||
this.send('s2c_game_chat', {
|
||
scale: 7,
|
||
msg: msg,
|
||
name: '',
|
||
resid: 0,
|
||
teamid: 0,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 跳转地图
|
||
* @param id 地图编号
|
||
*/
|
||
map_transfer(id: any, coordx: number = 0, coordy: number = 0) {
|
||
this.send('s2c_map_transfer', {
|
||
mapId: id,
|
||
coordx: coordx,
|
||
coordy: coordy,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 刷新队伍信息
|
||
*/
|
||
refresh_team_data() {
|
||
// 判断玩家是否在队伍中
|
||
if (this.teamid > 0) {
|
||
TeamMgr.shared.sendInfoToMember(this.teamid)
|
||
}
|
||
}
|
||
|
||
getZhenFaInfo() {
|
||
var json = this.ZFMgr.toJson()
|
||
this.send('s2c_getZhenFaInfo', {
|
||
info: json
|
||
});
|
||
}
|
||
|
||
upLevelZhenFa(index: number, level: number) {
|
||
var lv = this.ZFMgr.getZhenFaLevelByPos(index)
|
||
const l = level - lv
|
||
if (0 >= l) {
|
||
this.send_notice(`该阵法位置等级信息错误,请稍后再试!`);
|
||
return false
|
||
}
|
||
const count = ItemUtil.getBagItemCount(this, 2000030)
|
||
const _count = (l * 5)
|
||
if (count < _count) {
|
||
this.send_notice(`您的荒玉道具不足,请及时购买!`);
|
||
return false
|
||
}
|
||
|
||
this.addBagItem(2000030, 0 - _count, false)
|
||
this.ZFMgr.upLevel(index, level)
|
||
this.onZhenFaChange()
|
||
return true
|
||
}
|
||
|
||
equipXwItem(data: any) {
|
||
if (!this.bag_list[data.itemID]) {//如果没有在背包中
|
||
if (!!this.ZFMgr.isEquip(data.itemID)) {
|
||
var index = this.ZFMgr.getEquipIndex(data.itemID)//获取装备位
|
||
if (-1 != index) {
|
||
if (!!this.ZFMgr.dumpXw(index)) {//卸下信物
|
||
var oldXw = this.ZFMgr.equipXw(data.pos, data.itemID)
|
||
if (0 != oldXw)
|
||
this.addBagItem(oldXw, 1, false)
|
||
this.onZhenFaChange()
|
||
} else {
|
||
SKLogger.warn(`卸下信物失败!`);
|
||
}
|
||
} else {
|
||
SKLogger.warn(`在阵法对应位置上未找到该信物!`);
|
||
}
|
||
} else {
|
||
this.send_notice(`您没有该信物,请通过多宝商店进行购买!`);
|
||
}
|
||
} else if (!!this.bag_list[data.itemID]) {//如果在背包中
|
||
this.addBagItem(data.itemID, -1, false)
|
||
var oldXw = this.ZFMgr.equipXw(data.pos, data.itemID)
|
||
if (0 != oldXw)
|
||
this.addBagItem(oldXw, 1, false)
|
||
this.onZhenFaChange()
|
||
} else {
|
||
this.send_notice(`您没有该信物,请通过多宝商店进行购买!`);
|
||
}
|
||
}
|
||
//激活阵法位
|
||
active_zhenfa_position(data: any) {
|
||
this.ZFMgr.saveActiveInde(data.index)//保存激活位
|
||
var list = this.ZFMgr.getZhenFaItem()//获取阵法上的所有装备
|
||
if (0 < list.length) {
|
||
const count = list.length
|
||
for (var i = 0; i < count; ++i) {
|
||
this.addBagItem(list[i], 1, false)
|
||
}
|
||
}
|
||
this.ZFMgr.clearInfo()//清空阵法信息
|
||
var list = ItemUtil.getBagXwItem(this)
|
||
var info = ZhenFaUtil.getZhenFaInfo(data.index)//获取阵法位信息
|
||
const count = info.valid_pos.length
|
||
for (var i = 0; i < count; ++i) {
|
||
//随机信物道具
|
||
if (0 < list.length) {
|
||
var index = Math.floor((Math.random() * 100)) % list.length
|
||
if (!!this.ZFMgr.active(info.valid_pos[i], list[index].id)) {
|
||
this.addBagItem(list[index].id, -1, false)
|
||
list.splice(index, 1)
|
||
}
|
||
} else {
|
||
this.ZFMgr.active(info.valid_pos[i], 0)
|
||
}
|
||
}
|
||
this.onZhenFaChange()
|
||
return true
|
||
}
|
||
|
||
onZhenFaChange() {
|
||
this.calculateAttr();
|
||
for (let pet of this.petList) {
|
||
pet.calculateAttribute();
|
||
}
|
||
this.send('s2c_player_data', this.getData());
|
||
this.getZhenFaInfo()
|
||
}
|
||
|
||
succinct(data: any) {
|
||
let cnt = ItemUtil.getBagItemCount(this, 2000031)
|
||
if (cnt < 1) {
|
||
return this.send("s2c_xw_normal_succinct", {
|
||
ret: 1, // 缺少五色石
|
||
})
|
||
}
|
||
|
||
let money = this.GetMoney(GameUtil.goldKind.Money)
|
||
if (money < 300000) {
|
||
return this.send("s2c_xw_normal_succinct", {
|
||
ret: 2, // 缺少银两
|
||
})
|
||
}
|
||
|
||
this.update_bagitem({ operation: 0, itemid: 2000031, count: 1 })
|
||
this.addMoney(GameUtil.goldKind.Jade, -300000)
|
||
|
||
this.list.splice(0, this.list.length)
|
||
var info = this.XWMgr.succinct(data.itemID)
|
||
if (!!info) {
|
||
this.XWMgr.setNewAttrInfo(data.itemID, info)
|
||
this.list.push(info)
|
||
}
|
||
|
||
this.send("s2c_xw_normal_succinct", {
|
||
ret: 0,
|
||
list: SKDataUtil.toJson(this.list, "{}")
|
||
})
|
||
}
|
||
//获取属性信息
|
||
getAttrInfo(data: any) {
|
||
var info: any = this.XWMgr.getAttrInfo(data.itemID)
|
||
this.send("s2c_getXwAttrInfo", {
|
||
pos1: info.pos1,
|
||
attr1: info.attr1,
|
||
value1: info.value1,
|
||
|
||
pos2: info.pos2,
|
||
attr2: info.attr2,
|
||
value2: info.value2,
|
||
|
||
pos3: info.pos3,
|
||
attr3: info.attr3,
|
||
value3: info.value3,
|
||
|
||
max1: info.max1,
|
||
max2: info.max2,
|
||
max3: info.max3
|
||
})
|
||
}
|
||
|
||
getAllAttrInfo(data: any) {
|
||
var attr_info = this.XWMgr.getAttrInfo(data.itemID)
|
||
console.log("attr_info:", attr_info)
|
||
var new_info = this.XWMgr.getNewAttrInfo(data.itemID)
|
||
console.log("new_info:", new_info)
|
||
this.send("s2c_getAttrInfo", {
|
||
attrList: SKDataUtil.toJson(attr_info, "{}"),
|
||
succintAttrList: SKDataUtil.toJson({ list: new_info }, "{}")
|
||
})
|
||
}
|
||
|
||
replaceAttribute(data: any) {
|
||
var code = this.XWMgr.replaceAttr(data.itemID)
|
||
if (0 == code) {
|
||
var item = this.XWMgr.getXwItem(data.itemID)
|
||
if (!!item) {
|
||
var attr_info = this.XWMgr.getAttrInfo(data.itemID)
|
||
var new_info = this.XWMgr.getNewAttrInfo(data.itemID)
|
||
this.send("s2c_replaceattribute", {
|
||
itemID: data.itemID,
|
||
attrList: SKDataUtil.toJson(attr_info, "{}"),
|
||
succintAttrList: SKDataUtil.toJson(new_info, "{}"),
|
||
})
|
||
}
|
||
} else if (1 == code) {
|
||
this.send_notice("洗练失败不能替换信物属性")
|
||
} else if (2 == code) {
|
||
this.send_notice("没有找到该信物")
|
||
}
|
||
this.getZhenFaInfo()
|
||
this.calculateAttr();
|
||
this.send('s2c_player_data', this.getData());
|
||
}
|
||
|
||
getBabySkillConfig(data: any) {
|
||
//todo
|
||
let msg = GameUtil.require_ex("../../conf/prop_data/prop_baby_skill.json")
|
||
this.send("s2c_getBabySkillConfig", {
|
||
config: SKDataUtil.toJson(msg, "{}"),
|
||
})
|
||
}
|
||
|
||
adoptBaby(data: any) {
|
||
let baby = this.BabyMgr.AdoptBaby(data.sex)
|
||
let ret = 1
|
||
let jsonBaby = ""
|
||
if (baby != null) {
|
||
ret = 0
|
||
jsonBaby = baby.ToJson()
|
||
this.addMoney(GameUtil.goldKind.Jade, -6000000)
|
||
}
|
||
this.send("s2c_adoptBaby", {
|
||
ret: ret,
|
||
baby: jsonBaby
|
||
})
|
||
|
||
if (this.BabyMgr.BabyList.length == 1) {
|
||
this.BabyMgr.SetBattle(baby.ID)
|
||
this.send("s2c_babyBattle", {
|
||
ret: ret,
|
||
baby: baby.ToJson()
|
||
})
|
||
}
|
||
}
|
||
|
||
babyBattle(data: any) {
|
||
let baby = this.BabyMgr.SetBattle(data.id)
|
||
let ret = 1
|
||
let jsonBaby = ""
|
||
if (baby != null) {
|
||
ret = 0
|
||
jsonBaby = baby.ToJson()
|
||
}
|
||
this.send("s2c_babyBattle", {
|
||
ret: ret,
|
||
baby: baby.ToJson()
|
||
})
|
||
}
|
||
|
||
babySkillBless(data: any) {
|
||
let hasCnt = ItemUtil.getBagItemCount(this, 9651)
|
||
if (hasCnt < 1) {
|
||
this.send("s2c_babySkillBless", {
|
||
ret: 1,
|
||
id: data.id,
|
||
})
|
||
return
|
||
}
|
||
|
||
let skill = this.BabyMgr.Bless(data.id)
|
||
let ret = 1
|
||
let jsonSkill = ""
|
||
if (skill != null) {
|
||
ret = 0
|
||
jsonSkill = SKDataUtil.toJson(skill, "{}")
|
||
this.update_bagitem({ operation: 0, itemid: 9651, count: 1 })
|
||
|
||
}
|
||
this.send("s2c_babySkillBless", {
|
||
ret: ret,
|
||
id: data.id,
|
||
skill: jsonSkill
|
||
})
|
||
}
|
||
|
||
babySkillUpgrade(data: any) {
|
||
let _skill = this.BabyMgr.GetBabySkill(data.id, data.skillId)
|
||
if (_skill == null) {
|
||
this.send("s2c_babySkillUpgrade", {
|
||
ret: 1,
|
||
id: data.id,
|
||
})
|
||
return
|
||
}
|
||
|
||
if (_skill.level >= 100) {
|
||
this.send("s2c_babySkillUpgrade", {
|
||
ret: 3,
|
||
id: data.id,
|
||
})
|
||
return
|
||
}
|
||
|
||
let need = _skill.level * 5
|
||
let hasCnt = ItemUtil.getBagItemCount(this, 9650)
|
||
|
||
let hasMoney = this.GetMoney(GameUtil.goldKind.Money)
|
||
if (hasCnt < need || hasMoney < 1000000) {
|
||
this.send("s2c_babySkillUpgrade", {
|
||
ret: 1,
|
||
id: data.id,
|
||
})
|
||
return
|
||
}
|
||
|
||
let ret = this.BabyMgr.Upgrade(data.id, data.skillId)
|
||
let jsonSkill = ""
|
||
if (ret == 0) {
|
||
let skill = this.BabyMgr.GetBabySkill(data.id, data.skillId)
|
||
jsonSkill = SKDataUtil.toJson(skill, "{}")
|
||
|
||
this.addMoney(GameUtil.goldKind.Money, -1000000)
|
||
this.update_bagitem({ operation: 0, itemid: 9650, count: need })
|
||
}
|
||
this.send("s2c_babySkillUpgrade", {
|
||
ret: ret,
|
||
id: data.id,
|
||
skill: jsonSkill
|
||
})
|
||
}
|
||
|
||
babySkillBattle(data: any) {
|
||
let skill = this.BabyMgr.SkillBattle(data.id, data.skillId)
|
||
let ret = 1
|
||
let jsonSkill = ""
|
||
if (skill != null) {
|
||
ret = 0
|
||
jsonSkill = SKDataUtil.toJson(skill, "{}")
|
||
}
|
||
this.send("s2c_babySkillBattle", {
|
||
ret: ret,
|
||
id: data.id,
|
||
skill: jsonSkill
|
||
})
|
||
}
|
||
|
||
babyPracticeConfig(data?: any) {
|
||
let config = GameUtil.require_ex("../../conf/prop_data/prop_baby_practice.json")
|
||
this.send("s2c_babyPracticeConfig", {
|
||
config: SKDataUtil.toJson(config, "{}")
|
||
})
|
||
}
|
||
|
||
//0 成功 1 失败 2 疲劳已满 3 属性已加至最高
|
||
babyPractice(data: any) {
|
||
let ret = this.BabyMgr.Practice(data.id, data.type, data.class)
|
||
let babyJson = ""
|
||
if (ret == 0) {
|
||
let baby = this.BabyMgr.GetBabyByID(data.id)
|
||
babyJson = baby.ToJson()
|
||
}
|
||
|
||
this.send("s2c_babyPractice", {
|
||
ret: ret,
|
||
baby: babyJson
|
||
})
|
||
}
|
||
|
||
BabyEatCandy(babyId: number): boolean {
|
||
let ret = this.BabyMgr.EatCandy(babyId)
|
||
let babyJson = ""
|
||
if (ret == 0) {
|
||
let baby = this.BabyMgr.GetBabyByID(babyId)
|
||
babyJson = baby.ToJson()
|
||
}
|
||
|
||
this.send("s2c_babyPractice", {
|
||
ret: ret,
|
||
baby: babyJson
|
||
})
|
||
return ret == 0
|
||
}
|
||
|
||
ReadingBook(babyId: number): boolean {
|
||
let ret = this.BabyMgr.ReadingBook(babyId)
|
||
let babyJson = ""
|
||
if (ret == 0) {
|
||
let baby = this.BabyMgr.GetBabyByID(babyId)
|
||
babyJson = baby.ToJson()
|
||
}
|
||
|
||
this.send("s2c_babyPractice", {
|
||
ret: ret,
|
||
baby: babyJson
|
||
})
|
||
return ret == 0
|
||
}
|
||
|
||
//获取新属性信息
|
||
getNewAttrInfo(data: any) {
|
||
var info: any = this.XWMgr.getNewAttrInfo(data.itemID)
|
||
var strList = SKDataUtil.toJson([info], "{}")
|
||
this.send("s2c_getNewAttrInfo", {
|
||
list: strList
|
||
})
|
||
}
|
||
//清除所有新属性信息
|
||
clearNewAttrInfo() {
|
||
this.XWMgr.clearNewAttrInfo()
|
||
}
|
||
|
||
upgradeStar(data: any) {
|
||
let ret = this.StarMgr.Upgrade(data.starid, data.upgrade)
|
||
if (ret != 0) {
|
||
return this.send("s2c_upgradeStar", { ret: ret })
|
||
}
|
||
|
||
let star = this.StarMgr.GetStarByID(data.starid)
|
||
let msg = {
|
||
ret: 0,
|
||
starid: data.starid,
|
||
level: star.Level,
|
||
equip: SKDataUtil.toJson(star.EquipAttr, "[]"),
|
||
fresh: SKDataUtil.toJson(star.FreshAttr, "[]")
|
||
}
|
||
this.send("s2c_upgradeStar", msg)
|
||
|
||
this.calculateAttr()
|
||
this.send('s2c_player_data', this.getData());
|
||
}
|
||
|
||
getNewStarAttr(data: any) {
|
||
let ret = this.StarMgr.GetNewStarAttr(data.starid)
|
||
if (ret != 0) {
|
||
return this.send("s2c_getNewStarAttr", { ret: ret })
|
||
}
|
||
|
||
let star = this.StarMgr.GetStarByID(data.starid)
|
||
let msg = {
|
||
ret: 0,
|
||
starid: data.starid,
|
||
attr: SKDataUtil.toJson(star.FreshAttr, "[]")
|
||
}
|
||
this.send("s2c_getNewStarAttr", msg)
|
||
}
|
||
|
||
replaceStarAttr(data: any) {
|
||
let ret = this.StarMgr.ReplaceStarAttr(data.starid)
|
||
if (ret != 0) {
|
||
return this.send("s2c_replaceStarAttr", { ret: ret })
|
||
}
|
||
|
||
let star = this.StarMgr.GetStarByID(data.starid)
|
||
let msg = {
|
||
ret: 0,
|
||
starid: data.starid,
|
||
attr: SKDataUtil.toJson(star.EquipAttr, "[]")
|
||
}
|
||
this.send("s2c_replaceStarAttr", msg)
|
||
|
||
this.calculateAttr()
|
||
this.send('s2c_player_data', this.getData());
|
||
}
|
||
|
||
equipStar(data: any) {
|
||
let ret = this.StarMgr.EquipStar(data.starid)
|
||
if (ret == 0) {
|
||
this.calculateAttr()
|
||
this.send('s2c_player_data', this.getData());
|
||
}
|
||
|
||
let msg = {
|
||
ret: ret,
|
||
starid: data.starid
|
||
}
|
||
return this.send("s2c_equipStar", msg)
|
||
}
|
||
}
|