606 lines
22 KiB
TypeScript
606 lines
22 KiB
TypeScript
import TaskState from "../object/TaskState";
|
|
import GameUtil from "./GameUtil";
|
|
import TaskConfigMgr from "../task/TaskConfigMgr";
|
|
import TeamMgr from "./TeamMgr";
|
|
import NpcMgr from "./NpcMgr";
|
|
import SKDataUtil from "../gear/SKDataUtil";
|
|
import Player from '../object/Player';
|
|
import SKLogger from '../gear/SKLogger';
|
|
import { EEventType, ETaskKind, ETaskState } from "../role/EEnum";
|
|
import Task from "../task/Task";
|
|
import EventStateBase from "../event/EventStateBase";
|
|
import BangMgr from "../bang/BangMgr";
|
|
import DB from "../utils/DB";
|
|
|
|
export default class RoleTaskMgr {
|
|
player: Player;
|
|
recordList: number[];
|
|
mapTaskState: { [key: number]: TaskState };
|
|
nTimeCnt: any;
|
|
schedule: any;
|
|
mapDailyCnt: { [key: number]: number };
|
|
mapDailyStart: any;
|
|
mapFuBenCnt: any;
|
|
mapActiveScore: any;
|
|
szBeenTake: any;
|
|
szActivePrize: any;
|
|
bCanAutoFight: any;
|
|
|
|
constructor(player: Player) {
|
|
this.player = player;
|
|
this.recordList = [];
|
|
this.mapTaskState = {};
|
|
this.nTimeCnt = 0;
|
|
this.mapDailyCnt = {};
|
|
this.mapDailyStart = {};
|
|
this.mapFuBenCnt = {};
|
|
this.mapActiveScore = {};
|
|
this.szBeenTake = [0, 0, 0, 0, 0, 0];
|
|
this.szActivePrize = ['10301,1', '10406,10', '10204,10', '10404,30', '90004,50000', '70004,1'];//活跃度
|
|
this.bCanAutoFight = 0;
|
|
}
|
|
|
|
reset() {
|
|
this.mapTaskState = {};
|
|
}
|
|
|
|
OnTimer(nIndex?: any) { //一秒一次
|
|
this.nTimeCnt += 1;
|
|
if (this.nTimeCnt % 2 == 0) {
|
|
this.onGameEvent(EEventType.PLAYER_ARRIVE_AREA, {
|
|
mapid: this.player.mapid,
|
|
x: this.player.x,
|
|
y: this.player.y
|
|
});
|
|
}
|
|
if (this.nTimeCnt % 5 == 0)
|
|
this.OnFailEvent(EEventType.TIMEOUT, GameUtil.getTime());
|
|
}
|
|
|
|
OnNewDay() {
|
|
this.mapDailyStart = {};
|
|
let vecTask = [];
|
|
for (var it in this.mapTaskState) {
|
|
if (this.mapTaskState[it].nKind == ETaskKind.DAILY || this.mapTaskState[it].nKind == ETaskKind.FUBEN) {
|
|
if (this.mapTaskState[it].nTaskGrop == 22){
|
|
if (new Date().getDay() == 1){
|
|
vecTask.push(this.mapTaskState[it].nTaskID);
|
|
}
|
|
}else {
|
|
vecTask.push(this.mapTaskState[it].nTaskID);
|
|
}
|
|
|
|
}
|
|
}
|
|
for (var it in vecTask) {
|
|
this.abortTask(vecTask[it]);
|
|
}
|
|
let data: any = this.mapDailyCnt[22];
|
|
this.mapDailyCnt = {}; //放弃任务会增加计数，所以放到放弃后面
|
|
this.mapFuBenCnt = {};
|
|
this.mapActiveScore = {};
|
|
if (new Date().getDay() != 1){
|
|
if (data != undefined){
|
|
this.mapDailyCnt[22] = data;
|
|
}
|
|
}
|
|
|
|
this.szBeenTake = [0, 0, 0, 0, 0, 0];
|
|
this.player.unget_doublecnt += 60;
|
|
this.updateTaskStateToClient();
|
|
}
|
|
// 获得任务步骤状态
|
|
getTaskStepState(taskId: number, step: number): EventStateBase {
|
|
if (this.mapTaskState.hasOwnProperty(taskId) == false) {
|
|
return null;
|
|
}
|
|
if (step < 0 || step >= this.mapTaskState[taskId].vecEventState.length) {
|
|
return null;
|
|
}
|
|
let result = this.mapTaskState[taskId].vecEventState[step];
|
|
return result;
|
|
}
|
|
// 初始化
|
|
init(taskList: any[], recordList: number[], mapDailyCnt: any, mapFuBenCnt: any, mapDailyStart: any, mapActiveScore: any, szBeenTake: number[]) {
|
|
this.recordList = recordList.slice(0);
|
|
this.mapTaskState = {};
|
|
this.mapDailyCnt = mapDailyCnt;
|
|
this.mapFuBenCnt = mapFuBenCnt;
|
|
this.mapDailyStart = mapDailyStart;
|
|
this.mapActiveScore = mapActiveScore;
|
|
this.szBeenTake = szBeenTake;
|
|
if (SKDataUtil.isEmptyArray(taskList)) {
|
|
SKLogger.warn(`玩家[${this.player.roleid}:${this.player.name}]无任务数据!`);
|
|
}
|
|
for (let item of taskList) {
|
|
let isFinish = this.isAlreadyDoneThisTask(item.nTaskID);
|
|
if (!isFinish) {
|
|
this.addTaskState(parseInt(item.nTaskID), parseInt(item.nCurStep));
|
|
}
|
|
}
|
|
this.checkAndDeleteFinishedTask();
|
|
}
|
|
// 是否完成此任务
|
|
isAlreadyDoneThisTask(taskId: number): boolean {
|
|
for (let item of this.recordList) {
|
|
if (item == taskId) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
isMatchLimit(stTask: any): boolean {
|
|
for (var itLimit in stTask.vecLimit) {
|
|
if (stTask.vecLimit[itLimit].nKey == 'nPreTask') //前置任务
|
|
{
|
|
let nPreTask = parseInt(stTask.vecLimit[itLimit].nValue);
|
|
if (this.isAlreadyDoneThisTask(nPreTask) == false)
|
|
return false;
|
|
}
|
|
if (stTask.vecLimit[itLimit].nKey == 'nBang') {
|
|
if (this.player.bangid == 0)
|
|
return false;
|
|
}
|
|
if (stTask.vecLimit[itLimit].nKey == 'nRace') {
|
|
let nNeedRace = parseInt(stTask.vecLimit[itLimit].nValue);
|
|
if (this.player.race != nNeedRace)
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
// 加入任务状态
|
|
addTaskState(taskId: number, step: number) {
|
|
let task: Task = TaskConfigMgr.shared.getTaskConf(taskId);
|
|
if (task == null) {
|
|
SKLogger.warn(`玩家[${this.player.roleid}:${this.player.name}]找不到任务配置[${taskId}]!`);
|
|
return;
|
|
}
|
|
// 组队任务,玩家未组队
|
|
if (TaskConfigMgr.shared.isTeamTask(taskId) && this.player.teamid == 0) {
|
|
// SKLogger.warn(`玩家[${this.player.roleid}:${this.player.name}]组队任务未组队跳过!`);
|
|
return;
|
|
}
|
|
let taskState = new TaskState();
|
|
taskState.player = this.player;
|
|
taskState.initState(task, step);
|
|
this.mapTaskState[taskState.nTaskID] = taskState;
|
|
}
|
|
|
|
isAlreadyHasThisKindDailyTask(groupId: number): boolean {
|
|
for (let key in this.mapTaskState) {
|
|
let taskId: number = SKDataUtil.numberBy(key);
|
|
let task: Task = TaskConfigMgr.shared.getTaskConf(taskId);
|
|
if (task == null) {
|
|
continue;
|
|
}
|
|
if (task.nTaskGrop == groupId) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
// 获得任务次数
|
|
getKindTaskCnt(taskGroup: number): number {
|
|
let result = this.mapDailyCnt[taskGroup];
|
|
if (result == null) {
|
|
return 0;
|
|
}
|
|
return result;
|
|
}
|
|
// 获得活动组任务
|
|
getDailyGroupTask(): { [key: number]: Task[] } {
|
|
let dailyTasks: Task[] = TaskConfigMgr.shared.mapConfigTask[ETaskKind.DAILY];
|
|
if (dailyTasks == null) {
|
|
SKLogger.warn(`角色任务管理器:玩家[${this.player.roleid}:${this.player.name}]活动组任务没有配置!`);
|
|
return {};
|
|
}
|
|
let result: any = {};
|
|
for (let task of dailyTasks) {
|
|
let group = task.nTaskGrop;
|
|
if (result[group] == null) {
|
|
result[group] = [];
|
|
}
|
|
result[group].push(task);
|
|
}
|
|
return result;
|
|
}
|
|
// 取得开启的活动任务
|
|
getEnableDailyTask(mapDailyTask: any, group: any): Task[] {
|
|
let dailyGroup: Task[] = mapDailyTask[group];
|
|
let result: Task[] = [];
|
|
for (let key in dailyGroup) {
|
|
let task: Task = dailyGroup[key];
|
|
if (this.isMatchLimit(task) == false) {
|
|
continue;
|
|
}
|
|
result.push(task);
|
|
}
|
|
return result;
|
|
}
|
|
// 检查并接受任务
|
|
checkAndInceptTask() {
|
|
let taskList: Task[] = GameUtil.getDefault(TaskConfigMgr.shared.mapConfigTask[ETaskKind.STORY], []);
|
|
for (let key in taskList) {
|
|
let task: Task = taskList[key];
|
|
if (this.isAlreadyDoneThisTask(task.nTaskID)) {
|
|
continue;
|
|
}
|
|
if (this.mapTaskState.hasOwnProperty(task.nTaskID)) {
|
|
continue;
|
|
}
|
|
if (this.isMatchLimit(task) == false) {
|
|
continue;
|
|
}
|
|
this.addTaskState(task.nTaskID, 0);
|
|
break;
|
|
}
|
|
let dailyTasks = this.getDailyGroupTask();
|
|
for (let key in dailyTasks) {
|
|
if (this.mapDailyStart.hasOwnProperty(key) == false) {
|
|
continue;
|
|
}
|
|
let groupId: number = SKDataUtil.numberBy(key);
|
|
// 活动任务是组队,玩家不是队长则跳过
|
|
if (TaskConfigMgr.shared.IsTeamDaily(groupId) && this.player.isleader == false) {
|
|
continue;
|
|
}
|
|
if (this.isAlreadyHasThisKindDailyTask(groupId)) {
|
|
continue;
|
|
}
|
|
let groupTask: Task[] = this.getEnableDailyTask(dailyTasks, key);
|
|
if (SKDataUtil.isEmptyArray(groupTask)) {
|
|
SKLogger.debug(`玩家[${this.player.roleid}:${this.player.name}]组任务[${key}]为空`);
|
|
return;
|
|
}
|
|
let task: Task = SKDataUtil.randomList(groupTask);
|
|
// let task: Task = groupTask[3];
|
|
if (task != null) {
|
|
if (this.getKindTaskCnt(groupId) >= task.nDailyCnt) //这个类型的每日任务做完了
|
|
continue;
|
|
if (this.isMatchLimit(task) == false)
|
|
continue;
|
|
this.addTaskState(task.nTaskID, 0);
|
|
}
|
|
}
|
|
}
|
|
// 开始组任务
|
|
startGroupTask(taskGroup: number): string {
|
|
let current: number = this.getKindTaskCnt(taskGroup);
|
|
let max = TaskConfigMgr.shared.getDailyMaxCount(taskGroup);
|
|
if (current >= max) {
|
|
return "次数已满";
|
|
}
|
|
if (TaskConfigMgr.shared.IsTeamDaily(taskGroup) && this.player.teamid == 0 && this.player.isleader == false) {
|
|
return '只有队长才能接这个任务';
|
|
}
|
|
if (this.mapDailyStart.hasOwnProperty(taskGroup)) {
|
|
return '你已经领过这个任务了';
|
|
}
|
|
this.mapDailyStart[taskGroup] = true;
|
|
this.checkAndInceptTask();
|
|
this.updateTaskStateToClient();
|
|
return "";
|
|
}
|
|
|
|
CheckAndInceptFuBenTask(nTaskID: any) {
|
|
let pTaskConfig = TaskConfigMgr.shared.getTaskConf(nTaskID);
|
|
if (null == pTaskConfig || pTaskConfig.nKind != ETaskKind.FUBEN)
|
|
return 'syserr';
|
|
|
|
if (this.GetFuBenCnt(nTaskID) >= 1 && pTaskConfig.nTaskGrop != 14)
|
|
return '次数已满';
|
|
|
|
if (this.player.teamid == 0 || this.player.isleader == false)
|
|
return '只有队长才能接这个任务';
|
|
|
|
if (this.mapTaskState.hasOwnProperty(pTaskConfig.nTaskID))
|
|
return '你已经领取过这个任务';
|
|
|
|
if (this.isMatchLimit(pTaskConfig) == false)
|
|
return '不满足条件';
|
|
|
|
this.addTaskState(pTaskConfig.nTaskID, 0);
|
|
this.updateTaskStateToClient();
|
|
return '';
|
|
}
|
|
// 游戏事件
|
|
onGameEvent(nEventType: EEventType, data: any) {
|
|
if (this.player.teamid > 0 && this.player.isleader == false) {
|
|
SKLogger.debug(`游戏事件:玩家[${this.player.roleid}:${this.player.name}]是队员跳过!`);
|
|
return;
|
|
}
|
|
|
|
let onchange = false
|
|
for (let key in this.mapTaskState) {
|
|
if(this.mapTaskState[key].taskOnGameEvent(nEventType, data) == true){
|
|
onchange = true
|
|
}
|
|
}
|
|
|
|
if(onchange){
|
|
this.checkAndDeleteFinishedTask();
|
|
this.updateTaskStateToClient();
|
|
}
|
|
}
|
|
|
|
OnTeamTaskState(mapLeaderTaskState: any) {
|
|
for (let key in mapLeaderTaskState) {
|
|
if (TaskConfigMgr.shared.isTeamTask(key) == false) {
|
|
continue;
|
|
}
|
|
let groupId: number = SKDataUtil.numberBy(key);
|
|
if (this.mapTaskState.hasOwnProperty(groupId)) {
|
|
delete this.mapTaskState[groupId];
|
|
}
|
|
let pInfo = mapLeaderTaskState[key];
|
|
let taskState = new TaskState();
|
|
taskState.nTaskID = pInfo.nTaskID;
|
|
taskState.nKind = pInfo.nKind;
|
|
taskState.nTaskGrop = pInfo.nTaskGrop;
|
|
taskState.nTaskFinish = pInfo.nTaskFinish;
|
|
taskState.vecEventState = pInfo.vecEventState.slice(0);
|
|
taskState.vecFailEvent = pInfo.vecFailEvent.slice(0);
|
|
taskState.player = this.player;
|
|
this.mapTaskState[groupId] = taskState
|
|
}
|
|
this.updateTaskStateToClient();
|
|
}
|
|
// 放弃任务
|
|
abortTask(taskId: number) {
|
|
let taskState = this.mapTaskState[taskId];
|
|
if (taskState == null) {
|
|
SKLogger.debug(`放弃任务:找不到任务[${taskId}]状态!`);
|
|
return;
|
|
}
|
|
let task: Task = TaskConfigMgr.shared.getTaskConf(taskId);
|
|
if (task == null) {
|
|
SKLogger.warn(`放弃任务:找不到任务[${taskId}]信息!`);
|
|
return;
|
|
}
|
|
if (task.nKind == ETaskKind.STORY) {
|
|
this.player.send('s2c_notice', {
|
|
strRichText: '剧情任务无法取消'
|
|
});
|
|
SKLogger.debug(`放弃任务:剧情任务[${task.nTaskID}:${task.strTaskName}]不能取消!`);
|
|
return;
|
|
}
|
|
taskState.nTaskFinish = ETaskState.FALIED;
|
|
this.checkAndDeleteFinishedTask();
|
|
this.updateTaskStateToClient();
|
|
SKLogger.debug(`玩家[${this.player.roleid}:${this.player.name}]取消任务[${task.nTaskID}:${task.strTaskName}]`);
|
|
}
|
|
// 玩家离队
|
|
leaveTeam() {
|
|
// 找到所有的组队任务
|
|
let list = [];
|
|
for (let key in this.mapTaskState) {
|
|
if (TaskConfigMgr.shared.isTeamTask(key) == false) {
|
|
continue;
|
|
}
|
|
list.push(SKDataUtil.numberBy(key));
|
|
}
|
|
//放弃任务
|
|
for (let key in list) {
|
|
this.abortTask(list[key]);
|
|
}
|
|
}
|
|
// 任务失败
|
|
OnFailEvent(nEventType: any, stData: any) {
|
|
let bChange = false;
|
|
for (let it in this.mapTaskState) {
|
|
if (this.mapTaskState[it].TaskOnFialEvent(nEventType, stData) == true)
|
|
bChange = true;
|
|
}
|
|
if (bChange) {
|
|
this.checkAndDeleteFinishedTask();
|
|
this.updateTaskStateToClient();
|
|
}
|
|
}
|
|
// 检查所有完成或失败的任务
|
|
checkAndDeleteFinishedTask() {
|
|
for (let key in this.mapTaskState) {
|
|
let taskState: TaskState = this.mapTaskState[key];
|
|
if (taskState.nTaskFinish == ETaskState.DONE) {
|
|
this.onTaskFinish(taskState, true);
|
|
delete this.mapTaskState[key];
|
|
continue;
|
|
}
|
|
if (taskState.nTaskFinish == ETaskState.FALIED) {
|
|
this.onTaskFinish(taskState, false);
|
|
delete this.mapTaskState[key];
|
|
continue;
|
|
}
|
|
}
|
|
this.checkAndInceptTask();
|
|
}
|
|
// 任务完成
|
|
onTaskFinish(taskState: TaskState, isFinish: boolean) {
|
|
let playerList: Player[];
|
|
let leaderStep = 0;
|
|
if (this.player.teamid == 0) {
|
|
playerList = [this.player];
|
|
}
|
|
if (this.player.teamid > 0) {
|
|
playerList = TeamMgr.shared.getTeamPlayer(this.player.teamid);
|
|
}
|
|
let taskInfo = TaskConfigMgr.shared.getTaskConf(taskState.nTaskID);
|
|
if (taskInfo == null) {
|
|
console.warn(`玩家[${this.player.roleid}:${this.player.name}]任务[${taskState.nTaskID}]找不到!`);
|
|
return;
|
|
}
|
|
for (let member of playerList) {
|
|
if (member == null) {
|
|
continue;
|
|
}
|
|
if (isFinish && taskInfo.nKind == ETaskKind.STORY) {
|
|
member.getTaskMgr().recordList.push(taskState.nTaskID);
|
|
}
|
|
if(isFinish){
|
|
if(taskInfo.nTaskGrop == 2){
|
|
let bang = BangMgr.shared.getBang(member.bangid);
|
|
if(bang){
|
|
for (const roleInfo of bang.rolelist) {
|
|
if(roleInfo.roleid == member.roleid){
|
|
roleInfo.daytask++;
|
|
bang.bangexp += 75;
|
|
DB.updateBangMember(roleInfo,1);
|
|
DB.bangUpdate({bangid: member.bangid, banglevel: bang.banglevel, bangexp: bang.bangexp});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(member.doublecnt > 0 && taskInfo.nTaskGrop == 6){
|
|
member.doublecnt --;
|
|
DB.updateDoublePoint({doublecnt: member.doublecnt,unget_doublecnt: member.unget_doublecnt,roleid: member.roleid})
|
|
}
|
|
if(member.doublecnt > 0 && taskInfo.nTaskGrop == 7){
|
|
member.doublecnt -= 4;
|
|
DB.updateDoublePoint({doublecnt: member.doublecnt,unget_doublecnt: member.unget_doublecnt,roleid: member.roleid})
|
|
}
|
|
member.getTaskMgr().onDeleteTask(taskState,leaderStep, true);
|
|
if(member.isleader){
|
|
leaderStep = GameUtil.getDefault(this.mapFuBenCnt[taskState.nTaskID], 0);
|
|
}
|
|
}else{
|
|
member.getTaskMgr().onDeleteTask(taskState,leaderStep, false);
|
|
}
|
|
member.send('s2c_notice', {
|
|
strRichText: isFinish ? `任务[${taskInfo.strTaskName}]完成!` : `任务[${taskInfo.strTaskName}]失败!`
|
|
});
|
|
}
|
|
}
|
|
// 删除任务
|
|
onDeleteTask(taskState: TaskState,leaderStep: number, isSuccess: boolean) {
|
|
let max = TaskConfigMgr.shared.getDailyMaxCount(taskState.nTaskGrop);
|
|
let nextStep: number = taskState.vecEventState.length;
|
|
for (let key in taskState.vecEventState) {
|
|
let stepState = taskState.vecEventState[key];
|
|
if (stepState.nState == ETaskState.DOING) {
|
|
continue;
|
|
}
|
|
nextStep = SKDataUtil.numberBy(key);
|
|
if (typeof (stepState.vecRemainNpc) == "undefined") {
|
|
continue;
|
|
}
|
|
for (let npc in stepState.vecRemainNpc) {
|
|
NpcMgr.shared.CheckAndDeleteNpc(stepState.vecRemainNpc[npc].nOnlyID, this.player);
|
|
}
|
|
}
|
|
if (isSuccess) {//任务次数加1
|
|
//判断是不是组队任务
|
|
let flag = TaskConfigMgr.shared.isTeamTask(taskState.nTaskID);
|
|
if(flag == false){//如果不是组队任务，队员不加次数
|
|
if(this.player.teamid > 0 && this.player.isleader == false){
|
|
return;
|
|
}
|
|
}
|
|
if (taskState.nKind == ETaskKind.DAILY ) {
|
|
let num = this.mapDailyCnt[taskState.nTaskGrop];
|
|
if(num == undefined){
|
|
this.mapDailyCnt[taskState.nTaskGrop] = GameUtil.getDefault(this.mapDailyCnt[taskState.nTaskGrop], 0) + 1;
|
|
}else {
|
|
if(num < max){
|
|
this.mapDailyCnt[taskState.nTaskGrop] = GameUtil.getDefault(this.mapDailyCnt[taskState.nTaskGrop], 0) + 1;
|
|
}
|
|
}
|
|
}
|
|
if (taskState.nKind == ETaskKind.FUBEN) {
|
|
let nCurStep = GameUtil.getDefault(this.mapFuBenCnt[taskState.nTaskID], 0);
|
|
if(this.player.isleader == false && taskState.nTaskID == 1004){
|
|
nCurStep = leaderStep;
|
|
}
|
|
this.mapFuBenCnt[taskState.nTaskID] = Math.max(nCurStep, nextStep);
|
|
}
|
|
}
|
|
}
|
|
// 更新任务状态给客户端
|
|
updateTaskStateToClient() {
|
|
let vecData = [];
|
|
for (let it in this.mapTaskState) {
|
|
let stTask = this.mapTaskState[it];
|
|
let vecJson = [];
|
|
for (let itStep in stTask.vecEventState) {
|
|
let strJson = SKDataUtil.toJson(stTask.vecEventState[itStep], "{}");
|
|
vecJson.push(strJson);
|
|
}
|
|
vecData.push({
|
|
nTaskID: stTask.nTaskID,
|
|
vecStep: vecJson
|
|
});
|
|
}
|
|
this.player.send('s2c_role_task_list', {
|
|
vecTask: vecData,
|
|
strJsonDaily: SKDataUtil.toJson(this.mapDailyCnt, "{}")
|
|
});
|
|
if (this.player.teamid > 0 && this.player.isleader == true) {
|
|
this.SynchroTaskToTeam();
|
|
}
|
|
}
|
|
|
|
SynchroTaskToTeam() {
|
|
let pTeamInfo = TeamMgr.shared.teamList[this.player.teamid];
|
|
if (null == pTeamInfo) {
|
|
return;
|
|
}
|
|
|
|
for (let index = 1; index < pTeamInfo.playerlist.length; index++) {
|
|
let pMember: Player = pTeamInfo.playerlist[index];
|
|
if (null == pMember || pMember.roleid == this.player.roleid || pMember.isleader) {
|
|
continue;
|
|
}
|
|
if (pMember.getTaskMgr() == null) {
|
|
continue;
|
|
}
|
|
pMember.getTaskMgr().OnTeamTaskState(this.mapTaskState);
|
|
}
|
|
|
|
}
|
|
|
|
AddActive(nKind: any, nNum: any) {
|
|
if (this.mapActiveScore.hasOwnProperty(nKind) == false)
|
|
this.mapActiveScore[nKind] = 0;
|
|
|
|
this.mapActiveScore[nKind] = Math.min(this.mapActiveScore[nKind] + nNum, 140);
|
|
this.SendDailyActive();
|
|
}
|
|
|
|
SendDailyActive() {
|
|
let tmpData: any = {};
|
|
tmpData.mapActiveScore = this.mapActiveScore;
|
|
tmpData.szBeenTake = this.szBeenTake;
|
|
tmpData.szActivePrize = this.szActivePrize;
|
|
// 已接的每日任务
|
|
tmpData.mapDailyStart = this.mapDailyStart;
|
|
// 每日任务次数
|
|
tmpData.mapDailyCnt = this.mapDailyCnt;
|
|
// 副本任务次数
|
|
tmpData.mapFuBenCnt = this.mapFuBenCnt;
|
|
// 双倍点数
|
|
tmpData.doublecnt = this.player.doublecnt;
|
|
// 可领取点数
|
|
tmpData.canget = this.player.unget_doublecnt == null ? 0 : this.player.unget_doublecnt;
|
|
this.player.send('s2c_daily_info', {
|
|
strJson: SKDataUtil.toJson(tmpData, "{}")
|
|
});
|
|
}
|
|
|
|
GetFuBenCnt(nTaskID: any) {
|
|
if (this.mapFuBenCnt.hasOwnProperty(nTaskID) == false)
|
|
return 0;
|
|
|
|
return this.mapFuBenCnt[nTaskID];
|
|
}
|
|
|
|
//获取任务信息
|
|
getTaskStateByNpcOnlyid(npcOnlyid: any): { taskID: any, step: any } {
|
|
for (let it in this.mapTaskState) {
|
|
let step = this.mapTaskState[it].getTaskStepByNpcOnlyid(npcOnlyid);
|
|
if (step)
|
|
return { taskID: this.mapTaskState[it].nTaskID, step: step };
|
|
}
|
|
return null;
|
|
}
|
|
} |