882 lines
29 KiB
ActionScript
882 lines
29 KiB
ActionScript
package net.pixvi.myr.center
|
|
{
|
|
import net.pixvi.common.system.language.lang;
|
|
import net.pixvi.common.utils.Alert;
|
|
import net.pixvi.myr.CP;
|
|
import net.pixvi.myr.GameMath;
|
|
import net.pixvi.myr.element.bag.ItemVo;
|
|
import net.pixvi.myr.element.city.CityVo;
|
|
import net.pixvi.myr.element.guide.GSub;
|
|
import net.pixvi.myr.element.mon.MonsterVo;
|
|
import net.pixvi.myr.element.reward.RewardResultVo;
|
|
import net.pixvi.myr.element.task.TaskStatusType;
|
|
import net.pixvi.myr.element.task.TaskType;
|
|
import net.pixvi.myr.element.task.TaskVo;
|
|
import net.pixvi.myr.event.MYREvent;
|
|
import net.pixvi.myr.net.NetTask;
|
|
import net.pixvi.myr.panel.gacha.GachaPanel;
|
|
import net.pixvi.myr.panel.looptask.LoopTaskPanel;
|
|
import net.pixvi.myr.util.MyrCalendar;
|
|
import net.pixvi.pfw.utils.ArrayUtil;
|
|
import net.pixvi.pfw.utils.Caller;
|
|
import net.pixvi.pfw.utils.broadcast.GlobalBroadcast;
|
|
import net.pixvi.pfw.utils.core.Singleton;
|
|
|
|
public class TaskCenter
|
|
{
|
|
|
|
private var finishTask_tid:int;
|
|
|
|
private var finishTask_type:String;
|
|
|
|
private var onFinishTaskComplete:Function;
|
|
|
|
private var openCityName:String;
|
|
|
|
private var onCompleteStepComplete:Function;
|
|
|
|
private var completeStep_para:Object;
|
|
|
|
private var receiveTask_task:TaskVo;
|
|
|
|
private var receiveTask_show:Boolean;
|
|
|
|
private var onReceiveTaskComplete:Function;
|
|
|
|
private var resetingLoopTask:Boolean = false;
|
|
|
|
private var onResetLoopTaskComplete:Function;
|
|
|
|
private var onGetLoopTaskComplete:Function;
|
|
|
|
private var getLoopTask_para:Object;
|
|
|
|
public function TaskCenter()
|
|
{
|
|
super();
|
|
}
|
|
|
|
public static function getTaskByTaskData(taskData:Object) : TaskVo
|
|
{
|
|
var taskVo:TaskVo = new TaskVo();
|
|
taskVo.id = taskData.id;
|
|
taskVo.typeId = taskData.typeId;
|
|
taskVo.step = taskData.curStep - 1;
|
|
taskVo.stepVo = taskVo.getStepVo(taskVo.step);
|
|
taskVo.stepValue = taskData.stepValue;
|
|
taskVo.recieved = true;
|
|
return taskVo;
|
|
}
|
|
|
|
public static function getIns() : TaskCenter
|
|
{
|
|
return Singleton.getInstanceOrCreate(TaskCenter) as TaskCenter;
|
|
}
|
|
|
|
public function autoCheckNewTask(unlocks:Array = null) : void
|
|
{
|
|
var checkDatas:Object = null;
|
|
var startTask:String = "1001001";
|
|
if(Table.setting.useOldNewTaskFunction == true)
|
|
{
|
|
checkDatas = checkPassTasksNewTask(startTask);
|
|
}
|
|
else
|
|
{
|
|
checkDatas = checkNewTask();
|
|
}
|
|
var needGetTasks:Array = checkDatas.getNewTaskTypes;
|
|
var needUnlockTasks:Array = checkDatas.unlockNewTaskTypes;
|
|
var needRemoveTasks:Array = checkDatas.removeTaskIds;
|
|
if(unlocks != null)
|
|
{
|
|
needUnlockTasks = unlocks;
|
|
}
|
|
NetTask.getIns().updateTask(needUnlockTasks,needGetTasks,needRemoveTasks,autoCheckNewTaskHandler);
|
|
}
|
|
|
|
public function autoCheckNewTaskHandler(unlockTasks:Array, receiveTasks:Array) : void
|
|
{
|
|
var i:int = 0;
|
|
var j:int = 0;
|
|
var unlockTaskTypeId:String = null;
|
|
var k:int = 0;
|
|
var tv:TaskVo = null;
|
|
for(i = 0; i < receiveTasks.length; )
|
|
{
|
|
addLocalTask(TaskCenter.getTaskByTaskData(receiveTasks[i]));
|
|
i++;
|
|
}
|
|
for(j = 0; j < unlockTasks.length; )
|
|
{
|
|
unlockTaskTypeId = unlockTasks[j];
|
|
unlockLocalTask(unlockTaskTypeId);
|
|
j++;
|
|
}
|
|
for(k = 0; k < Master.tasks.length; )
|
|
{
|
|
tv = Master.tasks[k];
|
|
if(tv.closed == true)
|
|
{
|
|
Master.tasks.splice(k,1);
|
|
}
|
|
k++;
|
|
}
|
|
}
|
|
|
|
private function checkNewTask() : Object
|
|
{
|
|
var passTaskObject:Object = null;
|
|
var nextTasks:Array = null;
|
|
var unlockTasks:Array = null;
|
|
var i:int = 0;
|
|
var unlockTaskclose:Boolean = false;
|
|
var j:int = 0;
|
|
var nextTaskclose:Boolean = false;
|
|
var getNewTaskTypes:Array = [];
|
|
var unlockNewTaskTypes:Array = [];
|
|
var removeTaskIds:Array = [];
|
|
for(var taskKey:String in Master.history.passTask)
|
|
{
|
|
passTaskObject = Table.task_info[taskKey];
|
|
if(passTaskObject == null)
|
|
{
|
|
if(GameMath.ModeTrace)
|
|
{
|
|
Alert.showMsg("can\'t find task[" + taskKey + "]");
|
|
}
|
|
}
|
|
else if(!passTaskObject.closed)
|
|
{
|
|
nextTasks = passTaskObject.nextTasks;
|
|
unlockTasks = passTaskObject.unlockTasks;
|
|
for(i = 0; i < unlockTasks.length; )
|
|
{
|
|
unlockTaskclose = false;
|
|
if(Table.task_info[unlockTasks[i]] != null && Table.task_info[unlockTasks[i]].closed)
|
|
{
|
|
unlockTaskclose = true;
|
|
}
|
|
if(!unlockTaskclose && Master.history.unlockTask[unlockTasks[i]] != true && unlockNewTaskTypes.indexOf(unlockTasks[i]) == -1)
|
|
{
|
|
unlockNewTaskTypes.push({
|
|
"prev":taskKey,
|
|
"taskTypeId":unlockTasks[i]
|
|
});
|
|
trace("新任务解锁:" + unlockTasks[i]);
|
|
}
|
|
i++;
|
|
}
|
|
for(j = 0; j < nextTasks.length; )
|
|
{
|
|
nextTaskclose = false;
|
|
if(Table.task_info[nextTasks[j]] != null && Table.task_info[nextTasks[j]].closed)
|
|
{
|
|
nextTaskclose = true;
|
|
}
|
|
if(!nextTaskclose && Master.history.passTask[nextTasks[j]] != true && TaskCenter.getIns().getTaskByType(nextTasks[j]) == null)
|
|
{
|
|
getNewTaskTypes.push({
|
|
"prev":taskKey,
|
|
"taskTypeId":nextTasks[j]
|
|
});
|
|
trace("新任务获取:" + nextTasks[j]);
|
|
}
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
for each(var tv:TaskVo in Master.tasks)
|
|
{
|
|
if(tv.closed == true)
|
|
{
|
|
removeTaskIds.push(tv.id);
|
|
}
|
|
}
|
|
return {
|
|
"getNewTaskTypes":getNewTaskTypes,
|
|
"unlockNewTaskTypes":unlockNewTaskTypes,
|
|
"removeTaskIds":removeTaskIds
|
|
};
|
|
}
|
|
|
|
private function checkPassTasksNewTask(taskTypeId:String) : Object
|
|
{
|
|
var i:int = 0;
|
|
var nextTaskType:String = null;
|
|
var checkDatas:Object = null;
|
|
var j:int = 0;
|
|
var unlockTaskType:String = null;
|
|
trace("开始检测:" + taskTypeId);
|
|
if(Master.history.passTask[taskTypeId] != true)
|
|
{
|
|
trace(taskTypeId + "未通过");
|
|
return {
|
|
"getNewTaskTypes":[],
|
|
"unlockNewTaskTypes":[]
|
|
};
|
|
}
|
|
var getNewTaskTypes:Array = [];
|
|
var unlockNewTaskTypes:Array = [];
|
|
var nextTasks:Array = Table.task_info[taskTypeId].nextTasks;
|
|
var unlockTasks:Array = Table.task_info[taskTypeId].unlockTasks;
|
|
for(i = 0; i < nextTasks.length; )
|
|
{
|
|
nextTaskType = nextTasks[i];
|
|
trace("检测" + taskTypeId + "关联:",nextTaskType);
|
|
if(Master.history.passTask[nextTaskType] != true && TaskCenter.getIns().getTaskByType(nextTaskType) == null)
|
|
{
|
|
getNewTaskTypes.push({
|
|
"prev":taskTypeId,
|
|
"taskTypeId":nextTaskType
|
|
});
|
|
trace("检测" + taskTypeId + "关联:",nextTaskType,"补充获取!!!!!!");
|
|
}
|
|
else if(Master.history.passTask[nextTaskType] == true)
|
|
{
|
|
trace("检测" + taskTypeId + "关联:",nextTaskType,"检查");
|
|
checkDatas = checkPassTasksNewTask(nextTaskType);
|
|
getNewTaskTypes = getNewTaskTypes.concat(checkDatas.getNewTaskTypes);
|
|
unlockNewTaskTypes = unlockNewTaskTypes.concat(checkDatas.unlockNewTaskTypes);
|
|
}
|
|
i++;
|
|
}
|
|
for(j = 0; j < unlockTasks.length; )
|
|
{
|
|
unlockTaskType = unlockTasks[j];
|
|
trace("检测" + taskTypeId + "解锁关联:",unlockTaskType);
|
|
if(Master.history.unlockTask[unlockTaskType] != true)
|
|
{
|
|
trace("检测" + taskTypeId + "解锁关联:",unlockTaskType,"需解锁!!!!");
|
|
unlockNewTaskTypes.push({
|
|
"prev":taskTypeId,
|
|
"taskTypeId":unlockTaskType
|
|
});
|
|
}
|
|
j++;
|
|
}
|
|
return {
|
|
"getNewTaskTypes":getNewTaskTypes,
|
|
"unlockNewTaskTypes":unlockNewTaskTypes
|
|
};
|
|
}
|
|
|
|
public function finishTask(tid:int, tasktypeId:String, onComplete:Function) : void
|
|
{
|
|
onFinishTaskComplete = onComplete;
|
|
finishTask_tid = tid;
|
|
finishTask_type = tasktypeId;
|
|
NetTask.getIns().finishTask(tid,tasktypeId,finishTaskHandler);
|
|
}
|
|
|
|
private function finishTaskHandler(rewardData:Object, taskdatas:Array, unlockTasks:Array, unlockStages:Array) : void
|
|
{
|
|
var j:int = 0;
|
|
var newTask:TaskVo = null;
|
|
var k:int = 0;
|
|
var task:TaskVo = getTaskById(finishTask_tid);
|
|
var rewardResultVo:RewardResultVo = RewardCenter.getRewardResultVoByData(rewardData);
|
|
task.complete = true;
|
|
ArrayUtil.remove(Master.tasks,task);
|
|
Master.history.passTask[task.typeId] = true;
|
|
RewardCenter.getIns().getReward(rewardResultVo,true,"panel",showOpenCity);
|
|
if(task.type == TaskType.LOOP_TASK)
|
|
{
|
|
LoopTaskPanel.getIns().update();
|
|
}
|
|
if(taskdatas != null && taskdatas.length > 0)
|
|
{
|
|
for(j = 0; j < taskdatas.length; )
|
|
{
|
|
newTask = TaskCenter.getTaskByTaskData(taskdatas[j]);
|
|
Master.tasks.push(newTask);
|
|
j++;
|
|
}
|
|
}
|
|
if(unlockTasks != null && unlockTasks.length > 0)
|
|
{
|
|
for(k = 0; k < unlockTasks.length; )
|
|
{
|
|
TaskCenter.getIns().unlockLocalTask(unlockTasks[k]);
|
|
k++;
|
|
}
|
|
}
|
|
if(unlockStages != null && unlockStages.length > 0)
|
|
{
|
|
for each(var s:String in unlockStages)
|
|
{
|
|
StageCenter.getIns().unlockStage(s,1,true);
|
|
}
|
|
}
|
|
for each(var o:Object in Table.city_info)
|
|
{
|
|
if(task.typeId == o.openTask)
|
|
{
|
|
Master.history.unlockCity[o.cid] = true;
|
|
openCityName = o.name;
|
|
}
|
|
}
|
|
Master.history.passTask[task.typeId] = true;
|
|
if(onFinishTaskComplete != null)
|
|
{
|
|
onFinishTaskComplete();
|
|
onFinishTaskComplete = null;
|
|
}
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.TASK_CHANGE));
|
|
}
|
|
|
|
private function showOpenCity() : void
|
|
{
|
|
var entangleMon:MonsterVo = null;
|
|
if(openCityName != null)
|
|
{
|
|
Alert.yes(lang("通关区域"),CP.task(lang("新地区【{0}】开启了!",openCityName)));
|
|
openCityName = null;
|
|
}
|
|
for(var monType:String in Table.upstar_info)
|
|
{
|
|
if(Table.upstar_info[monType].task != null && Table.upstar_info[monType].task.indexOf(finishTask_type) >= 0)
|
|
{
|
|
entangleMon = MonsterCenter.getIns().getEntangleMonByType(int(monType));
|
|
if(entangleMon != null)
|
|
{
|
|
Alert.yes(lang("升星契机"),CP.task(lang("完成了与【{0}】的升星契机!可前往羁绊界面解锁升星。",entangleMon.desName)));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function completeLocalStep(task:TaskVo) : void
|
|
{
|
|
if(task.stepVo.unlockStages.length > 0)
|
|
{
|
|
for each(var s:String in task.stepVo.unlockStages)
|
|
{
|
|
StageCenter.getIns().unlockStage(s,1,true);
|
|
}
|
|
}
|
|
if(task.typeId == "1001006" && task.step == 3)
|
|
{
|
|
Caller.delayCall(GachaPanel.popInGacha,200,1,["task1"]);
|
|
}
|
|
task.step++;
|
|
if(task.steps[task.step] == null)
|
|
{
|
|
task.stepVo = null;
|
|
Alert.showMsg(lang("任务 {0} 完成!",CP.task(task.name)));
|
|
}
|
|
else
|
|
{
|
|
Alert.showMsg(lang("任务 {0} 有更新!",CP.task(task.name)));
|
|
task.stepVo = task.getStepVo();
|
|
}
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.TASK_CHANGE));
|
|
}
|
|
|
|
public function finishStep(t:TaskVo, showReward:Boolean = false, onComplete:Function = null) : void
|
|
{
|
|
var removeIds:Array = null;
|
|
onCompleteStepComplete = onComplete;
|
|
switch(t.stepVo.statusType)
|
|
{
|
|
case TaskStatusType.GET_ITEM:
|
|
removeIds = BagCenter.getIns().getIdsByType(t.stepVo.statusValue.type,t.stepVo.statusValue.num);
|
|
break;
|
|
case TaskStatusType.GET_MONSTER:
|
|
if(int(t.stepVo.statusValue.mode) == 0)
|
|
{
|
|
removeIds = BagCenter.getIns().getIdsByType(t.stepVo.statusValue.type,t.stepVo.statusValue.num);
|
|
}
|
|
else
|
|
{
|
|
removeIds = MonsterCenter.getIns().getTaskMonsterMode2(t.stepVo.statusValue.type,t.stepVo.statusValue.num);
|
|
}
|
|
}
|
|
completeStep_para = {
|
|
"t":t,
|
|
"removeIds":removeIds,
|
|
"showReward":showReward
|
|
};
|
|
NetTask.getIns().finishStep(t.id,t.typeId,removeIds,null,completeStepHandler);
|
|
}
|
|
|
|
private function completeStepHandler(rewardData:Object, re:Object) : void
|
|
{
|
|
var rewardResult:RewardResultVo = null;
|
|
var leftNum:int = 0;
|
|
var i:int = 0;
|
|
var itemVo:ItemVo = null;
|
|
var mons:Array = null;
|
|
var costTi:int = int(re.costTi);
|
|
if(rewardData != null)
|
|
{
|
|
rewardResult = RewardCenter.getRewardResultVoByData(rewardData);
|
|
}
|
|
var removeIds:Array = completeStep_para.removeIds;
|
|
var t:TaskVo = completeStep_para.t;
|
|
t.stepValue = re.taskStepValue;
|
|
var statusType:String = t.stepVo.statusType;
|
|
if(t.stepVo.statusType == TaskStatusType.GET_MONSTER && int(t.stepVo.statusValue.mode) == 0)
|
|
{
|
|
statusType = TaskStatusType.GET_ITEM;
|
|
}
|
|
switch(statusType)
|
|
{
|
|
case TaskStatusType.GET_ITEM:
|
|
if(t.stepVo.statusValue.remove == true)
|
|
{
|
|
leftNum = int(t.stepVo.statusValue.num);
|
|
for(i = 0; i < removeIds.length; )
|
|
{
|
|
itemVo = BagCenter.getIns().getById(removeIds[i]);
|
|
if(itemVo.num >= leftNum)
|
|
{
|
|
BagCenter.getIns().subNum(itemVo.id,leftNum,true,"交出了 {0} 个 {1}");
|
|
break;
|
|
}
|
|
leftNum -= itemVo.num;
|
|
BagCenter.getIns().subNum(itemVo.id,itemVo.num,true,"交出了 {0} 个 {1}");
|
|
i++;
|
|
}
|
|
}
|
|
break;
|
|
case TaskStatusType.GET_MONSTER:
|
|
if(t.stepVo.statusValue.remove == true)
|
|
{
|
|
mons = MonsterCenter.getIns().idsToMons(removeIds);
|
|
MonsterCenter.getIns().removeLocalMonsters(mons);
|
|
}
|
|
break;
|
|
case TaskStatusType.GET_MONEY:
|
|
if(t.stepVo.statusValue.remove == true)
|
|
{
|
|
MasterCenter.getIns().addMoney(-t.stepVo.statusValue.money,true);
|
|
}
|
|
}
|
|
if(!t.stepVo.hasBattle() && (t.stepVo.story == "" || t.stepVo.statusType != TaskStatusType.NONE && t.stepVo.afterStory == ""))
|
|
{
|
|
completeLocalStep(t);
|
|
}
|
|
else
|
|
{
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.TASK_CHANGE));
|
|
}
|
|
if(rewardResult != null)
|
|
{
|
|
RewardCenter.getIns().getReward(rewardResult,completeStep_para.showReward,"alert",null,completeStep_para.showReward);
|
|
}
|
|
MasterCenter.getIns().addTi(-costTi);
|
|
completeStep_para = null;
|
|
if(onCompleteStepComplete != null)
|
|
{
|
|
onCompleteStepComplete(rewardResult);
|
|
onCompleteStepComplete = null;
|
|
}
|
|
}
|
|
|
|
public function unlockLocalTask(taskid:String) : TaskVo
|
|
{
|
|
if(Table.task_info[taskid] == null || Table.task_info[taskid].closed == true)
|
|
{
|
|
return null;
|
|
}
|
|
var task:TaskVo = getLocalTaskByTypeId(taskid);
|
|
if(task == null)
|
|
{
|
|
task = new TaskVo();
|
|
task.id = 0;
|
|
task.typeId = taskid;
|
|
Master.tasks.push(task);
|
|
}
|
|
task.stepVo = task.startStep;
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.TASK_CHANGE));
|
|
return task;
|
|
}
|
|
|
|
public function activityLockStatus(key:String) : Boolean
|
|
{
|
|
var result:Boolean = false;
|
|
for each(var t:TaskVo in Master.tasks)
|
|
{
|
|
if(t.recieved && !t.canFinish() && t.stepVo.statusType == TaskStatusType.SYS_LOCK && t.stepVo.statusValue.key == key)
|
|
{
|
|
Alert.showMsg(lang("任务 {0} 目标达成!",CP.task(t.name)));
|
|
result = true;
|
|
}
|
|
}
|
|
if(result)
|
|
{
|
|
GuideCenter.getIns().fin(key);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public function activityMonsterNum(monType:int) : void
|
|
{
|
|
for each(var t:TaskVo in Master.tasks)
|
|
{
|
|
if(t.recieved && !t.canFinish() && t.stepVo.statusType == TaskStatusType.GET_MONSTER && t.stepVo.statusValue.type == monType)
|
|
{
|
|
if(t.stepVo.isStatusComplete())
|
|
{
|
|
Alert.showMsg(lang("任务 {0} 目标达成!",CP.task(t.name)));
|
|
}
|
|
if(t.stepVo.canStepComplete())
|
|
{
|
|
TaskCenter.getIns().finishStep(t,true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function activityItemNum(itemType:int) : void
|
|
{
|
|
for each(var t:TaskVo in Master.tasks)
|
|
{
|
|
if(t.recieved && !t.canFinish() && t.stepVo.statusType == TaskStatusType.GET_ITEM && t.stepVo.statusValue == itemType)
|
|
{
|
|
if(t.stepVo.isStatusComplete())
|
|
{
|
|
Alert.showMsg(lang("任务 {0} 目标达成!",CP.task(t.name)));
|
|
}
|
|
if(t.stepVo.canStepComplete())
|
|
{
|
|
TaskCenter.getIns().finishStep(t);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function activityMoneyNum() : void
|
|
{
|
|
for each(var t:TaskVo in Master.tasks)
|
|
{
|
|
if(t.recieved && !t.canFinish() && t.stepVo.statusType == TaskStatusType.GET_MONEY)
|
|
{
|
|
if(t.stepVo.isStatusComplete())
|
|
{
|
|
Alert.showMsg(lang("任务 {0} 目标达成!",CP.task(t.name)));
|
|
}
|
|
if(t.stepVo.canStepComplete())
|
|
{
|
|
TaskCenter.getIns().finishStep(t);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function addLocalTask(task:TaskVo) : void
|
|
{
|
|
Master.tasks.push(task);
|
|
Alert.showMsg(lang("获得任务 ") + CP.task(task.name));
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.TASK_CHANGE));
|
|
}
|
|
|
|
public function receiveTask(taskid:String, show:Boolean = true, onComplete:Function = null) : void
|
|
{
|
|
onReceiveTaskComplete = onComplete;
|
|
var task:TaskVo = getLocalTaskByTypeId(taskid);
|
|
if(task != null)
|
|
{
|
|
receiveTask_task = task;
|
|
receiveTask_show = show;
|
|
NetTask.getIns().getTask(task.typeId,receiveTaskHandler);
|
|
}
|
|
}
|
|
|
|
private function receiveTaskHandler(taskData:Object) : void
|
|
{
|
|
receiveTask_task.id = taskData.id;
|
|
receiveTask_task.stepValue = taskData.stepValue;
|
|
receiveTask_task.step = 0;
|
|
receiveTask_task.stepVo = receiveTask_task.getStepVo();
|
|
receiveTask_task.recieved = true;
|
|
if(receiveTask_show)
|
|
{
|
|
Alert.showMsg(lang("获得任务 ") + CP.task(receiveTask_task.name));
|
|
}
|
|
receiveTask_task = null;
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.TASK_CHANGE));
|
|
if(onReceiveTaskComplete != null)
|
|
{
|
|
onReceiveTaskComplete();
|
|
onReceiveTaskComplete = null;
|
|
}
|
|
}
|
|
|
|
public function getLocalTaskByTypeId(taskTypeId:String) : TaskVo
|
|
{
|
|
for each(var t:TaskVo in Master.tasks)
|
|
{
|
|
if(t.typeId == taskTypeId)
|
|
{
|
|
return t;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function getTaskListData(type:int = -1) : Array
|
|
{
|
|
var i:int = 0;
|
|
var t:TaskVo = null;
|
|
var arrSub:Array = [];
|
|
var arrMain:Array = [];
|
|
var arrFinish:Array = [];
|
|
for(i = 0; i < Master.tasks.length; )
|
|
{
|
|
t = Master.tasks[i] as TaskVo;
|
|
if(!(type != -1 && t.type != type))
|
|
{
|
|
if(t.recieved)
|
|
{
|
|
if(t.canFinish())
|
|
{
|
|
arrFinish.push(t);
|
|
}
|
|
else if(t.isMain)
|
|
{
|
|
arrMain.push(t);
|
|
}
|
|
else
|
|
{
|
|
arrSub.push(t);
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
return arrFinish.concat(arrMain.concat(arrSub.reverse()));
|
|
}
|
|
|
|
public function hasTaskByPosition(pos:String) : Boolean
|
|
{
|
|
var _loc4_:int = 0;
|
|
var _loc3_:* = Master.tasks;
|
|
while(true)
|
|
{
|
|
for each(var t:TaskVo in _loc3_)
|
|
{
|
|
if(!t.complete && !t.canFinish() && !t.closed && t.stepVo.position.indexOf(pos) == 0 && t.stepVo.canShow())
|
|
{
|
|
if(!(t.stepVo.position != pos && Table.game_setting.closePosCheckType2 != true))
|
|
{
|
|
break;
|
|
}
|
|
if(t.stepVo.position.charAt(pos.length) == "_")
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public function hasTaskByOtherCity(curcity:int) : Boolean
|
|
{
|
|
var i:int = 0;
|
|
if(!CityVo.checkUnlock(curcity))
|
|
{
|
|
return false;
|
|
}
|
|
var citys:Array = [1,2,3,4,5];
|
|
citys.splice(citys.indexOf(curcity),1);
|
|
for each(var t:TaskVo in Master.tasks)
|
|
{
|
|
if(t.recieved && !t.complete && !t.canFinish())
|
|
{
|
|
i = 0;
|
|
while(i < citys.length)
|
|
{
|
|
if(t.stepVo.position.indexOf("city" + citys[i]) == 0)
|
|
{
|
|
return true;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public function getTaskById(id:int) : TaskVo
|
|
{
|
|
var t:Object = ArrayUtil.getElementByValue(Master.tasks,"id",id);
|
|
if(t != null)
|
|
{
|
|
return t as TaskVo;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function getTaskByType(typeId:String) : TaskVo
|
|
{
|
|
var a:Object = null;
|
|
if(typeId == "1001002")
|
|
{
|
|
trace(1);
|
|
a = Master.tasks;
|
|
}
|
|
var t:Object = ArrayUtil.getElementByValue(Master.tasks,"typeId",typeId);
|
|
if(t != null)
|
|
{
|
|
return t as TaskVo;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function getTaskByPosition(pos:String) : TaskVo
|
|
{
|
|
var i:int = 0;
|
|
var t:TaskVo = null;
|
|
for(i = 0; i < Master.tasks.length; )
|
|
{
|
|
t = Master.tasks[i] as TaskVo;
|
|
if(!t.complete && !t.canFinish() && t.stepVo.position == pos)
|
|
{
|
|
return Master.tasks[i];
|
|
}
|
|
i++;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function getProcessTask(taskid:String) : TaskVo
|
|
{
|
|
var i:int = 0;
|
|
var t:TaskVo = null;
|
|
for(i = 0; i < Master.tasks.length; )
|
|
{
|
|
t = Master.tasks[i] as TaskVo;
|
|
if(t.typeId == taskid)
|
|
{
|
|
return Master.tasks[i];
|
|
}
|
|
i++;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function hasTaskFinish() : Boolean
|
|
{
|
|
for each(var t:TaskVo in Master.tasks)
|
|
{
|
|
if(t.canFinish() && !t.complete)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public function checkReceivableTask() : Boolean
|
|
{
|
|
var i:int = 0;
|
|
var rvo:TaskVo = null;
|
|
var curTaskTypeIds:Array = [];
|
|
var addNew:Boolean = false;
|
|
for(i = 0; i < Master.tasks.length; )
|
|
{
|
|
curTaskTypeIds.push(Master.tasks[i].typeId);
|
|
i++;
|
|
}
|
|
for(var key:String in Master.history.unlockTask)
|
|
{
|
|
if(Table.task_info[key] != null && Table.task_info[key].closed != true && Master.history.passTask[key] == null && curTaskTypeIds.indexOf(key) == -1)
|
|
{
|
|
rvo = new TaskVo();
|
|
rvo.id = 0;
|
|
rvo.typeId = key;
|
|
rvo.stepVo = rvo.startStep;
|
|
rvo.stepVo.isStartStep = true;
|
|
Master.tasks.push(rvo);
|
|
addNew = true;
|
|
}
|
|
}
|
|
return addNew;
|
|
}
|
|
|
|
public function autoCheckResetLoopTask() : void
|
|
{
|
|
if(resetingLoopTask)
|
|
{
|
|
return;
|
|
}
|
|
var oldDay:String = MyrCalendar.getDayNumber(Master.history.loopTaskTime * 1000).toString();
|
|
var newDay:String = MyrCalendar.getDayNumber(TimeCenter.timestamp * 1000 - 10000).toString();
|
|
if(oldDay != newDay)
|
|
{
|
|
resetLoopTask();
|
|
}
|
|
}
|
|
|
|
public function resetLoopTask() : void
|
|
{
|
|
resetingLoopTask = true;
|
|
NetTask.getIns().resetLoopTask(resetLoopTaskHandler);
|
|
}
|
|
|
|
private function resetLoopTaskHandler(newLoopTask:Object) : void
|
|
{
|
|
var t:TaskVo = null;
|
|
var i:int = 0;
|
|
Master.history.loopTaskNum = GameMath.loopTaskMaxNum;
|
|
Master.history.loopTask = newLoopTask;
|
|
Master.history.loopTaskTime = TimeCenter.timestamp;
|
|
for(i = 0; i < Master.tasks.length; )
|
|
{
|
|
t = Master.tasks[i];
|
|
if(t.type == TaskType.LOOP_TASK)
|
|
{
|
|
Alert.showMsg(lang("委托 {0} 超过了时限。",CP.task(t.name)));
|
|
Master.tasks.splice(i,1);
|
|
i--;
|
|
}
|
|
i++;
|
|
}
|
|
if(GuideCenter.getIns().checkFin(GSub.OPEN_XIEHUI))
|
|
{
|
|
Alert.showMsg(lang("驯养师协会有新到的委托任务!"));
|
|
}
|
|
if(onResetLoopTaskComplete != null)
|
|
{
|
|
onResetLoopTaskComplete();
|
|
onResetLoopTaskComplete = null;
|
|
}
|
|
resetingLoopTask = false;
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.LOOP_TASK_UPDATE));
|
|
}
|
|
|
|
public function getLoopTask(taskTypeId:String, city:int, onComplete:Function) : void
|
|
{
|
|
onGetLoopTaskComplete = onComplete;
|
|
getLoopTask_para = {"city":city};
|
|
NetTask.getIns().getLoopTask(taskTypeId,city,getLoopTaskHandler);
|
|
}
|
|
|
|
private function getLoopTaskHandler(taskData:Object) : void
|
|
{
|
|
var newTask:TaskVo = getTaskByTaskData(taskData);
|
|
Master.tasks.push(newTask);
|
|
Master.history.loopTaskNum--;
|
|
ArrayUtil.remove(Master.history.loopTask[getLoopTask_para.city],int(newTask.typeId));
|
|
Alert.showMsg(lang("接取了委托任务 {0}",CP.task(newTask.name)));
|
|
getLoopTask_para = null;
|
|
if(onGetLoopTaskComplete != null)
|
|
{
|
|
onGetLoopTaskComplete(newTask);
|
|
onGetLoopTaskComplete = null;
|
|
}
|
|
}
|
|
|
|
public function loopTaskResetLeftTime() : int
|
|
{
|
|
return MyrCalendar.leftTomorrowSecond(TimeCenter.timestamp * 1000) / 1000;
|
|
}
|
|
}
|
|
}
|
|
|