public WarpPoint PairPoint()
{
MapArea ownerArea = this.OwnerArea;
if (Object.op_Equality((Object)ownerArea, (Object)null))
{
return((WarpPoint)null);
}
Dictionary <int, List <WarpPoint> > dictionary;
List <WarpPoint> warpPointList;
if (!Singleton <Manager.Map> .Instance.WarpPointDic.TryGetValue(ownerArea.ChunkID, out dictionary) || !dictionary.TryGetValue(this._tableID, out warpPointList))
{
return((WarpPoint)null);
}
if (warpPointList.Count < 2)
{
return((WarpPoint)null);
}
WarpPoint warpPoint1 = (WarpPoint)null;
foreach (WarpPoint warpPoint2 in warpPointList)
{
if (!Object.op_Equality((Object)warpPoint2, (Object)this) && !Object.op_Equality((Object)warpPoint2, (Object)null))
{
warpPoint1 = warpPoint2;
}
}
return(warpPoint1);
}
public virtual TaskStatus OnUpdate()
{
AgentActor agent = this.Agent;
agent.StopNavMeshAgent();
agent.ChangeStaticNavMeshAgentAvoidance();
agent.CurrentPoint = agent.TargetInSightActionPoint;
agent.SetActiveOnEquipedItem(false);
agent.ChaControl.setAllLayerWeight(0.0f);
agent.ElectNextPoint();
if (Object.op_Equality((Object)agent.CurrentPoint, (Object)null))
{
this.ClearDesire(agent);
return((TaskStatus)2);
}
agent.CurrentPoint.SetActiveMapItemObjs(false);
WarpPoint currentPoint = agent.CurrentPoint as WarpPoint;
if (Object.op_Equality((Object)currentPoint, (Object)null))
{
agent.CurrentPoint = (ActionPoint)null;
this.ClearDesire(agent);
return((TaskStatus)2);
}
WarpPoint warpPoint = currentPoint.PairPoint();
Renderer[] renderers = warpPoint.Renderers;
bool flag = false;
if (!renderers.IsNullOrEmpty <Renderer>())
{
foreach (Renderer renderer in renderers)
{
if (renderer.get_isVisible())
{
flag = true;
break;
}
}
}
if (agent.ChaControl.IsVisibleInCamera)
{
ActorCameraControl cameraControl = Singleton <Manager.Map> .Instance.Player.CameraControl;
if ((double)Vector3.Distance(agent.Position, ((Component)cameraControl).get_transform().get_position()) <= (double)Singleton <Resources> .Instance.LocomotionProfile.CrossFadeEnableDistance)
{
cameraControl.CrossFade.FadeStart(-1f);
}
}
else if (flag)
{
Singleton <Manager.Map> .Instance.Player.CameraControl.CrossFade.FadeStart(-1f);
}
this.PlayWarpSE(400, ((Component)currentPoint).get_transform());
this.PlayWarpSE(401, ((Component)warpPoint).get_transform());
agent.NavMeshWarp(((Component)warpPoint).get_transform(), 0, 100f);
this.ClearDesire(agent);
return((TaskStatus)2);
}
private static void CreateList(
AgentActor agent,
List <ActionPoint> source,
List <ActionPoint> destination,
EventType eventType,
bool isFollow,
bool isRain)
{
int chunkId = agent.ChunkID;
Dictionary <int, bool> toRelease = DictionaryPool <int, bool> .Get();
int searchCount = Singleton <Manager.Map> .Instance.EnvironmentProfile.SearchCount;
float meshSampleDistance = Singleton <Resources> .Instance.LocomotionProfile.ActionPointNavMeshSampleDistance;
foreach (ActionPoint actionPoint1 in source)
{
if (!Object.op_Equality((Object)actionPoint1, (Object)null) && !Object.op_Equality((Object)actionPoint1.OwnerArea, (Object)null) && (actionPoint1.IsNeutralCommand && !actionPoint1.IsReserved(agent)))
{
List <ActionPoint> connectedActionPoints = actionPoint1.ConnectedActionPoints;
if (!connectedActionPoints.IsNullOrEmpty <ActionPoint>())
{
bool flag = false;
foreach (ActionPoint actionPoint2 in connectedActionPoints)
{
if (!Object.op_Equality((Object)actionPoint2, (Object)null) && (!actionPoint2.IsNeutralCommand || actionPoint2.IsReserved(agent)))
{
flag = true;
break;
}
}
if (flag)
{
continue;
}
}
if (!isRain || actionPoint1.AreaType == MapArea.AreaType.Indoor)
{
MapArea ownerArea = actionPoint1.OwnerArea;
bool flag1;
if (!toRelease.TryGetValue(ownerArea.AreaID, out flag1))
{
toRelease[ownerArea.AreaID] = flag1 = Singleton <Manager.Map> .Instance.CheckAvailableMapArea(ownerArea.AreaID);
}
if (flag1 && (!isFollow ? actionPoint1.AgentEventType : actionPoint1.AgentDateEventType).Contains(eventType))
{
switch (eventType)
{
case EventType.Eat:
StuffItem carryingItem = agent.AgentData.CarryingItem;
AgentProfile agentProfile = Singleton <Resources> .Instance.AgentProfile;
ItemIDKeyPair[] canStandEatItems = Singleton <Resources> .Instance.AgentProfile.CanStandEatItems;
bool flag2 = false;
foreach (ItemIDKeyPair itemIdKeyPair in canStandEatItems)
{
if (carryingItem.CategoryID == itemIdKeyPair.categoryID && carryingItem.ID == itemIdKeyPair.itemID)
{
flag2 = true;
break;
}
}
ActionPointInfo outInfo;
if (flag2)
{
PoseKeyPair eatDeskId1 = agentProfile.PoseIDTable.EatDeskID;
PoseKeyPair eatDeskId2 = agentProfile.PoseIDTable.EatDeskID;
if (actionPoint1.FindAgentActionPointInfo(EventType.Eat, eatDeskId1.poseID, out outInfo) || actionPoint1.FindAgentActionPointInfo(EventType.Eat, eatDeskId2.poseID, out outInfo))
{
break;
}
continue;
}
PoseKeyPair eatDishId = agentProfile.PoseIDTable.EatDishID;
if (actionPoint1.FindAgentActionPointInfo(EventType.Eat, eatDishId.poseID, out outInfo))
{
break;
}
continue;
case EventType.Search:
SearchActionPoint searchActionPoint = actionPoint1 as SearchActionPoint;
if (Object.op_Inequality((Object)searchActionPoint, (Object)null))
{
int registerId = searchActionPoint.RegisterID;
Dictionary <int, AIProject.SaveData.Environment.SearchActionInfo> searchActionLockTable = agent.AgentData.SearchActionLockTable;
AIProject.SaveData.Environment.SearchActionInfo searchActionInfo1;
if (!searchActionLockTable.TryGetValue(registerId, out searchActionInfo1))
{
AIProject.SaveData.Environment.SearchActionInfo searchActionInfo2 = new AIProject.SaveData.Environment.SearchActionInfo();
searchActionLockTable[registerId] = searchActionInfo2;
searchActionInfo1 = searchActionInfo2;
}
if (searchActionInfo1.Count < searchCount)
{
int tableId = searchActionPoint.TableID;
StuffItem itemInfo = agent.AgentData.EquipedSearchItem(tableId);
if (agent.SearchAreaID == 0)
{
if (tableId != 0 && tableId != 1 && tableId != 2 || !searchActionPoint.CanSearch(EventType.Search, itemInfo))
{
continue;
}
break;
}
if (agent.SearchAreaID != searchActionPoint.TableID || !searchActionPoint.CanSearch(EventType.Search, itemInfo))
{
continue;
}
break;
}
continue;
}
break;
case EventType.Warp:
WarpPoint warpPoint = actionPoint1 as WarpPoint;
Dictionary <int, List <WarpPoint> > dictionary;
List <WarpPoint> warpPointList;
if (!Object.op_Inequality((Object)warpPoint, (Object)null) || !Singleton <Manager.Map> .Instance.WarpPointDic.TryGetValue(ownerArea.ChunkID, out dictionary) || (!dictionary.TryGetValue(warpPoint.TableID, out warpPointList) || warpPointList.Count < 2))
{
continue;
}
break;
}
if (SetDesiredRandomAction._navMeshPath == null)
{
SetDesiredRandomAction._navMeshPath = new NavMeshPath();
}
NavMeshHit navMeshHit;
if (agent.NavMeshAgent.CalculatePath(actionPoint1.LocatedPosition, SetDesiredRandomAction._navMeshPath) && SetDesiredRandomAction._navMeshPath.get_status() == null && NavMesh.SamplePosition(actionPoint1.LocatedPosition, ref navMeshHit, meshSampleDistance, agent.NavMeshAgent.get_areaMask()))
{
destination.Add(actionPoint1);
}
}
}
}
}
DictionaryPool <int, bool> .Release(toRelease);
}
protected override void InitSub()
{
CommonDefine.CommonIconGroup icon = Singleton <Resources> .Instance.CommonDefine.Icon;
EventType playerEventMask = Singleton <Resources> .Instance.DefinePack.MapDefines.PlayerEventMask;
List <CommandLabel.CommandInfo> toRelease1 = ListPool <CommandLabel.CommandInfo> .Get();
foreach (KeyValuePair <EventType, Tuple <int, string, System.Action <PlayerActor, ActionPoint> > > keyValuePair in ActionPoint.LabelTable)
{
KeyValuePair <EventType, Tuple <int, string, System.Action <PlayerActor, ActionPoint> > > pair = keyValuePair;
WarpPoint warpPoint = this;
if (this._playerEventType.Contains(pair.Key) && playerEventMask.Contains(pair.Key) && AIProject.Definitions.Action.NameTable.TryGetValue(pair.Key, out ValueTuple <int, string> _))
{
ActionPointInfo actionPointInfo = this._playerInfos.Find((Predicate <ActionPointInfo>)(x => x.eventTypeMask == pair.Key));
string actionName = actionPointInfo.actionName;
Sprite sprite;
Singleton <Resources> .Instance.itemIconTables.ActionIconTable.TryGetValue(actionPointInfo.iconID, out sprite);
this._tableID = actionPointInfo.searchAreaID;
Transform transform = ((Component)this).get_transform().FindLoop(actionPointInfo.labelNullName)?.get_transform() ?? ((Component)this).get_transform();
toRelease1.Add(new CommandLabel.CommandInfo()
{
Text = actionName,
Icon = sprite,
IsHold = true,
TargetSpriteInfo = icon.ActionSpriteInfo,
Transform = transform,
Condition = (Func <PlayerActor, bool>)(x => warpPoint.CanAccess()),
ErrorText = (Func <PlayerActor, string>)(x => warpPoint.ErrorText()),
Event = (System.Action)(() => pair.Value.Item3(Singleton <Manager.Map> .Instance.Player, (ActionPoint)warpPoint))
});
}
}
this._labels = toRelease1.ToArray();
ListPool <CommandLabel.CommandInfo> .Release(toRelease1);
for (int key = 0; key < 2; ++key)
{
List <CommandLabel.CommandInfo> toRelease2 = ListPool <CommandLabel.CommandInfo> .Get();
foreach (KeyValuePair <EventType, Tuple <int, string, System.Action <PlayerActor, ActionPoint> > > keyValuePair in ActionPoint.DateLabelTable)
{
KeyValuePair <EventType, Tuple <int, string, System.Action <PlayerActor, ActionPoint> > > pair = keyValuePair;
WarpPoint warpPoint = this;
List <DateActionPointInfo> dateActionPointInfoList;
if (this._playerDateEventType[key].Contains(pair.Key) && AIProject.Definitions.Action.NameTable.TryGetValue(pair.Key, out ValueTuple <int, string> _) && this._playerDateInfos.TryGetValue(key, out dateActionPointInfoList))
{
DateActionPointInfo dateActionPointInfo = dateActionPointInfoList.Find((Predicate <DateActionPointInfo>)(x => x.eventTypeMask == pair.Key));
string actionName = dateActionPointInfo.actionName;
Sprite sprite;
Singleton <Resources> .Instance.itemIconTables.ActionIconTable.TryGetValue(dateActionPointInfo.iconID, out sprite);
Transform transform = ((Component)this).get_transform().FindLoop(dateActionPointInfo.labelNullName)?.get_transform() ?? ((Component)this).get_transform();
toRelease2.Add(new CommandLabel.CommandInfo()
{
Text = actionName,
Icon = sprite,
IsHold = true,
TargetSpriteInfo = icon.ActionSpriteInfo,
Transform = transform,
Condition = (Func <PlayerActor, bool>)(x => warpPoint.CanAccess()),
ErrorText = (Func <PlayerActor, string>)(x => warpPoint.ErrorText()),
Event = (System.Action)(() => pair.Value.Item3(Singleton <Manager.Map> .Instance.Player, (ActionPoint)warpPoint))
});
}
}
this._dateLabels[key] = toRelease2.ToArray();
ListPool <CommandLabel.CommandInfo> .Release(toRelease2);
}
List <CommandLabel.CommandInfo> toRelease3 = ListPool <CommandLabel.CommandInfo> .Get();
foreach (KeyValuePair <EventType, Tuple <int, string, System.Action <PlayerActor, ActionPoint> > > keyValuePair in ActionPoint.SickLabelTable)
{
KeyValuePair <EventType, Tuple <int, string, System.Action <PlayerActor, ActionPoint> > > pair = keyValuePair;
WarpPoint warpPoint = this;
if (this._playerEventType.Contains(pair.Key) && playerEventMask.Contains(pair.Key) && AIProject.Definitions.Action.NameTable.TryGetValue(pair.Key, out ValueTuple <int, string> _))
{
ActionPointInfo actionPointInfo = this._playerInfos.Find((Predicate <ActionPointInfo>)(x => x.eventTypeMask == pair.Key));
string actionName = actionPointInfo.actionName;
Sprite sprite;
Singleton <Resources> .Instance.itemIconTables.ActionIconTable.TryGetValue(actionPointInfo.iconID, out sprite);
Transform transform = ((Component)this).get_transform().FindLoop(actionPointInfo.labelNullName)?.get_transform() ?? ((Component)this).get_transform();
toRelease3.Add(new CommandLabel.CommandInfo()
{
Text = pair.Value.Item2,
Icon = sprite,
IsHold = true,
TargetSpriteInfo = icon.ActionSpriteInfo,
Transform = transform,
Condition = (Func <PlayerActor, bool>)(x => warpPoint.CanAccess()),
ErrorText = (Func <PlayerActor, string>)(x => warpPoint.ErrorText()),
Event = (System.Action)(() => pair.Value.Item3(Singleton <Manager.Map> .Instance.Player, (ActionPoint)warpPoint))
});
}
}
this._sickLabels = toRelease3.ToArray();
ListPool <CommandLabel.CommandInfo> .Release(toRelease3);
if (!this._playerInfos.IsNullOrEmpty <ActionPointInfo>() && this._playerInfos.Exists((Predicate <ActionPointInfo>)(x => x.eventTypeMask == EventType.Warp)) || !this._agentEventType.Contains(EventType.Warp))
{
return;
}
this._tableID = this._agentInfos.Find((Predicate <ActionPointInfo>)(x => x.eventTypeMask == EventType.Warp)).searchAreaID;
}
public virtual TaskStatus OnUpdate()
{
AgentActor agent = this.Agent;
if (Object.op_Equality((Object)agent.TargetInSightActionPoint, (Object)null))
{
return((TaskStatus)1);
}
if (this._rejected)
{
this._rejected = false;
if (agent.Mode == Desire.ActionType.TakeSleepPoint || agent.Mode == Desire.ActionType.TakeSleepHPoint || (agent.Mode == Desire.ActionType.TakeEatPoint || agent.Mode == Desire.ActionType.TakeBreakPoint))
{
return((TaskStatus)2);
}
agent.TargetInSightActionPoint = (ActionPoint)null;
return((TaskStatus)1);
}
if (!agent.TargetInSightActionPoint.IsNeutralCommand)
{
if (Object.op_Equality((Object)agent.TargetInSightActionPoint.Reserver, (Object)agent))
{
agent.TargetInSightActionPoint.Reserver = (Actor)null;
}
agent.TargetInSightActionPoint = (ActionPoint)null;
return((TaskStatus)1);
}
if (agent.Mode != Desire.ActionType.TakeSleepPoint && agent.Mode != Desire.ActionType.TakeSleepHPoint && (agent.Mode != Desire.ActionType.TakeEatPoint && agent.Mode != Desire.ActionType.TakeBreakPoint))
{
List <ActionPoint> connectedActionPoints = agent.TargetInSightActionPoint.ConnectedActionPoints;
if (!connectedActionPoints.IsNullOrEmpty <ActionPoint>())
{
foreach (ActionPoint actionPoint in connectedActionPoints)
{
if (!Object.op_Equality((Object)actionPoint, (Object)null) && !actionPoint.IsNeutralCommand)
{
if (Object.op_Equality((Object)agent.TargetInSightActionPoint.Reserver, (Object)agent))
{
agent.TargetInSightActionPoint.Reserver = (Actor)null;
}
agent.TargetInSightActionPoint = (ActionPoint)null;
return((TaskStatus)1);
}
}
}
}
if (Object.op_Inequality((Object)agent.TargetInSightActionPoint.Reserver, (Object)agent))
{
agent.TargetInSightActionPoint = (ActionPoint)null;
return((TaskStatus)1);
}
if (agent.TargetInSightActionPoint is WarpPoint)
{
WarpPoint sightActionPoint = agent.TargetInSightActionPoint as WarpPoint;
if (Object.op_Inequality((Object)sightActionPoint, (Object)null))
{
Dictionary <int, List <WarpPoint> > dictionary;
List <WarpPoint> source;
if (!Singleton <Manager.Map> .Instance.WarpPointDic.TryGetValue(sightActionPoint.OwnerArea.ChunkID, out dictionary) || !dictionary.TryGetValue(sightActionPoint.TableID, out source) || (source.IsNullOrEmpty <WarpPoint>() || source.Count < 2))
{
agent.TargetInSightActionPoint = (ActionPoint)null;
return((TaskStatus)1);
}
}
else
{
agent.TargetInSightActionPoint = (ActionPoint)null;
return((TaskStatus)1);
}
}
if (!agent.DestPosition.HasValue)
{
return((TaskStatus)1);
}
if (agent.DestPosition.HasValue)
{
this.SetDestination(agent.DestPosition.Value);
}
if ((double)Vector3.Distance(agent.DestPosition.Value, agent.Position) <= (!this._enterClose ? (double)Singleton <Resources> .Instance.LocomotionProfile.ApproachDistanceActionPoint : (double)Singleton <Resources> .Instance.LocomotionProfile.ApproachDistanceActionPointCloser))
{
return((TaskStatus)2);
}
Vector3 desiredVelocity = agent.NavMeshAgent.get_desiredVelocity();
if (Mathf.Approximately(((Vector3) ref desiredVelocity).get_magnitude(), 0.0f) && (double)Time.get_timeScale() > 0.0)
{
++this._stopCount;
if (this._stopCount >= 10 && agent.DestPosition.HasValue)
{
this._stopCount = 0;
agent.NavMeshAgent.ResetPath();
this.SetDestinationForce(agent.DestPosition.Value);
}
}
return((TaskStatus)3);
}
private static bool CheckNeutral(
AgentActor agent,
ActionPoint pt,
Dictionary <int, bool> availableArea,
int searchCount,
int chunkID,
EventType eventType,
bool isFollow,
bool isRain,
float sampleDistance)
{
if (Object.op_Equality((Object)pt, (Object)null) || Object.op_Equality((Object)pt.OwnerArea, (Object)null) || (!pt.IsNeutralCommand || pt.IsReserved(agent)))
{
return(false);
}
List <ActionPoint> connectedActionPoints = pt.ConnectedActionPoints;
if (!connectedActionPoints.IsNullOrEmpty <ActionPoint>())
{
foreach (ActionPoint actionPoint in connectedActionPoints)
{
if (!Object.op_Equality((Object)actionPoint, (Object)null) && (!actionPoint.IsNeutralCommand || actionPoint.IsReserved(agent)))
{
return(false);
}
}
}
if (isRain && pt.AreaType != MapArea.AreaType.Indoor)
{
return(false);
}
MapArea ownerArea = pt.OwnerArea;
if (ownerArea.ChunkID == chunkID)
{
return(false);
}
bool flag1;
if (!availableArea.TryGetValue(ownerArea.AreaID, out flag1))
{
availableArea[ownerArea.AreaID] = flag1 = Singleton <Manager.Map> .Instance.CheckAvailableMapArea(ownerArea.AreaID);
}
if (!flag1 || !(!isFollow ? pt.AgentEventType : pt.AgentDateEventType).Contains(eventType))
{
return(false);
}
switch (eventType)
{
case EventType.Eat:
StuffItem carryingItem = agent.AgentData.CarryingItem;
AgentProfile agentProfile = Singleton <Resources> .Instance.AgentProfile;
ItemIDKeyPair[] canStandEatItems = Singleton <Resources> .Instance.AgentProfile.CanStandEatItems;
bool flag2 = false;
foreach (ItemIDKeyPair itemIdKeyPair in canStandEatItems)
{
if (carryingItem.CategoryID == itemIdKeyPair.categoryID && carryingItem.ID == itemIdKeyPair.itemID)
{
flag2 = true;
break;
}
}
if (flag2)
{
PoseKeyPair eatDeskId1 = agentProfile.PoseIDTable.EatDeskID;
PoseKeyPair eatDeskId2 = agentProfile.PoseIDTable.EatDeskID;
ActionPointInfo outInfo;
if (!pt.FindAgentActionPointInfo(EventType.Eat, eatDeskId1.poseID, out outInfo) && !pt.FindAgentActionPointInfo(EventType.Eat, eatDeskId2.poseID, out outInfo))
{
return(false);
}
break;
}
PoseKeyPair eatDishId = agentProfile.PoseIDTable.EatDishID;
if (!pt.FindAgentActionPointInfo(EventType.Eat, eatDishId.poseID, out ActionPointInfo _))
{
return(false);
}
break;
case EventType.Search:
SearchActionPoint searchActionPoint = pt as SearchActionPoint;
if (Object.op_Inequality((Object)searchActionPoint, (Object)null))
{
int registerId = searchActionPoint.RegisterID;
Dictionary <int, AIProject.SaveData.Environment.SearchActionInfo> searchActionLockTable = agent.AgentData.SearchActionLockTable;
AIProject.SaveData.Environment.SearchActionInfo searchActionInfo1;
if (!searchActionLockTable.TryGetValue(registerId, out searchActionInfo1))
{
AIProject.SaveData.Environment.SearchActionInfo searchActionInfo2 = new AIProject.SaveData.Environment.SearchActionInfo();
searchActionLockTable[registerId] = searchActionInfo2;
searchActionInfo1 = searchActionInfo2;
}
if (searchActionInfo1.Count >= searchCount)
{
return(false);
}
int tableId = searchActionPoint.TableID;
StuffItem itemInfo = agent.AgentData.EquipedSearchItem(tableId);
if (agent.SearchAreaID == 0)
{
if (tableId != 0 && tableId != 1 && tableId != 2 || !searchActionPoint.CanSearch(EventType.Search, itemInfo))
{
return(false);
}
break;
}
if (agent.SearchAreaID != searchActionPoint.TableID || !searchActionPoint.CanSearch(EventType.Search, itemInfo))
{
return(false);
}
break;
}
break;
case EventType.Warp:
WarpPoint warpPoint = pt as WarpPoint;
Dictionary <int, List <WarpPoint> > dictionary;
List <WarpPoint> warpPointList;
if (!Object.op_Inequality((Object)warpPoint, (Object)null) || !Singleton <Manager.Map> .Instance.WarpPointDic.TryGetValue(ownerArea.ChunkID, out dictionary) || (!dictionary.TryGetValue(warpPoint.TableID, out warpPointList) || warpPointList.Count < 2))
{
return(false);
}
break;
}
if (SetDesiredActionOtherChunk._navMeshPath == null)
{
SetDesiredActionOtherChunk._navMeshPath = new NavMeshPath();
}
NavMeshHit navMeshHit;
return(agent.NavMeshAgent.CalculatePath(pt.LocatedPosition, SetDesiredActionOtherChunk._navMeshPath) && SetDesiredActionOtherChunk._navMeshPath.get_status() == null && NavMesh.SamplePosition(pt.LocatedPosition, ref navMeshHit, sampleDistance, agent.NavMeshAgent.get_areaMask()));
}
