using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
namespace vnxbqy.UI
|
{
|
public class TaskFeedbackModel : Model
|
{
|
Dictionary<int, TaskFeedback> m_TaskFeedbacks = new Dictionary<int, TaskFeedback>();
|
|
public readonly List<int> taskFeedbackFuncs = new List<int>();
|
|
public static Vector3 s_ClickPosition = Vector3.zero;
|
|
ReikiRootModel reikiRootModel { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }
|
PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }
|
TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
|
AlchemyModel alchemyModel { get { return ModelCenter.Instance.GetModel<AlchemyModel>(); } }
|
EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }
|
EquipStrengthModel equipStrengthModel { get { return ModelCenter.Instance.GetModel<EquipStrengthModel>(); } }
|
TreasureSkillModel treasureSkillModel { get { return ModelCenter.Instance.GetModel<TreasureSkillModel>(); } }
|
|
public override void Init()
|
{
|
ParseConfig();
|
}
|
|
public override void UnInit()
|
{
|
}
|
|
void ParseConfig()
|
{
|
var configs = TaskFeedbackConfig.GetValues();
|
foreach (var config in configs)
|
{
|
if (config.type == 100)
|
{
|
continue;
|
}
|
|
var feedback = new TaskFeedback()
|
{
|
taskId = config.taskId,
|
type = (TaskFeedbackType)config.type,
|
};
|
|
switch (feedback.type)
|
{
|
case TaskFeedbackType.SideTask:
|
case TaskFeedbackType.FightPowerSideTask:
|
{
|
var array = LitJson.JsonMapper.ToObject<int[][]>(config.sideTasks);
|
if (array != null)
|
{
|
List<int[]> sideTasks = new List<int[]>(array.Length);
|
for (int i = 0; i < array.Length; i++)
|
{
|
sideTasks.Add(array[i]);
|
}
|
feedback.sideTasks = sideTasks;
|
}
|
}
|
break;
|
case TaskFeedbackType.Equip:
|
{
|
var array = LitJson.JsonMapper.ToObject<int[]>(config.equips);
|
feedback.equipCondition = array;
|
}
|
break;
|
case TaskFeedbackType.ItemCount:
|
{
|
var array = LitJson.JsonMapper.ToObject<int[][]>(config.items);
|
if (array != null)
|
{
|
List<Item> items = new List<Item>();
|
for (int i = 0; i < array.Length; i++)
|
{
|
items.Add(new Item()
|
{
|
id = array[i][0],
|
count = array[i][1],
|
});
|
}
|
feedback.items = items;
|
}
|
}
|
break;
|
case TaskFeedbackType.SkyTowerFightPoint:
|
{
|
if (!string.IsNullOrEmpty(config.reikiRoot))
|
{
|
var point = 0;
|
int.TryParse(config.reikiRoot, out point);
|
feedback.totalPoints = point;
|
}
|
}
|
break;
|
case TaskFeedbackType.ReikiPoint:
|
{
|
if (!string.IsNullOrEmpty(config.reikiRoot))
|
{
|
var json = LitJson.JsonMapper.ToObject(config.reikiRoot);
|
feedback.reikiRoots = new Dictionary<int, List<int[]>>();
|
foreach (var jobKey in json.Keys)
|
{
|
var job = int.Parse(jobKey);
|
var intArray = LitJson.JsonMapper.ToObject<int[][]>(json[jobKey].ToJson());
|
feedback.reikiRoots.Add(job, new List<int[]>());
|
for (int i = 0; i < intArray.Length; i++)
|
{
|
feedback.reikiRoots[job].Add(intArray[i]);
|
}
|
}
|
}
|
}
|
break;
|
}
|
|
if (!string.IsNullOrEmpty(config.failFuncs))
|
{
|
var funcArray = LitJson.JsonMapper.ToObject<int[][]>(config.failFuncs);
|
if (funcArray != null)
|
{
|
List<int[]> failFuncs = new List<int[]>(funcArray.Length);
|
for (int i = 0; i < funcArray.Length; i++)
|
{
|
failFuncs.Add(funcArray[i]);
|
}
|
feedback.failFuns = failFuncs;
|
}
|
}
|
|
m_TaskFeedbacks.Add(config.taskId, feedback);
|
}
|
}
|
|
public bool TryGetTaskFeedback(int taskId, out TaskFeedback feedback)
|
{
|
return m_TaskFeedbacks.TryGetValue(taskId, out feedback);
|
}
|
|
public void ExecuteTaskFeedback(int taskId)
|
{
|
if (NewBieCenter.Instance.inGuiding)
|
{
|
return;
|
}
|
|
if (!WindowCenter.Instance.IsOpen<MainInterfaceWin>() && taskId != 3110)
|
{
|
//特殊写死3110限制105级开启宗门试炼 触发提示逻辑，如后续不需要，请果断删除
|
return;
|
}
|
|
TaskFeedback feedback;
|
if (TryGetTaskFeedback(taskId, out feedback))
|
{
|
var config = TaskFeedbackConfig.Get(taskId);
|
|
switch (feedback.type)
|
{
|
case TaskFeedbackType.FightPower:
|
case TaskFeedbackType.Copper:
|
case TaskFeedbackType.ReikiPoint:
|
case TaskFeedbackType.Guide:
|
case TaskFeedbackType.Equip:
|
case TaskFeedbackType.ItemCount:
|
case TaskFeedbackType.SkyTowerFightPoint:
|
case TaskFeedbackType.DemonTreasure:
|
case TaskFeedbackType.AlchemyItem:
|
case TaskFeedbackType.HasFairy:
|
{
|
int condition = 0;
|
if (IsSatisfyCondition(feedback, out condition))
|
{
|
ExecuteSuccFeedback(taskId);
|
}
|
else
|
{
|
if (config.remind != null && config.remind.Length > 0)
|
{
|
var index = Mathf.Min(condition, config.remind.Length - 1);
|
SysNotifyMgr.Instance.ShowTip(config.remind[index]);
|
}
|
if (feedback.failFuns != null)
|
{
|
var index = Mathf.Min(condition, feedback.failFuns.Count - 1);
|
var funcTitle = index < config.funcTitles.Length ? config.funcTitles[index] : string.Empty;
|
List<int> succFuncs;
|
if (TryGetSatisfyConditionFuncs(feedback.failFuns[index], out succFuncs))
|
{
|
taskFeedbackFuncs.Clear();
|
if (config.onlyOneFunc != null &&
|
index < config.onlyOneFunc.Length && config.onlyOneFunc[index] == 1)
|
{
|
taskFeedbackFuncs.Add(succFuncs[0]);
|
}
|
else
|
{
|
taskFeedbackFuncs.AddRange(succFuncs);
|
}
|
TaskFeedbackFuncWin.funcTitle = funcTitle;
|
WindowCenter.Instance.Open<TaskFeedbackFuncWin>();
|
}
|
}
|
}
|
}
|
break;
|
case TaskFeedbackType.SideTask:
|
{
|
int condition = 0;
|
if (IsSatisfyCondition(feedback, out condition))
|
{
|
ExecuteSuccFeedback(taskId);
|
}
|
else
|
{
|
if (config.remind != null && config.remind.Length > 0)
|
{
|
var taskIndex = feedback.IndexOfSideTasks(condition);
|
var index = Mathf.Min(taskIndex, config.remind.Length - 1);
|
SysNotifyMgr.Instance.ShowTip(config.remind[index]);
|
}
|
if (feedback.failFuns != null)
|
{
|
var taskIndex = feedback.IndexOfSideTasks(condition);
|
var index = Mathf.Min(taskIndex, feedback.failFuns.Count - 1);
|
var funcTitle = index < config.funcTitles.Length ? config.funcTitles[index] : string.Empty;
|
List<int> succFuncs;
|
if (TryGetSatisfyConditionFuncs(feedback.failFuns[index], out succFuncs))
|
{
|
taskFeedbackFuncs.Clear();
|
if (config.onlyOneFunc != null &&
|
index < config.onlyOneFunc.Length && config.onlyOneFunc[index] == 1)
|
{
|
taskFeedbackFuncs.Add(succFuncs[0]);
|
}
|
else
|
{
|
taskFeedbackFuncs.AddRange(succFuncs);
|
}
|
TaskFeedbackFuncWin.funcTitle = funcTitle;
|
WindowCenter.Instance.Open<TaskFeedbackFuncWin>();
|
}
|
}
|
}
|
}
|
break;
|
case TaskFeedbackType.FightPowerSideTask:
|
{
|
int condition = 0;
|
if (IsSatisfyCondition(feedback, out condition))
|
{
|
ExecuteSuccFeedback(taskId);
|
}
|
else
|
{
|
if (config.remind != null && config.remind.Length > 0)
|
{
|
var index = Mathf.Min(condition, config.remind.Length - 1);
|
SysNotifyMgr.Instance.ShowTip(config.remind[index]);
|
}
|
if (feedback.failFuns != null)
|
{
|
var sideTaskId = 0;
|
IsSatisfySideTask(feedback.sideTasks, out sideTaskId);
|
var taskIndex = feedback.IndexOfSideTasks(sideTaskId);
|
var index = Mathf.Min(taskIndex, feedback.failFuns.Count - 1);
|
var funcTitle = index < config.funcTitles.Length ? config.funcTitles[index] : string.Empty;
|
List<int> succFuncs;
|
if (TryGetSatisfyConditionFuncs(feedback.failFuns[index], out succFuncs))
|
{
|
taskFeedbackFuncs.Clear();
|
if (config.onlyOneFunc != null &&
|
index < config.onlyOneFunc.Length && config.onlyOneFunc[index] == 1)
|
{
|
taskFeedbackFuncs.Add(succFuncs[0]);
|
}
|
else
|
{
|
taskFeedbackFuncs.AddRange(succFuncs);
|
}
|
TaskFeedbackFuncWin.funcTitle = funcTitle;
|
WindowCenter.Instance.Open<TaskFeedbackFuncWin>();
|
}
|
}
|
}
|
}
|
break;
|
case TaskFeedbackType.OnekeyHangUp:
|
{
|
OnekeyHangUp();
|
}
|
break;
|
}
|
}
|
}
|
|
public void OnekeyHangUp()
|
{
|
|
var mapModel = ModelCenter.Instance.GetModel<MapModel>();
|
var point = mapModel.GetRecommendHangPoint();
|
var config = MapEventPointConfig.Get(point);
|
|
var mapId = MapUtility.GetMapId(config.DataMapID, config.LineId);
|
MapTransferUtility.Instance.MissionFlyTo(mapId, config.NPCID, MapTransferType.WorldTransport);
|
}
|
|
public void ExecuteSuccFeedback(int id)
|
{
|
var config = TaskFeedbackConfig.Get(id);
|
var guide = config.succGuide;
|
if (guide != 0 && !NewBieCenter.Instance.IsGuideCompleted(guide))
|
{
|
ExecuteGuide(guide);
|
}
|
else
|
{
|
if (config.jump != 0)
|
{
|
WindowJumpMgr.Instance.WindowJumpTo((JumpUIType)config.jump);
|
}
|
}
|
}
|
|
public void ExecuteGuide(int id)
|
{
|
if (id == 0)
|
{
|
return;
|
}
|
var config = GuideConfig.Get(id);
|
if (config == null)
|
{
|
DebugEx.LogFormat("引导<color=#ff0000>{0}</color>未添加", id);
|
return;
|
}
|
switch ((GuideType)config.Type)
|
{
|
case GuideType.Functional:
|
if (FunctionalGuideCenter.Instance.ExistUnderwayGuide(id))
|
{
|
FunctionalGuideCenter.Instance.RemoveGuide(id);
|
NewBieCenter.Instance.ResetGuide(id);
|
SnxxzGame.Instance.StartCoroutine(_ExecuteGuide(id));
|
}
|
else
|
{
|
FunctionalGuideCenter.Instance.StartGuide(id);
|
}
|
break;
|
default:
|
NewBieCenter.Instance.StartNewBieGuideEx(id);
|
break;
|
}
|
}
|
|
IEnumerator _ExecuteGuide(int id)
|
{
|
yield return null;
|
FunctionalGuideCenter.Instance.StartGuide(id);
|
}
|
|
public bool IsSatisfyCondition(TaskFeedback feedback, out int condition)
|
{
|
var config = TaskFeedbackConfig.Get(feedback.taskId);
|
condition = 0;
|
switch (feedback.type)
|
{
|
case TaskFeedbackType.FightPower:
|
return PlayerDatas.Instance.baseData.FightPoint >= (ulong)config.condition;
|
case TaskFeedbackType.SideTask:
|
return IsSatisfySideTask(feedback.sideTasks, out condition);
|
case TaskFeedbackType.ReikiPoint:
|
{
|
if (reikiRootModel.GetReikiRootTotalPointWithFree() < config.condition)
|
{
|
return false;
|
}
|
if (feedback.reikiRoots != null)
|
{
|
var job = PlayerDatas.Instance.baseData.Job;
|
var reikiRoots = feedback.reikiRoots[job];
|
foreach (var reikiRoot in reikiRoots)
|
{
|
if (reikiRootModel.GetReikiRootPoint(reikiRoot[0]) < reikiRoot[1])
|
{
|
condition = 1;
|
return false;
|
}
|
}
|
}
|
}
|
return true;
|
case TaskFeedbackType.Equip:
|
{
|
var items = packModel.GetItems(PackType.Item, new SinglePack.FilterParams()
|
{
|
levels = new List<int>() { feedback.equipCondition[0] },
|
qualitys = new List<int>() { feedback.equipCondition[1] },
|
equipTypes = EquipModel.realmEquipTypes,
|
jobs = new List<int>() { PlayerDatas.Instance.baseData.Job },
|
});
|
return items != null && items.Count > 0;
|
}
|
case TaskFeedbackType.Copper:
|
return PlayerDatas.Instance.baseData.allCopper >= (ulong)config.condition;
|
case TaskFeedbackType.Guide:
|
return true;
|
case TaskFeedbackType.FightPowerSideTask:
|
return PlayerDatas.Instance.baseData.FightPoint >= (ulong)config.condition;
|
case TaskFeedbackType.ItemCount:
|
{
|
if (feedback.items != null)
|
{
|
foreach (var item in feedback.items)
|
{
|
if (packModel.GetItemCountByID(PackType.Item, item.id) < item.count)
|
{
|
return false;
|
}
|
}
|
}
|
return true;
|
}
|
case TaskFeedbackType.AlchemyItem:
|
{
|
if (!alchemyModel.IsGraspRecipe(config.condition))
|
{
|
var error = 0;
|
if (alchemyModel.TryLearn(config.condition, out error))
|
{
|
return true;
|
}
|
return false;
|
}
|
Item material;
|
return alchemyModel.GetStoveState(config.condition) != 0
|
|| alchemyModel.IsAlchemyEnoughMaterial(config.condition, out material);
|
}
|
case TaskFeedbackType.SkyTowerFightPoint:
|
{
|
var skyTowerConfig = SkyTowerConfig.Get(config.condition);
|
if (skyTowerConfig != null)
|
{
|
if (feedback.totalPoints > 0 && PlayerDatas.Instance.baseData.FightPoint < (ulong)NPCExConfig.Get(skyTowerConfig.bossId).SuppressFightPower)
|
{
|
condition = reikiRootModel.GetReikiRootTotalPointWithFree() >= feedback.totalPoints ? 0 : 1;
|
return false;
|
}
|
else
|
{
|
return PlayerDatas.Instance.baseData.FightPoint >= (ulong)NPCExConfig.Get(skyTowerConfig.bossId).SuppressFightPower;
|
}
|
}
|
}
|
break;
|
case TaskFeedbackType.DemonTreasure:
|
{
|
TreasureDungeon treasureDungeon;
|
if (treasureModel.TryGetTreasureDungeon(config.condition, out treasureDungeon))
|
{
|
var dungeonInfo = treasureDungeon.Get(treasureDungeon.currentLevel + 1);
|
if (!dungeonInfo.Equals(default(TreasureDungeonInfo)))
|
{
|
return (int)UIHelper.GetPropertyValue(PropertyType.DEF) >= dungeonInfo.defense;
|
}
|
return true;
|
}
|
}
|
break;
|
case TaskFeedbackType.HasFairy:
|
{
|
return PlayerDatas.Instance.baseData.FamilyId > 0;
|
}
|
}
|
return false;
|
}
|
|
public bool IsSatisfySideTask(List<int[]> sideTasks, out int condition)
|
{
|
condition = 0;
|
foreach (var taskId in taskModel.SideQuestsDic.Keys)
|
{
|
for (int i = 0; i < sideTasks.Count; i++)
|
{
|
if (taskId >= sideTasks[i][0]
|
&& taskId <= sideTasks[i][1])
|
{
|
condition = taskId;
|
return false;
|
}
|
}
|
}
|
return true;
|
}
|
|
public bool TryGetSatisfyConditionFuncs(int[] funcs, out List<int> succFuncs)
|
{
|
succFuncs = null;
|
if (funcs != null && funcs.Length > 0)
|
{
|
succFuncs = new List<int>();
|
for (int i = 0; i < funcs.Length; i++)
|
{
|
if (IsSatisfyFuncConfition(funcs[i]))
|
{
|
succFuncs.Add(funcs[i]);
|
}
|
}
|
return succFuncs.Count > 0;
|
}
|
return false;
|
}
|
|
public bool IsSatisfyFuncConfition(int func)
|
{
|
var config = TaskFeedbackFuncConfig.Get(func);
|
if (config != null)
|
{
|
switch (config.type)
|
{
|
case 1:
|
foreach (var item in config.itemCondition)
|
{
|
var count = packModel.GetItemCountByID(PackType.Item, item.x);
|
if (count < item.y)
|
{
|
return false;
|
}
|
}
|
return true;
|
case 2:
|
return reikiRootModel.freePoint > 0;
|
case 3:
|
foreach (var equipSet in equipModel.GetUnLockedEquipSets())
|
{
|
if (equipModel.ExistBetterEquip(equipSet, EquipModel.realmEquipTypes))
|
{
|
return true;
|
}
|
}
|
return false;
|
case 4:
|
MissionDetailDates taskData;
|
if (taskModel.TryGetTaskData(config.condition, out taskData))
|
{
|
return taskData.MissionState != 3;
|
}
|
return false;
|
case 5:
|
return equipStrengthModel.ExistAnySatisfyStrengh();
|
case 6:
|
if (!alchemyModel.IsGraspRecipe(config.condition))
|
{
|
var error = 0;
|
if (alchemyModel.TryLearn(config.condition, out error))
|
{
|
return true;
|
}
|
return false;
|
}
|
Item material;
|
return alchemyModel.GetStoveState(config.condition) != 0
|
|| alchemyModel.IsAlchemyEnoughMaterial(config.condition, out material);
|
case 7:
|
{
|
foreach (var funcId in config.excludeFuncs)
|
{
|
if (funcId == func)
|
{
|
continue;
|
}
|
if (IsSatisfyFuncConfition(funcId))
|
{
|
return false;
|
}
|
}
|
return true;
|
}
|
case 10:
|
{
|
if (config.expertSkills != null)
|
{
|
foreach (var skill in config.expertSkills)
|
{
|
if (treasureSkillModel.IsSatisfyLevelUpSkill(skill.x, skill.y, skill.z))
|
{
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
case 11:
|
{
|
if (config.condition != 0)
|
{
|
Treasure treasure;
|
if (treasureModel.TryGetTreasure(config.condition, out treasure)
|
&& treasure.state != TreasureState.Collected)
|
{
|
return true;
|
}
|
}
|
}
|
return false;
|
default:
|
return true;
|
}
|
}
|
return false;
|
}
|
}
|
|
public struct TaskFeedback
|
{
|
public int taskId;
|
public TaskFeedbackType type;
|
public List<int[]> sideTasks;
|
public int[] equipCondition;
|
public List<Item> items;
|
public Dictionary<int, List<int[]>> reikiRoots;
|
public List<int[]> failFuns;
|
public int totalPoints;
|
|
public int IndexOfSideTasks(int taskId)
|
{
|
var index = 0;
|
for (int i = 0; i < sideTasks.Count; i++)
|
{
|
if (taskId >= sideTasks[i][0]
|
&& taskId <= sideTasks[i][1])
|
{
|
index += taskId - sideTasks[i][0];
|
break;
|
}
|
index += (sideTasks[i][1] - sideTasks[i][0] + 1);
|
}
|
return index;
|
}
|
}
|
|
public enum TaskFeedbackType
|
{
|
FightPower = 1,
|
SideTask = 2,
|
ReikiPoint = 3,
|
Equip = 4,
|
Copper = 5,
|
Guide = 6,
|
FightPowerSideTask = 7,
|
ItemCount = 8,
|
SkyTowerFightPoint = 9,
|
DemonTreasure = 10,
|
AlchemyItem = 11,
|
HasFairy = 12,
|
OnekeyHangUp = 13,
|
//后续IL开发添加预设
|
default1,
|
default2,
|
default3,
|
default4,
|
default5,
|
default6,
|
default7,
|
default8,
|
default9,
|
default10,
|
}
|
}
|
|
