public void InitPortalPointForExplore(ExploreStatus exploreStatus)
{
if (current != null && current.fieldPortalInfoList != null)
{
foreach (FieldMapPortalInfo fieldPortalInfo in current.fieldPortalInfoList)
{
if (fieldPortalInfo.IsValid())
{
FieldMapTable.PortalTableData portalData = Singleton <FieldMapTable> .I.GetPortalData(fieldPortalInfo.portalData.portalID);
FieldPortal fieldPortal = new FieldPortal();
fieldPortal.pId = (int)fieldPortalInfo.portalData.portalID;
fieldPortal.used = false;
fieldPortal.point = 0;
ExplorePortalPoint portalData2 = exploreStatus.GetPortalData(fieldPortal.pId);
if (portalData2 != null)
{
fieldPortal.point = portalData2.point;
fieldPortal.used = (ExplorePortalPoint.USEDFLAG_CLOSED != portalData2.used);
}
fieldPortalInfo.fieldPortal = fieldPortal;
}
}
_ResetPortalPointToIndex(0);
}
}
private static bool IsDifferentRegion(uint portalID)
{
if (!Singleton <FieldMapTable> .IsValid())
{
return(false);
}
FieldMapTable.PortalTableData portalData = Singleton <FieldMapTable> .I.GetPortalData(portalID);
if (portalData == null)
{
return(false);
}
FieldMapTable.FieldMapTableData fieldMapData = Singleton <FieldMapTable> .I.GetFieldMapData(portalData.srcMapID);
FieldMapTable.FieldMapTableData fieldMapData2 = Singleton <FieldMapTable> .I.GetFieldMapData(portalData.dstMapID);
if (fieldMapData == null || fieldMapData2 == null)
{
return(false);
}
if (fieldMapData.regionId == fieldMapData2.regionId)
{
return(false);
}
return(true);
}
public static bool IsOpenPortal(FieldMapTable.PortalTableData portal)
{
if (portal.srcMapID != 0 && !MonoBehaviourSingleton <WorldMapManager> .I.IsTraveledMap((int)portal.srcMapID))
{
return(false);
}
if (portal.dstMapID == 0 && portal.dstQuestID == 0)
{
return(true);
}
if (MonoBehaviourSingleton <WorldMapManager> .I.IsTraveledPortal(portal))
{
return(true);
}
if (!IsOpenPortalClearOrder(portal))
{
return(false);
}
if (portal.portalPoint != 0)
{
int portalPoint = MonoBehaviourSingleton <WorldMapManager> .I.GetPortalPoint(portal.portalID);
if (portalPoint < portal.portalPoint)
{
return(false);
}
}
return(true);
}
private void ToExplore()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Expected O, but got Unknown
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Expected O, but got Unknown
FieldMapTable.PortalTableData portalData = Singleton <FieldMapTable> .I.GetPortalData(MonoBehaviourSingleton <InGameManager> .I.beforePortalID);
if (portalData == null)
{
MonoBehaviourSingleton <GameSceneManager> .I.ExecuteSceneEvent("InGameProgress", this.get_gameObject(), "INGAME_MAIN", null, null, true);
}
else
{
FieldMapTable.FieldMapTableData fieldMapData = Singleton <FieldMapTable> .I.GetFieldMapData(portalData.dstMapID);
if (fieldMapData == null)
{
MonoBehaviourSingleton <GameSceneManager> .I.ExecuteSceneEvent("InGameProgress", this.get_gameObject(), "INGAME_MAIN", null, null, true);
}
else
{
ExploreMapOpenNewField.EventData eventData = new ExploreMapOpenNewField.EventData();
eventData.regionId = fieldMapData.regionId;
eventData.portalId = MonoBehaviourSingleton <InGameManager> .I.beforePortalID;
eventData.fromBoss = fromBossExplore;
eventData.toBoss = isEncounterBoss;
MonoBehaviourSingleton <GameSceneManager> .I.ExecuteSceneEvent("InGameProgress", this.get_gameObject(), "NEW_EXPLORE", eventData, null, true);
}
}
}
public static bool IsOpenPortalClearOrder(FieldMapTable.PortalTableData portal)
{
if (portal.appearQuestId != 0 && !MonoBehaviourSingleton <QuestManager> .I.IsClearQuest(portal.appearQuestId))
{
return(false);
}
if (portal.appearDeliveryId != 0 && !MonoBehaviourSingleton <DeliveryManager> .I.IsClearDelivery(portal.appearDeliveryId))
{
return(false);
}
if (portal.appearRegionId != 0)
{
FieldMapTable.FieldMapTableData fieldMapData = Singleton <FieldMapTable> .I.GetFieldMapData(portal.dstMapID);
if (fieldMapData == null)
{
return(false);
}
if (!MonoBehaviourSingleton <WorldMapManager> .I.releasedRegionIds.Contains((int)fieldMapData.regionId))
{
return(false);
}
}
else if (portal.travelMapId != 0 && !MonoBehaviourSingleton <WorldMapManager> .I.IsTraveledMap((int)portal.travelMapId))
{
return(false);
}
return(true);
}
public static bool IsToHardPortal(uint portalId)
{
FieldMapTable.PortalTableData portalData = Singleton <FieldMapTable> .I.GetPortalData(portalId);
if (portalData == null)
{
return(false);
}
return(IsToHardPortal(portalData));
}
private bool IsPortalReverseAndGetPortalData(int portalId, out RegionMapPortal portalData)
{
portalData = regionMapRoot.FindEntrancePortal(portalId);
if (portalData != null)
{
return(false);
}
portalData = regionMapRoot.FindExitPortal(portalId);
return(true);
}
private IEnumerator CheckPortalOpen()
{
yield return((object)null);
while (true)
{
if (IsDeleteCleardAnnounce())
{
m_coroutinePortal = null;
yield break;
}
if (IsDispCleardAnnounce())
{
break;
}
yield return((object)null);
}
if (!MonoBehaviourSingleton <InGameProgress> .IsValid())
{
m_coroutinePortal = null;
}
else
{
List <PortalObject> portalObjList = MonoBehaviourSingleton <InGameProgress> .I.portalObjectList;
if (portalObjList == null)
{
m_coroutinePortal = null;
}
else
{
bool isNewPortalOpen = false;
for (int i = 0; i < portalObjList.Count; i++)
{
FieldMapTable.PortalTableData portalData = portalObjList[i].portalData;
if ((FieldManager.IsOpenPortalClearOrder(portalData) || FieldManager.IsOpenPortal(portalData)) && GameSaveData.instance.isNewReleasePortal(portalObjList[i].portalID))
{
PortalObject preObj = portalObjList[i];
portalObjList[i] = PortalObject.Create(preObj.portalInfo, preObj._transform.get_parent());
PortalUnlockEvent portalUnlockEvent = MonoBehaviourSingleton <InGameManager> .I.get_gameObject().AddComponent <PortalUnlockEvent>();
portalUnlockEvent.AddPortal(portalObjList[i]);
GameSaveData.instance.newReleasePortals.Remove(portalObjList[i].portalID);
Object.Destroy(preObj.get_gameObject());
isNewPortalOpen = true;
}
}
if (isNewPortalOpen)
{
MonoBehaviourSingleton <FieldManager> .I.ResetPortalPointToIndex();
}
m_coroutinePortal = null;
}
}
}
public ExplorePortalPoint(FieldMapTable.PortalTableData tableData)
{
fieldPortal = new FieldPortal();
fieldPortal.pId = (int)tableData.portalID;
used = USEDFLAG_CLOSED;
linkPortalId = (int)tableData.linkPortalId;
portalData = tableData;
if (tableData.portalPoint == 0)
{
used = USEDFLAG_PASSED;
}
}
public static bool IsShowPortal(FieldMapTable.PortalTableData portal)
{
if (portal.hideQuestId != 0 && MonoBehaviourSingleton <QuestManager> .I.IsClearQuest(portal.hideQuestId))
{
return(false);
}
if (portal.showDeliveryId != 0 && !MonoBehaviourSingleton <DeliveryManager> .I.IsClearDelivery(portal.showDeliveryId))
{
return(false);
}
return(true);
}
public bool IsTraveledPortal(FieldMapTable.PortalTableData portal)
{
if (QuestManager.IsValidInGameExplore())
{
return(MonoBehaviourSingleton <QuestManager> .I.PortalIsUsedInExplore((int)portal.portalID));
}
if (portal.srcMapID != 0 && !IsTraveledMap((int)portal.srcMapID))
{
return(false);
}
return(GetFieldPortal((int)portal.portalID)?.used ?? false);
}
public static bool IsToHardPortal(FieldMapTable.PortalTableData portal)
{
if (portal.dstMapID != 0)
{
FieldMapTable.FieldMapTableData fieldMapData = Singleton <FieldMapTable> .I.GetFieldMapData(portal.dstMapID);
if (fieldMapData != null)
{
return(fieldMapData.fieldMode == DIFFICULTY_MODE.HARD);
}
}
return(false);
}
private static bool IsSameField(uint portalID)
{
if (!Singleton <FieldMapTable> .IsValid())
{
return(false);
}
FieldMapTable.PortalTableData portalData = Singleton <FieldMapTable> .I.GetPortalData(portalID);
if (portalData == null)
{
return(false);
}
return(portalData.srcMapID == portalData.dstMapID);
}
public void SetCurrentFieldMapPortalID(uint portal_id)
{
FieldMapTable.PortalTableData portalData = Singleton <FieldMapTable> .I.GetPortalData(portal_id);
if (portalData == null)
{
Log.Error(LOG.INGAME, "FieldManager.SetCurrentPortalID() portal data is none. portal_id : {0}", portal_id);
}
else
{
SetCurrentFieldMapID(portalData.dstMapID, portalData.dstX, portalData.dstZ, portalData.dstDir);
current.fieldTransitionInfo.portalID = portal_id;
}
}
private void QuestToField()
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
FieldMapTable.PortalTableData portalTableData = Singleton <FieldMapTable> .I.GetPortalData(MonoBehaviourSingleton <FieldManager> .I.currentPortalID);
if (portalTableData == null)
{
RequestEvent("EXIT", null);
}
else
{
RegionMapLocation regionMapLocation = regionMapRoot.FindLocation((int)portalTableData.dstMapID);
if (null == regionMapLocation)
{
RequestEvent("EXIT", null);
}
else
{
Vector3 position = regionMapLocation.get_transform().get_position();
_camera.get_transform().set_position(position - _camera.get_transform().get_forward() * MonoBehaviourSingleton <GlobalSettingsManager> .I.worldMapParam.eventCameraDistance);
playerMarker.SetParent(regionMapLocation.get_transform());
playerMarker.set_localPosition(MonoBehaviourSingleton <GlobalSettingsManager> .I.worldMapParam.playerMarkerOffset);
playerMarker.set_localScale(new Vector3(0f, 0f, 0f));
this.StartCoroutine(DoQuestToField());
}
}
}
private static bool IsJumpPortal(uint portalID)
{
if (!Singleton <FieldMapTable> .IsValid())
{
return(false);
}
FieldMapTable.PortalTableData portalData = Singleton <FieldMapTable> .I.GetPortalData(portalID);
if (portalData == null)
{
return(false);
}
if (0 < portalData.srcMapID)
{
return(false);
}
if (portalID == 10000000)
{
return(false);
}
return(true);
}
private static bool IsSrcOrDstChildRegion(uint portalID)
{
if (!Singleton <FieldMapTable> .IsValid())
{
return(false);
}
FieldMapTable.PortalTableData portalData = Singleton <FieldMapTable> .I.GetPortalData(portalID);
if (portalData == null)
{
return(false);
}
FieldMapTable.FieldMapTableData fieldMapData = Singleton <FieldMapTable> .I.GetFieldMapData(portalData.srcMapID);
FieldMapTable.FieldMapTableData fieldMapData2 = Singleton <FieldMapTable> .I.GetFieldMapData(portalData.dstMapID);
if (fieldMapData == null || fieldMapData2 == null)
{
return(false);
}
if (fieldMapData.childRegionId == fieldMapData2.regionId)
{
return(true);
}
if (!Singleton <RegionTable> .IsValid())
{
return(false);
}
RegionTable.Data data = Singleton <RegionTable> .I.GetData(fieldMapData.regionId);
RegionTable.Data data2 = Singleton <RegionTable> .I.GetData(fieldMapData2.regionId);
if (data == null || data2 == null)
{
return(false);
}
return(data2.parentRegionId == fieldMapData.regionId || data.parentRegionId == fieldMapData2.regionId);
}
public void UpdatePortals(bool isMiniMap)
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < portals.Length; i++)
{
Transform val = portals[i];
string name = val.get_name();
FieldMapTable.PortalTableData portalData = GetPortalData(name);
if (portalData != null)
{
val.get_gameObject().SetActive(true);
UITexture[] componentsInChildren = val.GetComponentsInChildren <UITexture>();
if (componentsInChildren == null || componentsInChildren.Length == 0)
{
val.get_gameObject().SetActive(false);
}
else if (MonoBehaviourSingleton <WorldMapManager> .I.IsTraveledPortal(portalData.portalID))
{
componentsInChildren[0].color = passedColor;
if (portalData.IsWarpPortal())
{
componentsInChildren[0].color = warpColor;
}
}
else
{
componentsInChildren[0].color = unusedColor;
val.get_gameObject().SetActive(isMiniMap);
}
}
}
}
private IEnumerator DoInitialize()
{
eventData = (SectionEventData)GameSection.GetEventData();
if (MonoBehaviourSingleton <InGameManager> .IsValid())
{
portalData = Singleton <FieldMapTable> .I.GetPortalData(MonoBehaviourSingleton <InGameManager> .I.beforePortalID);
}
if (MonoBehaviourSingleton <OutGameSettingsManager> .IsValid() && portalData == null)
{
portalData = Singleton <FieldMapTable> .I.GetPortalData((uint)MonoBehaviourSingleton <OutGameSettingsManager> .I.homeScene.linkFieldPortalID);
}
if (eventData.IsQuestToField())
{
portalData = Singleton <FieldMapTable> .I.GetPortalData(MonoBehaviourSingleton <FieldManager> .I.currentPortalID);
}
if (portalData == null)
{
base.Initialize();
}
else
{
FieldMapTable.FieldMapTableData currentMapData = Singleton <FieldMapTable> .I.GetFieldMapData(portalData.srcMapID);
newMapData = Singleton <FieldMapTable> .I.GetFieldMapData(portalData.dstMapID);
regionId = newMapData.regionId;
if (NeedDirectionOpenRegion())
{
toRegionRelease = true;
base.Initialize();
}
else
{
if (currentMapData != null && newMapData != null && newMapData.regionId != currentMapData.regionId)
{
regionId = currentMapData.regionId;
}
if (newMapData == null || !IsValidRegion(newMapData))
{
newMapData = null;
base.Initialize();
}
else
{
LoadingQueue loadQueue = new LoadingQueue(this);
LoadObject loadedEventUIRoot = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "NewFieldOpenEventUIRoot", false);
LoadObject loadedLocationSpot = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "LocationSpot", false);
LoadObject loadedEventCamera = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "NewFieldEventCamera", false);
LoadObject loadedFilterCamera = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "ZoomBlurFilterCamera", false);
LoadObject loadedPlayerMarker = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "PlayerMarker", false);
LoadObject loadedRegion = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "RegionMap_" + regionId.ToString("D3"), false);
LoadObject loadedEffect = loadQueue.LoadEffect(RESOURCE_CATEGORY.EFFECT_UI, "ef_ui_map_fire_01", false);
LoadObject loadedWindEffect = loadQueue.LoadEffect(RESOURCE_CATEGORY.EFFECT_ACTION, "ef_btl_bg_questmap_01", false);
LoadObject loadedDungeonEff = null;
if (eventData.IsFindNewDungeon() && newMapData != null)
{
uint mapID = newMapData.mapID;
loadedDungeonEff = loadQueue.LoadEffect(RESOURCE_CATEGORY.EFFECT_DUNGEON, "DEF_" + mapID.ToString("D8"), false);
}
LoadObject loadedEncounterBossCutIn = null;
if (eventData.IsEncounterBossEvent())
{
loadedEncounterBossCutIn = loadQueue.Load(RESOURCE_CATEGORY.UI, "InGameFieldQuestWarning", false);
}
CacheAudio(loadQueue);
if (loadQueue.IsLoading())
{
yield return((object)loadQueue.Wait());
}
if (loadedEncounterBossCutIn != null)
{
fieldQuestWarningRoot = ResourceUtility.Realizes(loadedEncounterBossCutIn.loadedObject, -1).get_gameObject();
UIPanel panel = fieldQuestWarningRoot.GetComponentInChildren <UIPanel>();
if (panel != null)
{
panel.depth = 8000;
}
if (MonoBehaviourSingleton <UIInGameFieldQuestWarning> .IsValid())
{
MonoBehaviourSingleton <UIInGameFieldQuestWarning> .I.Load(loadQueue);
}
}
if (loadQueue.IsLoading())
{
yield return((object)loadQueue.Wait());
}
topEffectPrefab = loadedEffect.loadedObject;
Transform t = ResourceUtility.Realizes(loadedEventUIRoot.loadedObject, base._transform, -1);
regionMapRoot = ResourceUtility.Realizes(loadedRegion.loadedObject, MonoBehaviourSingleton <AppMain> .I._transform, -1).get_gameObject().GetComponent <RegionMapRoot>();
if (regionMapRoot != null)
{
bool wait = true;
regionMapRoot.InitPortalStatus(delegate
{
((_003CDoInitialize_003Ec__Iterator164) /*Error near IL_0526: stateMachine*/)._003Cwait_003E__15 = false;
});
while (wait)
{
yield return((object)null);
}
}
blurFilter = (ResourceUtility.Instantiate <Object>(loadedFilterCamera.loadedObject) as GameObject).GetComponent <ZoomBlurFilter>();
blurFilter.get_transform().set_parent(base._transform);
_camera = ResourceUtility.Realizes(loadedEventCamera.loadedObject, MonoBehaviourSingleton <AppMain> .I._transform, -1).GetComponent <Camera>();
uiFrontMapSprite = t.FindChild("FrontMap").get_gameObject().GetComponent <UITexture>();
if (uiFrontMapSprite != null)
{
uiFrontMapSprite.alpha = 0f;
}
uiMapSprite = t.FindChild("Map").get_gameObject().GetComponent <UITexture>();
InitMapSprite(MonoBehaviourSingleton <ScreenOrientationManager> .I.isPortrait);
if (eventData.IsEncounterBossEvent())
{
t.FindChild("TaptoSkip").get_gameObject().SetActive(false);
}
bgEventListener = UIEventListener.Get(t.Find("BG").get_gameObject());
tutorialTrigger = t.FindChild("TUTORIAL_TRIGGER");
if (tutorialTrigger != null)
{
if (!TutorialStep.HasAllTutorialCompleted())
{
tutorialTrigger.get_gameObject().SetActive(true);
UITweenCtrl.Play(tutorialTrigger, true, null, false, 0);
}
else
{
tutorialTrigger.get_gameObject().SetActive(false);
}
}
spots = new SpotManager(null, loadedLocationSpot.loadedObject as GameObject, _camera);
spots.spotRootTransform = t;
playerMarker = ResourceUtility.Realizes(loadedPlayerMarker.loadedObject, -1);
PlayerMarker playerMarkerCom = playerMarker.GetComponent <PlayerMarker>();
if (null != playerMarkerCom)
{
playerMarkerCom.SetCamera(_camera.get_transform());
}
windEffect = ResourceUtility.Realizes(loadedWindEffect.loadedObject, _camera.get_transform(), -1).get_gameObject().GetComponent <rymFX>();
windEffect.Cameras = (Camera[])new Camera[1]
{
_camera
};
windEffect.get_gameObject().set_layer(LayerMask.NameToLayer("WorldMap"));
if (loadedDungeonEff != null)
{
dungeonOpenEffect = ResourceUtility.Realizes(loadedDungeonEff.loadedObject, base._transform, -1);
dungeonOpenEffect.get_gameObject().SetActive(false);
}
CreateVisitedLocationSpot();
if (MonoBehaviourSingleton <GameSceneManager> .I.GetCurrentSceneName() == "InGameScene")
{
MonoBehaviourSingleton <ScreenOrientationManager> .I.OnScreenRotate += InitMapSprite;
}
base.Initialize();
}
}
}
}
public void Clear()
{
portalData = null;
fieldPortal = null;
}
public FieldMapPortalInfo(FieldMapTable.PortalTableData _portal, FieldPortal _fieldPortal)
{
portalData = _portal;
fieldPortal = _fieldPortal;
}
public void SetPortalData(FieldMapTable.PortalTableData _portal, FieldPortal _fieldPortal)
{
portalData = _portal;
fieldPortal = _fieldPortal;
}
private IEnumerator DoInitialize()
{
EventData eventData = GameSection.GetEventData() as EventData;
if (eventData == null)
{
base.Initialize();
}
else
{
uint regionId = eventData.regionId;
fromBoss_ = eventData.fromBoss;
toBoss_ = eventData.toBoss;
portalData_ = Singleton <FieldMapTable> .I.GetPortalData(eventData.portalId);
if (portalData_ == null)
{
base.Initialize();
}
else
{
LoadingQueue loadQueue = new LoadingQueue(this);
LoadObject loadedExploreMapFrame = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "ExploreMapFrame", false);
LoadObject loadedExploreMap = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "ExploreMap_" + regionId.ToString("D3"), false);
LoadObject loadedPlayerMarker = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "ExplorePlayerMarker", false);
LoadObject loadedCircle = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "ExploreCircle", false);
LoadObject loadedBattleIcon = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "ExploreBattleMarker", false);
LoadObject loadedFootprint = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "ExploreTraceMarker", false);
LoadObject loadedEncounterBossCutIn = null;
if (toBoss_)
{
loadedEncounterBossCutIn = loadQueue.Load(RESOURCE_CATEGORY.UI, "InGameFieldQuestWarning", false);
}
if (loadQueue.IsLoading())
{
yield return((object)loadQueue.Wait());
}
if (null == loadedExploreMap.loadedObject)
{
base.Initialize();
}
else
{
if (loadedEncounterBossCutIn != null)
{
fieldQuestWarningRoot = ResourceUtility.Realizes(loadedEncounterBossCutIn.loadedObject, -1).get_gameObject();
UIPanel panel2 = fieldQuestWarningRoot.GetComponentInChildren <UIPanel>();
if (panel2 != null)
{
panel2.depth = 12000;
}
if (MonoBehaviourSingleton <UIInGameFieldQuestWarning> .IsValid())
{
MonoBehaviourSingleton <UIInGameFieldQuestWarning> .I.Load(loadQueue);
}
}
mapFrame_ = ResourceUtility.Realizes(loadedExploreMapFrame.loadedObject, base._transform, -1);
if (toBoss_)
{
UIPanel panel = mapFrame_.GetComponent <UIPanel>();
panel.renderQueue = UIPanel.RenderQueue.StartAt;
panel.startingRenderQueue = 2900;
}
map_ = ResourceUtility.Realizes(loadedExploreMap.loadedObject, mapFrame_, -1);
Transform map = map_.FindChild("Map");
map.get_gameObject().SetActive(true);
mapRoot_ = map_.GetComponent <ExploreMapRoot>();
ExploreMapLocation[] locations = mapRoot_.locations;
for (int k = 0; k < locations.Length; k++)
{
Transform active = locations[k].get_transform().FindChild("ExploreSpotActive");
Transform inactive = locations[k].get_transform().FindChild("ExploreSpotInactive");
Transform sonar = locations[k].get_transform().FindChild("ExploreSpotSonar");
active.get_gameObject().SetActive(true);
inactive.get_gameObject().SetActive(false);
List <FieldMapTable.FieldGimmickPointTableData> gimmicks = Singleton <FieldMapTable> .I.GetFieldGimmickPointListByMapID((uint)locations[k].mapId);
if (gimmicks != null && sonar != null)
{
for (int i = 0; i < gimmicks.Count; i++)
{
if (gimmicks[i].gimmickType == FieldMapTable.FieldGimmickPointTableData.GIMMICK_TYPE.SONAR)
{
active.get_gameObject().SetActive(false);
inactive.get_gameObject().SetActive(false);
sonar.get_gameObject().SetActive(true);
}
}
}
}
mapRoot_.UpdatePortals(false);
from_ = mapRoot_.FindLocation((int)portalData_.srcMapID);
to_ = mapRoot_.FindLocation((int)portalData_.dstMapID);
if (null == to_)
{
base.Initialize();
}
else
{
ExploreMapFrame frame = mapFrame_.GetComponent <ExploreMapFrame>();
frame.SetMap(mapRoot_);
RegionTable.Data regionData = Singleton <RegionTable> .I.GetData(regionId);
if (regionData != null)
{
frame.SetCaption(regionData.regionName);
}
for (int j = 0; j < playerMarkers_.Length; j++)
{
playerMarkers_[j] = ResourceUtility.Realizes(loadedPlayerMarker.loadedObject, mapFrame_, -1);
ExplorePlayerMarker marker = playerMarkers_[j].GetComponent <ExplorePlayerMarker>();
if (null != marker)
{
marker.SetIndex(j);
}
marker.get_gameObject().SetActive(false);
}
selfMarker_ = playerMarkers_[0];
Transform bg = mapFrame_.FindChild("BG");
bg.get_gameObject().SetActive(true);
bgEventListener = UIEventListener.Get(bg.get_gameObject());
mapFrame_.FindChild("TaptoSkip").get_gameObject().SetActive(!toBoss_);
mapFrame_.FindChild("CaptionRoot/Close").get_gameObject().SetActive(false);
mapRoot_.SetMarkers(playerMarkers_, false);
ExploreStatus.TraceInfo[] traceHistory = MonoBehaviourSingleton <QuestManager> .I.GetBossTraceHistory();
if (traceHistory != null && traceHistory.Length > 0)
{
Transform lastFootprint = ResourceUtility.Realizes(loadedFootprint.loadedObject, map_, -1);
ExploreStatus.TraceInfo lastInfo = traceHistory[traceHistory.Length - 1];
Vector3 lastPos = mapRoot_.GetPositionOnMap(lastInfo.mapId);
lastFootprint.set_localPosition(new Vector3(lastPos.x + MarkerOffsetX, lastPos.y + MarkerOffsetY, lastPos.z));
lastFootprint.get_gameObject().SetActive(true);
if (traceHistory.Length > 1)
{
Transform lastSecondFootprint = ResourceUtility.Realizes(loadedFootprint.loadedObject, map_, -1);
ExploreStatus.TraceInfo lastSecondInfo = traceHistory[traceHistory.Length - 2];
Vector3 lastSecondPos = mapRoot_.GetPositionOnMap(lastSecondInfo.mapId);
lastSecondFootprint.set_localPosition(new Vector3(lastSecondPos.x + MarkerOffsetX, lastSecondPos.y + MarkerOffsetY, lastSecondPos.z));
lastSecondFootprint.get_gameObject().SetActive(true);
}
}
redCircle = ResourceUtility.Realizes(loadedCircle.loadedObject, map_, -1);
redCircle.set_localScale(new Vector3(0.6f, 0.6f, 0.6f));
battleIcon = ResourceUtility.Realizes(loadedBattleIcon.loadedObject, map_, -1);
if (mapRoot_.showBattleMarker)
{
int bossMapId = MonoBehaviourSingleton <QuestManager> .I.GetExploreBossAppearMapId();
Vector3 pos = mapRoot_.GetPositionOnMap(bossMapId);
redCircle.set_localPosition(pos);
battleIcon.set_localPosition(new Vector3(pos.x + MarkerOffsetX, pos.y + MarkerOffsetY, pos.z));
TweenAlpha tweenAlpha = redCircle.GetComponent <TweenAlpha>();
if (null != tweenAlpha)
{
tweenAlpha.from = tweenAlpha.to;
}
redCircle.get_gameObject().SetActive(true);
battleIcon.get_gameObject().SetActive(true);
}
else
{
redCircle.get_gameObject().SetActive(false);
battleIcon.get_gameObject().SetActive(false);
}
base.Initialize();
}
}
}
}
}
private IEnumerator DoInitialize()
{
eventData = (SectionEventData)GameSection.GetEventData();
FieldMapTable.PortalTableData portal = Singleton <FieldMapTable> .I.GetPortalData(MonoBehaviourSingleton <FieldManager> .I.currentPortalID);
FieldMapTable.FieldMapTableData mapA = Singleton <FieldMapTable> .I.GetFieldMapData(portal.srcMapID);
FieldMapTable.FieldMapTableData mapB = Singleton <FieldMapTable> .I.GetFieldMapData(portal.dstMapID);
fromRegionID = mapA.regionId;
toRegionID = mapB.regionId;
LoadingQueue loadQueue = new LoadingQueue(this);
LoadObject loadedWorldMap = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "WorldMap", false);
LoadObject loadedRegionSpotRoot = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "RegionSpotRoot", false);
LoadObject loadedRegionSpot = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "RegionSpot", false);
LoadObject loadedPlayerMarker = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "PlayerMarker", false);
LoadObject loadedMapGlowEffectA = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "MapGlowEffectA", false);
LoadObject loadedMapGlowEffectB = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "MapGlowEffectB", false);
LoadObject loadedTelop = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "TelopOpenRegion", false);
loadQueue.CacheSE(SE_ID_LOGO, null);
loadQueue.CacheSE(SE_ID_SMOKE, null);
uint[] openedRegionids = MonoBehaviourSingleton <WorldMapManager> .I.GetOpenRegionIdListInWorldMap();
if (openedRegionids.Length == 0)
{
openedRegionids = new uint[1];
}
LoadObject[] regionAreaLOs = new LoadObject[openedRegionids.Length];
string newRegionIcon = ResourceName.GetRegionIcon(0);
string passedRegionIcon = ResourceName.GetRegionIcon(1);
int lastIndex = openedRegionids.Length - 1;
openedRegionInfo = new OpendRegionInfo[openedRegionids.Length];
for (int j = 0; j < openedRegionids.Length; j++)
{
RegionTable.Data data = Singleton <RegionTable> .I.GetData(openedRegionids[j]);
if (!data.hasParentRegion())
{
string iconName = passedRegionIcon;
if (lastIndex == j)
{
iconName = newRegionIcon;
}
LoadObject loadedObj = loadQueue.Load(RESOURCE_CATEGORY.REGION_ICON, iconName, false);
openedRegionInfo[j] = new OpendRegionInfo(data, loadedObj);
if (j != 0)
{
regionAreaLOs[j] = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "WorldMapPart" + openedRegionids[j].ToString("D3"), false);
}
}
}
LoadObject loadedMaterial = null;
if (!eventData.IsOnlyCameraMoveEvent())
{
loadedMaterial = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "WorldMapPartGlow" + toRegionID.ToString("D3"), false);
}
if (loadQueue.IsLoading())
{
yield return((object)loadQueue.Wait());
}
worldMapUIRoot = ResourceUtility.Realizes(loadedWorldMap.loadedObject, MonoBehaviourSingleton <AppMain> .I._transform, -1).get_gameObject();
worldMapCamera = worldMapUIRoot.get_transform().Find("Camera").GetComponent <WorldMapCameraController>();
worldMapCamera.isInteractive = false;
worldMapObject = worldMapUIRoot.get_transform().FindChild("Map");
spots = new SpotManager(loadedRegionSpotRoot.loadedObject as GameObject, loadedRegionSpot.loadedObject as GameObject, worldMapCamera._camera);
spots.CreateSpotRoot();
GameObject bg = spots.spotRootTransform.Find("BG").get_gameObject();
bg.get_gameObject().SetActive(true);
bgEventListener = UIEventListener.Get(bg);
spots.spotRootTransform.Find("TaptoSkip").get_gameObject().SetActive(true);
mapGlowEffectA = ResourceUtility.Realizes(loadedMapGlowEffectA.loadedObject, worldMapObject, -1);
mapGlowEffectA.get_gameObject().SetActive(false);
mapGlowEffectParticleA = mapGlowEffectA.GetComponent <ParticleSystem>();
mapGlowEffectB = ResourceUtility.Realizes(loadedMapGlowEffectB.loadedObject, worldMapObject, -1);
mapGlowEffectB.get_gameObject().SetActive(false);
mapGlowEffectParticleB = mapGlowEffectB.GetComponent <ParticleSystem>();
playerMarker = ResourceUtility.Realizes(loadedPlayerMarker.loadedObject, base._transform, -1);
playerMarker.get_gameObject().SetActive(false);
if (loadedMaterial != null)
{
glowMaterial = (loadedMaterial.loadedObject as Material);
}
regionAreas = (Transform[])new Transform[regionAreaLOs.Length];
for (int i = 0; i < regionAreaLOs.Length; i++)
{
LoadObject areaLO = regionAreaLOs[i];
if (areaLO != null && null != areaLO.loadedObject)
{
Transform regionArea = ResourceUtility.Realizes(areaLO.loadedObject, worldMapObject, -1);
if (i == toRegionID)
{
if (eventData.IsOnlyCameraMoveEvent())
{
regionArea.get_gameObject().SetActive(true);
}
else
{
regionArea.get_gameObject().SetActive(false);
}
mapGlowEffectA.SetParent(regionArea);
mapGlowEffectA.set_localPosition(new Vector3(0f, 0f, 0f));
mapGlowEffectB.SetParent(regionArea);
mapGlowEffectB.set_localPosition(new Vector3(0f, 0f, 0f));
ShapeModule module = mapGlowEffectParticleB.get_shape();
MeshFilter meshFilter = regionArea.GetComponent <MeshFilter>();
module.set_mesh(meshFilter.get_sharedMesh());
glowRegionTop = ResourceUtility.Realizes(areaLO.loadedObject, worldMapObject, -1);
glowRegionTop.get_gameObject().SetActive(false);
glowRegionTop.set_localPosition(glowRegionTop.get_localPosition() + new Vector3(0f, 0f, 0.001f));
glowRegionTop.set_localScale(new Vector3(1.1f, 1.1f, 1.1f));
glowRegionTop.GetComponent <Renderer>().set_material(glowMaterial);
}
else
{
regionArea.get_gameObject().SetActive(true);
}
regionAreas[i] = regionArea;
}
}
telop = ResourceUtility.Realizes(loadedTelop.loadedObject, spots.spotRootTransform, -1);
Transform closeBtn = Utility.Find(spots.spotRootTransform, "CLOSE_BTN");
if (null != closeBtn)
{
closeBtn.get_gameObject().SetActive(false);
}
if (MonoBehaviourSingleton <GameSceneManager> .I.GetCurrentSceneName() == "InGameScene")
{
MonoBehaviourSingleton <ScreenOrientationManager> .I.OnScreenRotate += InitMapSprite;
}
base.Initialize();
}
public void UpdateLastPortal(FieldMapTable.PortalTableData portal)
{
lastUsePortal = portal;
UpdatePortalUsedFlag((int)portal.portalID);
}
