824309ec44
Copied the 89 uncopied AI*SimulationUtility/extension files defining the AIVirtualCard/AIVirtualField extension methods; the compile loop then auto-closed the revealed type deps (~3049 files total, drift-clean). 10.0k -> 62 errors.
1407 lines
42 KiB
C#
1407 lines
42 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Cute;
|
|
using UnityEngine;
|
|
using Wizard;
|
|
using Wizard.Battle.Recovery;
|
|
using Wizard.Scripts.Network.Data.TaskData.BuildDeckPurchase;
|
|
using Wizard.Story;
|
|
using Wizard.Story.ChapterSelection;
|
|
using Wizard.Story.ChapterSelection.SelectionProcessing.Main;
|
|
|
|
public class AreaSelectUI : UIBase
|
|
{
|
|
private enum CHAPTERUNLOCK_STATE
|
|
{
|
|
STATE_NULL,
|
|
STATE_EFFECT_CLEARLABEL,
|
|
STATE_FOCUS_NEWCHAPTER,
|
|
STATE_DISP_MAPICON
|
|
}
|
|
|
|
private enum LoadStatusTutorialEffect
|
|
{
|
|
NotLoad,
|
|
Loading,
|
|
Loaded
|
|
}
|
|
|
|
private const float CLEAR_EFFECT_WAIT_SEC = 1.1f;
|
|
|
|
private const float CLEAR_LABEL_DELAY_SEC = 0.4f;
|
|
|
|
private const float NEWCHAPTER_FOCUS_SEC = 1f;
|
|
|
|
private const float NEWCHAPTER_FOCUS_MAPICON_ENABLE_THRESHOLD = 0.55f;
|
|
|
|
private const float MAPICON_EFFECTWAIT_SEC = 0.05f;
|
|
|
|
private CHAPTERUNLOCK_STATE StateChapterUnlock;
|
|
|
|
private float NewAreaTimer;
|
|
|
|
private ChapterSelectButton _clearEffectPlayingChapter;
|
|
|
|
private bool IsClearLabelDisplayed;
|
|
|
|
private bool IsNewMapIconOpened;
|
|
|
|
private bool IsNewMapIconFocused;
|
|
|
|
private int nowAreaAllNum;
|
|
|
|
private bool IsPlayingUnlockChapter;
|
|
|
|
private GameObject _clearEffect;
|
|
|
|
private GameObject _alreadyReadEffect;
|
|
|
|
private List<string> _loadEffectResources = new List<string>();
|
|
|
|
public static readonly string CUESHEETNAME_MAP = "se_st_map";
|
|
|
|
public const int CHAPTERLIST_CAPACITY_DEFAULT = 8;
|
|
|
|
private const int SORTINGORDER_EFFECT_OVER = 1;
|
|
|
|
private const float PLAYERICON_Y = -320f;
|
|
|
|
private const float TITLEPANEL_X_IN = 0f;
|
|
|
|
private const float TITLEPANEL_X_OUT = 949f;
|
|
|
|
private const float CHAPTERLIST_X_IN = -200f;
|
|
|
|
private const float CHAPTERLIST_X_OUT = 400f;
|
|
|
|
private const int CHAPTERLISTICON_MAX = 5;
|
|
|
|
public const float CHAPTERLISTICON_OFFSET_Y = 80f;
|
|
|
|
public const int CHAPTERLISTICON_MARGIN = 50;
|
|
|
|
public const float CHAPTERLIST_SCROLL_RADIUS = 200f;
|
|
|
|
public const float CHAPTERLIST_SWITCH_SEC = 0.5f;
|
|
|
|
private static readonly Vector2 CHAPTERLIST_PANEL_CLIPOFFSET = new Vector2(0f, -420f);
|
|
|
|
private static readonly Vector2 CHAPTERLIST_PANEL_CLIPPOS = new Vector2(0f, 0f);
|
|
|
|
private static readonly Vector2 CHAPTERLIST_PANEL_CLIPSIZE = new Vector2(1200f, 80f);
|
|
|
|
private static readonly string ANOTHER_ENDING_APPEARANCE_EFFECT_NAME = "scn_map_world_another_bright_1";
|
|
|
|
private string _beforeNextChapterId;
|
|
|
|
private int? _beforeReleasedChapterNum;
|
|
|
|
private int? _beforeReplayChapterIndex;
|
|
|
|
[SerializeField]
|
|
private GameObject PlayerIcon;
|
|
|
|
[SerializeField]
|
|
private GameObject _chapterRewardPanelRoot;
|
|
|
|
private AreaSelInfo _chapterRewardPanel;
|
|
|
|
[SerializeField]
|
|
private GameObject _titlePanelRoot;
|
|
|
|
private TitlePanelBase _titlePanel;
|
|
|
|
[SerializeField]
|
|
private GameObject RightPartsRoot;
|
|
|
|
[SerializeField]
|
|
private ChapterSelectButton _chapterSelectButtonOriginal;
|
|
|
|
[SerializeField]
|
|
private GameObject ChapterListRoot;
|
|
|
|
[SerializeField]
|
|
private UIScrollView ChapterListScrollView;
|
|
|
|
[SerializeField]
|
|
private SpringPanel ChapterListSpringPanel;
|
|
|
|
private List<ChapterSelectButton> _chapterSelectButtonList;
|
|
|
|
private float ChapterListScrollYPrev;
|
|
|
|
private GameObject ChapterListTapEffectLocator;
|
|
|
|
private Effect ChapterListTapEffect;
|
|
|
|
[SerializeField]
|
|
private ChapterSelectSphere _chapterSelectSphere;
|
|
|
|
private bool IsChapterSelectEnable = true;
|
|
|
|
[SerializeField]
|
|
private GameObject _chapterListScrollCollision;
|
|
|
|
[SerializeField]
|
|
private AreaSelectBG _BG = new AreaSelectBG();
|
|
|
|
[SerializeField]
|
|
private AreaSelectMapIcon _mapIcon = new AreaSelectMapIcon();
|
|
|
|
private AreaSelectChapterEffect _chapterEffect = new AreaSelectChapterEffect();
|
|
|
|
[SerializeField]
|
|
private GameObject _chapterEffectLocator;
|
|
|
|
[SerializeField]
|
|
private CommonPrefabContainer _commonPrefabContainer;
|
|
|
|
[SerializeField]
|
|
private float _chapterEffectSimulationSpeedAfterStop = 1f;
|
|
|
|
private ScenarioSummary _scenarioSummary;
|
|
|
|
private List<string> _resourcePathList = new List<string>();
|
|
|
|
private int _selectChapterIndex;
|
|
|
|
private StoryChapterData _selectChapterData;
|
|
|
|
private LoadStatusTutorialEffect _loadStatusTutorialEffect;
|
|
|
|
private bool IsLoadEnd = true;
|
|
|
|
private bool IsFadeInEnd;
|
|
|
|
private bool IsSetupEnd;
|
|
|
|
private TopBar _topBar;
|
|
|
|
private bool IsUseChapterListScroll;
|
|
|
|
private bool IsUseChapterListTapEffect;
|
|
|
|
private bool IsUseChapterListSwitch;
|
|
|
|
private bool _usedScrollWheel;
|
|
|
|
private bool _isBackTransitionStarted;
|
|
|
|
private IProcessing _firstSelectionProcessing;
|
|
|
|
private StoryChapterData _anotherEndingAppearanceAnimationChapterData;
|
|
|
|
private GameObject _anotherEndingAppearanceEffect;
|
|
|
|
private bool _unlockAfterZoom;
|
|
|
|
public static readonly Vector3 BG_SCALE_ZOOMOUT = new Vector3(0.28f, 0.28f, 0.28f);
|
|
|
|
public static readonly Vector3 BG_POS_ZOOMOUT = new Vector3(-70f, -430f, 0f);
|
|
|
|
public static readonly Vector3 BG_SCALE_ZOOMIN = new Vector3(0.6f, 0.6f, 0.6f);
|
|
|
|
public const float BG_POS_ZOOMIN_OFFSET_Y = -400f;
|
|
|
|
private const float CHAPTERLISTROOT_X_OUT = 800f;
|
|
|
|
private const float CHAPTERLISTROOT_X_IN = -25f;
|
|
|
|
private const float MAPMOVE_TIMER_IDLE = 1f;
|
|
|
|
private const float MAPMOVE_TIMER_ZOOMIN = 1f;
|
|
|
|
private const float MAPMOVE_TIMER_TOEND = 1f;
|
|
|
|
private const float ANOTHER_ENDING_APPEARANCE_ANIMATION_TIME = 1.5f;
|
|
|
|
[SerializeField]
|
|
private iTween.EaseType BG_ZOOMIN_EASETYPE = iTween.EaseType.easeInOutCubic;
|
|
|
|
private bool _isPlayingBGStartMove;
|
|
|
|
private SelectedStoryInfo SelectedStoryInfo => Data.SelectedStoryInfo;
|
|
|
|
private StorySectionData SectionData => SelectedStoryInfo.SectionData;
|
|
|
|
private int SectionId => SectionData.Id;
|
|
|
|
private int? SectionClassId => SelectedStoryInfo.SectionClassId;
|
|
|
|
private List<StoryChapterData> _chapterDataList => Data.StoryInfo.ChapterDataList;
|
|
|
|
public bool IsUseChapterListClearedMask { get; private set; }
|
|
|
|
private bool HasAnotherEndingAppearanceAnimation => _anotherEndingAppearanceAnimationChapterData != null;
|
|
|
|
private void InitUnlockChapter()
|
|
{
|
|
ChangeStateUnlockChapter(CHAPTERUNLOCK_STATE.STATE_NULL);
|
|
NewAreaTimer = 0f;
|
|
SetPlayerIconVisible(isvisible: false);
|
|
IsPlayingUnlockChapter = false;
|
|
}
|
|
|
|
private void LoadUnlockChapterResources(Action onFinish)
|
|
{
|
|
_loadEffectResources.Clear();
|
|
_loadEffectResources.Add(Toolbox.ResourcesManager.GetAssetTypePath("cmn_ui_clear_1", ResourcesManager.AssetLoadPathType.Effect2D));
|
|
_loadEffectResources.Add(Toolbox.ResourcesManager.GetAssetTypePath("cmn_ui_clear_2", ResourcesManager.AssetLoadPathType.Effect2D));
|
|
Toolbox.ResourcesManager.StartCoroutine_LoadAssetGroupAsync(_loadEffectResources, delegate
|
|
{
|
|
StartCoroutine(CreateEffect(onFinish));
|
|
});
|
|
}
|
|
|
|
private IEnumerator CreateEffect(Action onFinish)
|
|
{
|
|
bool isLoadClearEffect = false;
|
|
_clearEffect = EffectUtility.CreateEffect2D(new Effect2dCreateParam
|
|
{
|
|
Parent = base.gameObject,
|
|
EffectName = "cmn_ui_clear_1",
|
|
UnloadAssetList = _loadEffectResources,
|
|
MaterialSetEndCallback = delegate
|
|
{
|
|
isLoadClearEffect = true;
|
|
}
|
|
});
|
|
bool isLoadAlreadyReadEffect = false;
|
|
_alreadyReadEffect = EffectUtility.CreateEffect2D(new Effect2dCreateParam
|
|
{
|
|
Parent = base.gameObject,
|
|
EffectName = "cmn_ui_clear_2",
|
|
UnloadAssetList = _loadEffectResources,
|
|
MaterialSetEndCallback = delegate
|
|
{
|
|
isLoadAlreadyReadEffect = true;
|
|
}
|
|
});
|
|
while (!isLoadClearEffect || !isLoadAlreadyReadEffect)
|
|
{
|
|
yield return null;
|
|
}
|
|
onFinish.Call();
|
|
}
|
|
|
|
private void UnloadUnlockChapterResources()
|
|
{
|
|
Toolbox.ResourcesManager.RemoveAssetGroup(_loadEffectResources);
|
|
_loadEffectResources.Clear();
|
|
}
|
|
|
|
private void UpdateUnlockChapter()
|
|
{
|
|
switch (StateChapterUnlock)
|
|
{
|
|
case CHAPTERUNLOCK_STATE.STATE_EFFECT_CLEARLABEL:
|
|
StateUnlockChapter_EffectClearLabel_Update();
|
|
break;
|
|
case CHAPTERUNLOCK_STATE.STATE_FOCUS_NEWCHAPTER:
|
|
StateUnlockChapter_FocusNewChapter_Update();
|
|
break;
|
|
case CHAPTERUNLOCK_STATE.STATE_DISP_MAPICON:
|
|
StateUnlockChapter_DispMapIcon_Update();
|
|
break;
|
|
}
|
|
}
|
|
|
|
private bool CheckUnlockChapter()
|
|
{
|
|
if (SectionData.IsTutorialCategory)
|
|
{
|
|
return false;
|
|
}
|
|
if (!_beforeReleasedChapterNum.HasValue || _beforeNextChapterId == null)
|
|
{
|
|
return false;
|
|
}
|
|
StoryChapterData storyChapterData = Data.StoryInfo.FindChapterData(_beforeNextChapterId);
|
|
if (storyChapterData != null && storyChapterData.IsPlayedChapter)
|
|
{
|
|
return false;
|
|
}
|
|
int value = _beforeReleasedChapterNum.Value;
|
|
return nowAreaAllNum > value;
|
|
}
|
|
|
|
private int? CheckSection20UnlockChapter()
|
|
{
|
|
if (SectionId == 20)
|
|
{
|
|
int num = nowAreaAllNum;
|
|
bool flag = false;
|
|
if (num == 10 && !PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.IS_SECTION20_WERUSA_ANIMATION_PLAYED))
|
|
{
|
|
flag = true;
|
|
}
|
|
if (num == 26 && !PlayerPrefsWrapper.GetBool(PlayerPrefsWrapper.IS_SECTION20_NATERA_ANIMATION_PLAYED))
|
|
{
|
|
flag = true;
|
|
}
|
|
if (flag)
|
|
{
|
|
return num - 2;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void SetupUnlockChapter()
|
|
{
|
|
SelectChapter(_beforeReleasedChapterNum.Value - 1, isplayse: false, iscalcscroll: true, ismapiconeffectenable: false);
|
|
MoveToScreenChapterList(isIn: true, isImmediate: true);
|
|
UpdateChapterList(isinterpscale: false);
|
|
MoveToScreenTitlePanel(isIn: true, isImmediate: true);
|
|
_chapterRewardPanel.MoveToScreen(isIn: true, isImmediate: true);
|
|
_BG.GetBGRoot().transform.localScale = BG_SCALE_ZOOMIN;
|
|
mapMoveTarget(0f);
|
|
SetPlayerIconVisible(isvisible: false);
|
|
_chapterSelectButtonList[_selectChapterIndex].SetClearVisible(visible: false);
|
|
_topBar.SetBackButtonEnable(enable: false);
|
|
_mapIcon.SetActiveMapIcon(nowAreaAllNum - 1, isActive: false);
|
|
}
|
|
|
|
private void StartUnlockChapter()
|
|
{
|
|
ChangeStateUnlockChapter(CHAPTERUNLOCK_STATE.STATE_EFFECT_CLEARLABEL);
|
|
SetChapterScrollEnable(isEnable: false);
|
|
IsPlayingUnlockChapter = true;
|
|
}
|
|
|
|
private void StartUnlockChapterWithoutClear()
|
|
{
|
|
ChangeStateUnlockChapter(CHAPTERUNLOCK_STATE.STATE_FOCUS_NEWCHAPTER);
|
|
SetChapterScrollEnable(isEnable: false);
|
|
IsPlayingUnlockChapter = true;
|
|
}
|
|
|
|
private void OnUnlockChapterEnd()
|
|
{
|
|
SetPlayerIconVisible(_selectChapterData.IsDisplayMapIcon);
|
|
SetChapterScrollEnable(isEnable: true);
|
|
CheckPreBuildDeckConfirmDialog();
|
|
_topBar.SetBackButtonEnable(enable: true);
|
|
IsPlayingUnlockChapter = false;
|
|
}
|
|
|
|
private void ChangeStateUnlockChapter(CHAPTERUNLOCK_STATE newstate)
|
|
{
|
|
if (StateChapterUnlock != newstate)
|
|
{
|
|
switch (StateChapterUnlock)
|
|
{
|
|
case CHAPTERUNLOCK_STATE.STATE_EFFECT_CLEARLABEL:
|
|
StateUnlockChapter_EffectClearLabel_Exit();
|
|
break;
|
|
case CHAPTERUNLOCK_STATE.STATE_FOCUS_NEWCHAPTER:
|
|
StateUnlockChapter_FocusNewChapter_Exit();
|
|
break;
|
|
case CHAPTERUNLOCK_STATE.STATE_DISP_MAPICON:
|
|
StateUnlockChapter_DispMapIcon_Exit();
|
|
break;
|
|
}
|
|
switch (newstate)
|
|
{
|
|
case CHAPTERUNLOCK_STATE.STATE_EFFECT_CLEARLABEL:
|
|
StateUnlockChapter_EffectClearLabel_Enter();
|
|
break;
|
|
case CHAPTERUNLOCK_STATE.STATE_FOCUS_NEWCHAPTER:
|
|
StateUnlockChapter_FocusNewChapter_Enter();
|
|
break;
|
|
case CHAPTERUNLOCK_STATE.STATE_DISP_MAPICON:
|
|
StateUnlockChapter_DispMapIcon_Enter();
|
|
break;
|
|
}
|
|
StateChapterUnlock = newstate;
|
|
}
|
|
}
|
|
|
|
private void StateUnlockChapter_EffectClearLabel_Update()
|
|
{
|
|
NewAreaTimer -= Time.deltaTime;
|
|
float num = ((_BG.ChapterExtraData == null) ? 1.1f : (1.1f + _BG.ChapterExtraData.FirstClearEffectDelayTime));
|
|
if (!IsClearLabelDisplayed && NewAreaTimer < num - 0.4f)
|
|
{
|
|
_clearEffectPlayingChapter.OnFinishClearEffect();
|
|
IsClearLabelDisplayed = true;
|
|
}
|
|
if (NewAreaTimer < 0f && !IsNewMapIconFocused)
|
|
{
|
|
IsNewMapIconFocused = true;
|
|
if (_BG.ChapterExtraData != null && _BG.ChapterExtraData.FirstClearMoveDelayTime > 0f)
|
|
{
|
|
_BG.SetExtraTexture(_BG.BeforeChapterId + 1);
|
|
StartCoroutine(MoveDelay());
|
|
}
|
|
else
|
|
{
|
|
ChangeStateUnlockChapter(CHAPTERUNLOCK_STATE.STATE_FOCUS_NEWCHAPTER);
|
|
}
|
|
}
|
|
}
|
|
|
|
private IEnumerator MoveDelay()
|
|
{
|
|
yield return new WaitForSeconds((_BG.ChapterExtraData == null) ? 0f : _BG.ChapterExtraData.FirstClearMoveDelayTime);
|
|
ChangeStateUnlockChapter(CHAPTERUNLOCK_STATE.STATE_FOCUS_NEWCHAPTER);
|
|
}
|
|
|
|
private void StateUnlockChapter_EffectClearLabel_Enter()
|
|
{
|
|
StartCoroutine(_BG.SetClearEffect());
|
|
if (_selectChapterIndex >= 0 && _selectChapterIndex < _chapterSelectButtonList.Count)
|
|
{
|
|
_clearEffectPlayingChapter = _chapterSelectButtonList[_selectChapterIndex];
|
|
_chapterSelectButtonList[_selectChapterIndex].UpdateClearState(_selectChapterData.ClearStatus);
|
|
}
|
|
if (!(null == _clearEffectPlayingChapter))
|
|
{
|
|
_chapterSelectButtonList[_selectChapterIndex].OnStartClearEffect();
|
|
IsClearLabelDisplayed = false;
|
|
GameMgr.GetIns().GetSoundMgr().PlaySe(Se.TYPE.SYS_MAP_CLEAR);
|
|
GameObject obj = ((_selectChapterData.ClearStatus == StoryChapterData.ChapterClearStatus.Cleared) ? _clearEffect : _alreadyReadEffect);
|
|
obj.transform.parent = _clearEffectPlayingChapter.ClearLabelTransform;
|
|
obj.transform.localPosition = Vector3.zero;
|
|
obj.gameObject.SetActive(value: true);
|
|
float newAreaTimer = ((_BG.ChapterExtraData == null) ? 1.1f : (1.1f + _BG.ChapterExtraData.FirstClearEffectDelayTime));
|
|
NewAreaTimer = newAreaTimer;
|
|
}
|
|
}
|
|
|
|
private void StateUnlockChapter_EffectClearLabel_Exit()
|
|
{
|
|
_clearEffectPlayingChapter = null;
|
|
}
|
|
|
|
private void StateUnlockChapter_FocusNewChapter_Update()
|
|
{
|
|
mapMoveTarget((_BG.TransitionChapterExtraData == null) ? 1f : _BG.TransitionChapterExtraData.ChapterMoveTime);
|
|
if (!IsNewMapIconOpened && NewAreaTimer < 0.55f)
|
|
{
|
|
if (!_selectChapterData.IsDisplayMapIcon)
|
|
{
|
|
_mapIcon.SetActiveMapIcon(_selectChapterIndex, isActive: false);
|
|
}
|
|
else
|
|
{
|
|
_mapIcon.SetActiveMapIcon(_selectChapterIndex, isActive: true);
|
|
Vector3 mapIconPos = _mapIcon.GetMapIconPos(_selectChapterIndex, isLocal: false);
|
|
GameMgr.GetIns().GetEffectMgr().Start(EffectMgr.EffectType.CMN_MAP_CHAPTER_1, mapIconPos.x, mapIconPos.y);
|
|
GameMgr.GetIns().GetSoundMgr().PlaySe(Se.TYPE.SYS_MAP_NEW_AREA_RELEASE);
|
|
}
|
|
IsNewMapIconOpened = true;
|
|
}
|
|
NewAreaTimer -= Time.deltaTime;
|
|
if (NewAreaTimer < 0f)
|
|
{
|
|
ChangeStateUnlockChapter(CHAPTERUNLOCK_STATE.STATE_DISP_MAPICON);
|
|
}
|
|
}
|
|
|
|
private void StateUnlockChapter_FocusNewChapter_Enter()
|
|
{
|
|
SelectChapter(nowAreaAllNum - 1, isplayse: false, iscalcscroll: true, ismapiconeffectenable: false, isFirstClear: true);
|
|
GameMgr.GetIns().GetSoundMgr().PlaySe(Se.TYPE.SYS_MAP_CAMERA_MOVE);
|
|
NewAreaTimer = ((_BG.TransitionChapterExtraData == null) ? 1f : (1f + _BG.TransitionChapterExtraData.FirstClearMoveOutDelayTime));
|
|
IsNewMapIconOpened = false;
|
|
}
|
|
|
|
private void StateUnlockChapter_FocusNewChapter_Exit()
|
|
{
|
|
}
|
|
|
|
private void StateUnlockChapter_DispMapIcon_Update()
|
|
{
|
|
NewAreaTimer -= Time.deltaTime;
|
|
if (NewAreaTimer < 0f)
|
|
{
|
|
if (_selectChapterData.IsDisplayMapIcon)
|
|
{
|
|
_mapIcon.StartMapIconEffect(StoryChapterData.ChapterClearStatus.NotCleared, _selectChapterIndex);
|
|
}
|
|
ChangeStateUnlockChapter(CHAPTERUNLOCK_STATE.STATE_NULL);
|
|
}
|
|
}
|
|
|
|
private void StateUnlockChapter_DispMapIcon_Enter()
|
|
{
|
|
NewAreaTimer = 0.05f;
|
|
}
|
|
|
|
private void StateUnlockChapter_DispMapIcon_Exit()
|
|
{
|
|
OnUnlockChapterEnd();
|
|
}
|
|
|
|
public static void SetRecoveryData(SetupConditionInfo setupInfo)
|
|
{
|
|
Data.StoryInfo.IsPreBuildDeck = setupInfo.ScenarioDeckIsPreBuild;
|
|
Data.StoryInfo.IsTrialDeck = setupInfo.ScenarioDeckIsTrial;
|
|
Data.StoryInfo.IsStoryBattleDone = true;
|
|
StoryNextSceneSelector.ResetHistoryOfUsingPreBuildDeck();
|
|
}
|
|
|
|
public override void onFirstStart()
|
|
{
|
|
_chapterSelectButtonOriginal.gameObject.SetActive(value: false);
|
|
bool flag = false;
|
|
if (SectionData.IsTutorial)
|
|
{
|
|
IsUseChapterListScroll = false;
|
|
IsUseChapterListClearedMask = true;
|
|
IsUseChapterListTapEffect = true;
|
|
IsUseChapterListSwitch = false;
|
|
flag = false;
|
|
}
|
|
else if (SectionData.IsTutorialReplay)
|
|
{
|
|
IsUseChapterListScroll = true;
|
|
IsUseChapterListClearedMask = false;
|
|
IsUseChapterListTapEffect = false;
|
|
IsUseChapterListSwitch = true;
|
|
flag = true;
|
|
}
|
|
else
|
|
{
|
|
IsUseChapterListScroll = true;
|
|
IsUseChapterListClearedMask = false;
|
|
IsUseChapterListTapEffect = false;
|
|
IsUseChapterListSwitch = true;
|
|
flag = true;
|
|
}
|
|
UIManager.GetInstance().createInSceneLoading();
|
|
if (flag)
|
|
{
|
|
_topBar = StoryChapterSelectionUtility.CreateTopBar(base.gameObject, SelectedStoryInfo, new UIManager.ChangeViewSceneParam
|
|
{
|
|
OnChange = delegate
|
|
{
|
|
_isBackTransitionStarted = true;
|
|
}
|
|
}, 1);
|
|
}
|
|
_titlePanel = CreateTitlePanel();
|
|
_chapterRewardPanel = CreateChapterRewardPanel();
|
|
if (IsUseChapterListSwitch)
|
|
{
|
|
_chapterSelectSphere.OnClick = delegate
|
|
{
|
|
OnSwitchChapterSelect();
|
|
};
|
|
}
|
|
StoryNextSceneSelector.ResetHistoryOfUsingPreBuildDeck();
|
|
Data.StoryInfo.IsStoryBattleDone = false;
|
|
base.onFirstStart();
|
|
}
|
|
|
|
protected override void onClose()
|
|
{
|
|
GameMgr.GetIns().GetEffectMgr().StopBuff(EffectMgr.EffectType.CMN_MAP_PLAYERICON, PlayerIcon);
|
|
_mapIcon.Term();
|
|
_chapterEffect.UnLoadEffect();
|
|
_chapterEffect.Term();
|
|
StopEffectTap();
|
|
if (LoadStatusTutorialEffect.Loaded == _loadStatusTutorialEffect)
|
|
{
|
|
GameMgr.GetIns().GetEffectMgr().DisposeLatestMadeEffects();
|
|
_loadStatusTutorialEffect = LoadStatusTutorialEffect.NotLoad;
|
|
}
|
|
Toolbox.ResourcesManager.RemoveAssetGroup(_resourcePathList);
|
|
_resourcePathList.Clear();
|
|
GameMgr.GetIns().GetSoundMgr().UnloadSe(CUESHEETNAME_MAP);
|
|
UnloadUnlockChapterResources();
|
|
_BG.UnLoadBG();
|
|
_BG.Term();
|
|
if (_scenarioSummary != null)
|
|
{
|
|
_scenarioSummary.Dispose();
|
|
}
|
|
_chapterRewardPanel.ReleaseClearPresent();
|
|
Toolbox.ResourcesManager.RemoveAssetGroup(Toolbox.ResourcesManager.CardListAssetPathList);
|
|
Toolbox.ResourcesManager.CardListAssetPathList.Clear();
|
|
InitBGStartMove();
|
|
InitUnlockChapter();
|
|
base.onClose();
|
|
}
|
|
|
|
private void OnTouchChapterListTutorial(int chapterindex)
|
|
{
|
|
if (chapterindex == _selectChapterIndex)
|
|
{
|
|
GameMgr.GetIns().GetSoundMgr().PlaySe(Se.TYPE.SYS_BTN_DECIDE);
|
|
StopEffectTap();
|
|
ExecuteSelectionProcessings();
|
|
}
|
|
else if (SectionData.IsTutorialReplay)
|
|
{
|
|
SelectChapter(chapterindex, isplayse: true, iscalcscroll: true);
|
|
}
|
|
}
|
|
|
|
private void SetChapterScrollEnable(bool isEnable)
|
|
{
|
|
if (null != ChapterListScrollView && ChapterListScrollView.enabled != isEnable)
|
|
{
|
|
ChapterListScrollView.enabled = isEnable;
|
|
}
|
|
if (_chapterSelectButtonList == null)
|
|
{
|
|
return;
|
|
}
|
|
foreach (ChapterSelectButton chapterSelectButton in _chapterSelectButtonList)
|
|
{
|
|
if (chapterSelectButton != null)
|
|
{
|
|
chapterSelectButton.SetScrollEnable(isEnable);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnTouchChapterList(int chapterindex)
|
|
{
|
|
if (!IsPlayingUnlockChapter && !_unlockAfterZoom)
|
|
{
|
|
if (chapterindex == _selectChapterIndex)
|
|
{
|
|
GameMgr.GetIns().GetSoundMgr().PlaySe(Se.TYPE.SYS_BTN_DECIDE);
|
|
ExecuteSelectionProcessings();
|
|
}
|
|
else
|
|
{
|
|
SelectChapter(chapterindex, isplayse: true, iscalcscroll: true);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnCancelScenarioSummary()
|
|
{
|
|
if (IsUseChapterListTapEffect)
|
|
{
|
|
StartEffectTap();
|
|
}
|
|
}
|
|
|
|
private void StartEffectTap()
|
|
{
|
|
if (IsUseChapterListTapEffect && !(null != ChapterListTapEffect))
|
|
{
|
|
ChapterListTapEffectLocator = _chapterSelectButtonList[_chapterSelectButtonList.Count - 1].TapEffectLocator;
|
|
ChapterListTapEffect = GameMgr.GetIns().GetEffectMgr().StartBuff(EffectMgr.EffectType.CMN_TUTORIAL_TAP_1, ChapterListTapEffectLocator);
|
|
}
|
|
}
|
|
|
|
private void StopEffectTap()
|
|
{
|
|
if (!(null == ChapterListTapEffectLocator))
|
|
{
|
|
GameMgr.GetIns().GetEffectMgr().StopBuff(EffectMgr.EffectType.CMN_TUTORIAL_TAP_1, ChapterListTapEffectLocator);
|
|
ChapterListTapEffectLocator = null;
|
|
ChapterListTapEffect = null;
|
|
}
|
|
}
|
|
|
|
private void LimitAreaScroll()
|
|
{
|
|
int count = _chapterSelectButtonList.Count;
|
|
UIPanel component = ChapterListScrollView.transform.GetComponent<UIPanel>();
|
|
component.clipOffset = CHAPTERLIST_PANEL_CLIPOFFSET;
|
|
component.baseClipRegion = new Vector4(CHAPTERLIST_PANEL_CLIPPOS.x, CHAPTERLIST_PANEL_CLIPPOS.y, CHAPTERLIST_PANEL_CLIPSIZE.x, CHAPTERLIST_PANEL_CLIPSIZE.y + (float)(count * 2) * 80f);
|
|
}
|
|
|
|
private void OnSwitchChapterSelect()
|
|
{
|
|
if (!IsPlayingUnlockChapter && !_isPlayingBGStartMove)
|
|
{
|
|
IsChapterSelectEnable = !IsChapterSelectEnable;
|
|
SetChapterSelectEnable(IsChapterSelectEnable, isplayse: true);
|
|
SetChapterScrollEnable(IsChapterSelectEnable);
|
|
SetPlayerIconVisible(IsChapterSelectEnable && _selectChapterData.IsDisplayMapIcon);
|
|
_BG.SetBGDragEnable(!IsChapterSelectEnable && _selectChapterData.IsEnableDragMapBG);
|
|
if (IsChapterSelectEnable && _selectChapterData.IsDisplayMapIcon)
|
|
{
|
|
_mapIcon.StartMapIconEffect(_selectChapterData.ClearStatus, _selectChapterIndex);
|
|
}
|
|
else
|
|
{
|
|
_mapIcon.StopMapIconEffect();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MoveToScreenObj(GameObject target, float localPosX, float time, Action onComplete = null)
|
|
{
|
|
if (Mathf.Approximately(time, 0f))
|
|
{
|
|
Vector3 localPosition = target.transform.localPosition;
|
|
localPosition.x = localPosX;
|
|
target.transform.localPosition = localPosition;
|
|
onComplete.Call();
|
|
return;
|
|
}
|
|
iTween.MoveTo(target, iTween.Hash("islocal", true, "x", localPosX, "time", time));
|
|
StartCoroutine(DelayedCall(time, onComplete.Call));
|
|
}
|
|
|
|
private IEnumerator DelayedCall(float time, Action callback)
|
|
{
|
|
yield return new WaitForSeconds(time);
|
|
if (!_isBackTransitionStarted)
|
|
{
|
|
callback.Call();
|
|
}
|
|
}
|
|
|
|
private void MoveToScreenRightPartsRoot(bool isIn, bool isImmediate)
|
|
{
|
|
float time = (isImmediate ? 0f : 0.5f);
|
|
if (isIn)
|
|
{
|
|
SetChapterListMarqueeDisable();
|
|
}
|
|
MoveToScreenObj(RightPartsRoot, isIn ? (-25f) : 800f, time, delegate
|
|
{
|
|
if (isIn)
|
|
{
|
|
SetSelectedChapterMarqueeEnable();
|
|
}
|
|
});
|
|
if (isIn && !_unlockAfterZoom)
|
|
{
|
|
if (isImmediate)
|
|
{
|
|
SetChapterScrollEnable(IsUseChapterListScroll);
|
|
}
|
|
else
|
|
{
|
|
StartCoroutine(MoveToScreenRightCallBack(time));
|
|
}
|
|
}
|
|
}
|
|
|
|
private IEnumerator MoveToScreenRightCallBack(float time)
|
|
{
|
|
yield return new WaitForSeconds(time);
|
|
SetChapterScrollEnable(IsUseChapterListScroll);
|
|
}
|
|
|
|
private void MoveToScreenChapterList(bool isIn, bool isImmediate)
|
|
{
|
|
if (isIn)
|
|
{
|
|
SetChapterListMarqueeDisable();
|
|
}
|
|
MoveToScreenObj(ChapterListRoot, isIn ? (-200f) : 400f, isImmediate ? 0f : 0.5f, delegate
|
|
{
|
|
if (isIn)
|
|
{
|
|
SetSelectedChapterMarqueeEnable();
|
|
}
|
|
});
|
|
}
|
|
|
|
private void MoveToScreenTitlePanel(bool isIn, bool isImmediate)
|
|
{
|
|
MoveToScreenObj(_titlePanel.gameObject, isIn ? 0f : 949f, isImmediate ? 0f : 0.5f);
|
|
}
|
|
|
|
private void SetChapterSelectEnable(bool enable, bool isplayse)
|
|
{
|
|
IsChapterSelectEnable = enable;
|
|
_chapterSelectSphere.UpdateChapterSelectStatus(IsChapterSelectEnable, IsUseChapterListSwitch);
|
|
MoveToScreenChapterList(enable, isImmediate: false);
|
|
MoveToScreenTitlePanel(enable, isImmediate: false);
|
|
_chapterRewardPanel.MoveToScreen(enable, isImmediate: false);
|
|
_chapterListScrollCollision.SetActive(enable);
|
|
_BG.SetBGDragEnable(!enable);
|
|
if (isplayse)
|
|
{
|
|
GameMgr.GetIns().GetSoundMgr().PlaySe(enable ? Se.TYPE.SYS_TOGGLE_ON : Se.TYPE.SYS_TOGGLE_OFF);
|
|
}
|
|
}
|
|
|
|
private void SetChapterListMarqueeDisable()
|
|
{
|
|
if (_chapterSelectButtonList == null)
|
|
{
|
|
return;
|
|
}
|
|
foreach (ChapterSelectButton chapterSelectButton in _chapterSelectButtonList)
|
|
{
|
|
chapterSelectButton.SetMarqueeEnable(enable: false);
|
|
}
|
|
}
|
|
|
|
private void SetSelectedChapterMarqueeEnable()
|
|
{
|
|
if (_chapterSelectButtonList != null)
|
|
{
|
|
_chapterSelectButtonList[_selectChapterIndex].SetMarqueeEnable(enable: true);
|
|
}
|
|
}
|
|
|
|
protected override void onOpen()
|
|
{
|
|
base.onOpen();
|
|
UIManager.GetInstance().OpenNotTouch();
|
|
ResetSelectedStoryInfo();
|
|
InitBGStartMove();
|
|
InitUnlockChapter();
|
|
SetChapterSelectEnable(enable: true, isplayse: false);
|
|
SetChapterScrollEnable(isEnable: false);
|
|
_mapIcon.Init();
|
|
_BG.Init(this);
|
|
_chapterEffect.Init(this, base.transform);
|
|
SetPlayerIconVisible(isvisible: false);
|
|
PlayerIcon.transform.localPosition = new Vector3(0f, -320f, 0f);
|
|
_firstSelectionProcessing = CreateSelectionProcessings(SectionData.IsTutorialCategory);
|
|
StartCoroutine(Setup());
|
|
}
|
|
|
|
private IEnumerator Setup()
|
|
{
|
|
IsSetupEnd = false;
|
|
if (SectionData.IsTutorialCategory)
|
|
{
|
|
SetupChapterDataListTutorial();
|
|
}
|
|
else
|
|
{
|
|
yield return StoryChapterSelectionUtility.StoryInfoTaskCoroutine(SelectedStoryInfo);
|
|
yield return StoryChapterSelectionUtility.LoadAiMasterCoroutine(_chapterDataList);
|
|
StoryChapterSelectionUtility.RegisterMaintenanceChapters(_chapterDataList);
|
|
_anotherEndingAppearanceAnimationChapterData = ((_beforeNextChapterId == null) ? _chapterDataList.FirstOrDefault((StoryChapterData x) => x.IsPlayAnotherEndingAppearanceAnimation && x.IsReleased) : null);
|
|
}
|
|
StartCoroutine(assetSetting());
|
|
IsLoadEnd = false;
|
|
StartCoroutine(LoadAndSetupResourcesAsync());
|
|
_BG.LoadBG(SectionData, SectionClassId);
|
|
_chapterEffect.LoadEffect(_chapterDataList);
|
|
_chapterRewardPanel.LoadClearPresent(_chapterDataList);
|
|
while (!IsLoadEnd || !_chapterRewardPanel.GetLoadEnd() || !_BG.GetLoadEnd() || !_chapterEffect.GetLoadEnd())
|
|
{
|
|
yield return null;
|
|
}
|
|
SetupChapterList();
|
|
_mapIcon.SetupMapIcon(_chapterDataList);
|
|
if (CheckUnlockChapter())
|
|
{
|
|
SetupUnlockChapter();
|
|
}
|
|
else
|
|
{
|
|
int? focus = CheckSection20UnlockChapter();
|
|
if (focus.HasValue)
|
|
{
|
|
_unlockAfterZoom = true;
|
|
}
|
|
SetupBGStartMove(focus);
|
|
}
|
|
_chapterRewardPanel.SetClearPresent(_selectChapterData);
|
|
_BG.SetActiveBGEffect(isActive: true);
|
|
IsFadeInEnd = false;
|
|
UIManager.GetInstance().OnReadyViewScene(isFadein: true, null, OnFadeInEnd);
|
|
_BG.SetupEnd();
|
|
IsSetupEnd = true;
|
|
}
|
|
|
|
private IEnumerator LoadAndSetupResourcesAsync()
|
|
{
|
|
_resourcePathList.Clear();
|
|
foreach (StoryChapterData chapterData in _chapterDataList)
|
|
{
|
|
_resourcePathList.Add(ChapterSelectButton.GetHeaderPath(chapterData, isFetch: false));
|
|
}
|
|
if (IsUseChapterListTapEffect)
|
|
{
|
|
_loadStatusTutorialEffect = LoadStatusTutorialEffect.Loading;
|
|
GameMgr.GetIns().GetEffectMgr().InitCommonEffect("Json/EffectTutorialData", isBattle: false, isField: false, isBattleEffect: false, delegate
|
|
{
|
|
_loadStatusTutorialEffect = LoadStatusTutorialEffect.Loaded;
|
|
});
|
|
}
|
|
GameMgr.GetIns().GetSoundMgr().LoadSe(CUESHEETNAME_MAP);
|
|
_scenarioSummary = new ScenarioSummary(SectionId, SectionClassId);
|
|
yield return StartCoroutine(Toolbox.ResourcesManager.LoadAssetGroupAsync(_resourcePathList, null));
|
|
bool isLoadedClearEffect = false;
|
|
LoadUnlockChapterResources(delegate
|
|
{
|
|
isLoadedClearEffect = true;
|
|
});
|
|
while (!_scenarioSummary.IsValid || LoadStatusTutorialEffect.Loading == _loadStatusTutorialEffect || !isLoadedClearEffect || !_titlePanel.IsFinishInit)
|
|
{
|
|
yield return null;
|
|
}
|
|
if (HasAnotherEndingAppearanceAnimation)
|
|
{
|
|
yield return EffectMgr.LoadAndInstantiate2dEffectCoroutine(ANOTHER_ENDING_APPEARANCE_EFFECT_NAME, delegate(GameObject createdEffect, List<string> loadedAssets)
|
|
{
|
|
_anotherEndingAppearanceEffect = createdEffect;
|
|
createdEffect.transform.parent = base.transform;
|
|
_resourcePathList.AddRange(loadedAssets);
|
|
});
|
|
}
|
|
IsLoadEnd = true;
|
|
}
|
|
|
|
public override void onMove()
|
|
{
|
|
if (!IsSetupEnd || !IsFadeInEnd)
|
|
{
|
|
SetChapterListMarqueeDisable();
|
|
return;
|
|
}
|
|
if (IsPlayingUnlockChapter)
|
|
{
|
|
UpdateUnlockChapter();
|
|
UpdateChapterList();
|
|
return;
|
|
}
|
|
UpdateChapterList();
|
|
if (_isPlayingBGStartMove)
|
|
{
|
|
return;
|
|
}
|
|
if (_unlockAfterZoom)
|
|
{
|
|
_unlockAfterZoom = false;
|
|
StartUnlockChapterWithoutClear();
|
|
return;
|
|
}
|
|
UpdateTamaArrow();
|
|
if (_BG.IsBGDragEnable())
|
|
{
|
|
_BG.UpdateBGDrag();
|
|
}
|
|
else
|
|
{
|
|
mapMoveTarget((_BG.TransitionChapterExtraData == null) ? 1.5f : _BG.TransitionChapterExtraData.ChapterMoveTime);
|
|
}
|
|
_mapIcon.UpdateMapIconEffectPos(_selectChapterIndex);
|
|
float y = ChapterListScrollView.transform.localPosition.y;
|
|
int num = (450 - (int)y) / 80;
|
|
if (num < 0)
|
|
{
|
|
num = 0;
|
|
}
|
|
else if (num >= _chapterSelectButtonList.Count)
|
|
{
|
|
num = _chapterSelectButtonList.Count - 1;
|
|
}
|
|
if (num != _selectChapterIndex)
|
|
{
|
|
SelectChapter(num, isplayse: true);
|
|
}
|
|
base.onMove();
|
|
}
|
|
|
|
private void SelectChapter(int newIndex, bool isplayse = false, bool iscalcscroll = false, bool ismapiconeffectenable = true, bool isFirstClear = false)
|
|
{
|
|
int selectChapterIndex = _selectChapterIndex;
|
|
_selectChapterIndex = newIndex;
|
|
if (_selectChapterIndex < 0 || _selectChapterIndex >= _chapterDataList.Count)
|
|
{
|
|
_selectChapterIndex = 0;
|
|
}
|
|
if (SectionId == 20)
|
|
{
|
|
if (_selectChapterIndex == 9)
|
|
{
|
|
PlayerPrefsWrapper.SetBool(PlayerPrefsWrapper.IS_SECTION20_WERUSA_ANIMATION_PLAYED, flag: true);
|
|
}
|
|
else if (_selectChapterIndex == 25)
|
|
{
|
|
PlayerPrefsWrapper.SetBool(PlayerPrefsWrapper.IS_SECTION20_NATERA_ANIMATION_PLAYED, flag: true);
|
|
}
|
|
}
|
|
string chapterId = (newIndex + 1).ToString();
|
|
_selectChapterData = _chapterDataList.Single((StoryChapterData x) => x.ChapterId == chapterId);
|
|
_BG.OnChangeSelectChapter(_selectChapterData, isFirstClear);
|
|
if (SectionId == 20)
|
|
{
|
|
int chapterId2 = int.Parse(_selectChapterData.ChapterId);
|
|
List<int> chaptersWithDifferentBackgroundFrom = _BG.GetChaptersWithDifferentBackgroundFrom(chapterId2);
|
|
for (int num = 0; num < _chapterSelectButtonList.Count; num++)
|
|
{
|
|
bool isActive = !chaptersWithDifferentBackgroundFrom.Contains(num + 1);
|
|
_mapIcon.SetActiveMapIcon(num, isActive);
|
|
}
|
|
}
|
|
_mapIcon.StopMapIconEffect();
|
|
if (ismapiconeffectenable && _selectChapterData.IsDisplayMapIcon)
|
|
{
|
|
_mapIcon.StartMapIconEffect(_selectChapterData.ClearStatus, _selectChapterIndex);
|
|
}
|
|
SetPlayerIconVisible(_selectChapterData.IsDisplayMapIcon);
|
|
SwitchChapterEffectVisible(selectChapterIndex);
|
|
_chapterRewardPanel.SetClearPresent(_selectChapterData);
|
|
if (isplayse)
|
|
{
|
|
GameMgr.GetIns().GetSoundMgr().PlaySe(Se.TYPE.SYS_SCROLL);
|
|
}
|
|
if (iscalcscroll)
|
|
{
|
|
float num2 = 400f - (float)_selectChapterIndex * 80f;
|
|
Vector3 position = ChapterListScrollView.transform.position;
|
|
position.y = num2;
|
|
ChapterListScrollView.transform.localPosition = position;
|
|
ChapterListScrollView.GetComponent<UIPanel>().clipOffset = new Vector2(0f, 0f - num2);
|
|
if (null == ChapterListSpringPanel)
|
|
{
|
|
ChapterListSpringPanel = ChapterListScrollView.GetComponent<SpringPanel>();
|
|
}
|
|
if (null != ChapterListSpringPanel)
|
|
{
|
|
ChapterListSpringPanel.target = Vector3.zero;
|
|
ChapterListSpringPanel.strength = 0f;
|
|
ChapterListSpringPanel.onFinished = null;
|
|
ChapterListSpringPanel.enabled = false;
|
|
}
|
|
}
|
|
_chapterSelectSphere.IsScrollUpEnable = IsUseChapterListScroll && _chapterSelectButtonList.Count > 1 && _selectChapterIndex < _chapterSelectButtonList.Count - 1;
|
|
_chapterSelectSphere.IsScrollDownEnable = IsUseChapterListScroll && _chapterSelectButtonList.Count > 1 && _selectChapterIndex > 0;
|
|
_chapterSelectSphere.OnSelectChapter(IsChapterSelectEnable);
|
|
}
|
|
|
|
private void UpdateTamaArrow()
|
|
{
|
|
if (IsChapterSelectEnable)
|
|
{
|
|
_chapterSelectSphere.UpdateArrowAlpha();
|
|
}
|
|
}
|
|
|
|
private void UpdateChapterList(bool isinterpscale = true)
|
|
{
|
|
for (int i = 0; i < _chapterSelectButtonList.Count; i++)
|
|
{
|
|
ChapterSelectButton chapterSelectButton = _chapterSelectButtonList[i];
|
|
if (chapterSelectButton != null)
|
|
{
|
|
chapterSelectButton.UpdateSelectStatus(_selectChapterIndex, i, this, isinterpscale, ChapterListScrollView);
|
|
}
|
|
}
|
|
if (_isPlayingBGStartMove)
|
|
{
|
|
return;
|
|
}
|
|
bool flag = false;
|
|
float y = ChapterListScrollView.transform.localPosition.y;
|
|
if (ChapterListScrollYPrev != y)
|
|
{
|
|
ChapterListScrollYPrev = y;
|
|
y = 450 - (int)y;
|
|
flag = !Input.GetMouseButton(0) && Input.mouseScrollDelta.y < 0f;
|
|
if (Input.GetMouseButton(0) || flag)
|
|
{
|
|
_chapterSelectSphere.UpdateRotationOnScroll(y, _chapterSelectButtonList.Count);
|
|
}
|
|
}
|
|
if (Input.GetMouseButtonUp(0) || (!flag && _usedScrollWheel))
|
|
{
|
|
_chapterSelectSphere.ResetRotationOnScroll();
|
|
}
|
|
_usedScrollWheel = flag;
|
|
}
|
|
|
|
private void OnFadeInEnd()
|
|
{
|
|
UIManager.GetInstance().offNotTouch();
|
|
if (CheckUnlockChapter())
|
|
{
|
|
StartUnlockChapter();
|
|
}
|
|
else
|
|
{
|
|
StartBGStartMove();
|
|
CheckPreBuildDeckConfirmDialog();
|
|
}
|
|
IsFadeInEnd = true;
|
|
}
|
|
|
|
public static void CheckPreBuildDeckConfirmDialog()
|
|
{
|
|
}
|
|
|
|
private static void ShowBuildDeckBuyConfirmDialog(int currentCount, int maxCount)
|
|
{
|
|
int productId = PlayerPrefsWrapper.GetValue(PlayerPrefsWrapper.LAST_BATTLE_DECK_ID);
|
|
if (currentCount < maxCount)
|
|
{
|
|
SystemText systemText = Data.SystemText;
|
|
string message = systemText.Get("Story_0057");
|
|
if (currentCount > 0)
|
|
{
|
|
message = systemText.Get("Story_0058");
|
|
}
|
|
DialogBase dialogBase = UIManager.GetInstance().CreateConfirmationDialog(message);
|
|
dialogBase.SetButtonLayout(DialogBase.ButtonLayout.BlueBtn_CancelBtn);
|
|
dialogBase.SetTitleLabel(systemText.Get("Story_0056"));
|
|
dialogBase.SetButtonText(systemText.Get("Shop_0095"), systemText.Get("Common_0005"));
|
|
dialogBase.onPushButton1 = delegate
|
|
{
|
|
BuildDeckPurchasePage.BuildDeckConfirmDialogShow(productId);
|
|
UIManager.GetInstance().ChangeViewScene(UIManager.ViewScene.BuildDeckPurchasePage);
|
|
UIManager.GetInstance()._Footer.UpdateCurrentIndex(5);
|
|
};
|
|
}
|
|
}
|
|
|
|
private void SetupChapterDataListTutorial()
|
|
{
|
|
Data.StoryInfo.ChapterDataList = Data.Master.TutorialAreaSelectList.Select((TutorialAreaSelect x) => new StoryChapterData(x)).ToList();
|
|
}
|
|
|
|
private void SetupChapterList()
|
|
{
|
|
if (_chapterDataList == null)
|
|
{
|
|
return;
|
|
}
|
|
if (_chapterSelectButtonList != null)
|
|
{
|
|
for (int i = 0; i < _chapterSelectButtonList.Count; i++)
|
|
{
|
|
UnityEngine.Object.Destroy(_chapterSelectButtonList[i].gameObject);
|
|
}
|
|
}
|
|
_chapterSelectButtonList = new List<ChapterSelectButton>(8);
|
|
nowAreaAllNum = 0;
|
|
for (int j = 0; j < _chapterDataList.Count; j++)
|
|
{
|
|
if (!_chapterDataList[j].IsReleased)
|
|
{
|
|
continue;
|
|
}
|
|
ChapterSelectButton chapterSelectButton = UnityEngine.Object.Instantiate(_chapterSelectButtonOriginal);
|
|
chapterSelectButton.gameObject.SetActive(value: true);
|
|
chapterSelectButton.transform.parent = ChapterListScrollView.transform;
|
|
chapterSelectButton.transform.localPosition = new Vector3(0f, -400f + (float)j * 80f, 0f);
|
|
chapterSelectButton.transform.localScale = Vector3.one;
|
|
chapterSelectButton.name = "chapterlist_" + j.ToString("00");
|
|
chapterSelectButton.SetChapterData(_chapterDataList[j], this, ChapterListScrollView);
|
|
int index = j;
|
|
chapterSelectButton.OnClick = delegate
|
|
{
|
|
if (SectionData.IsTutorialCategory)
|
|
{
|
|
OnTouchChapterListTutorial(index);
|
|
}
|
|
else
|
|
{
|
|
OnTouchChapterList(index);
|
|
}
|
|
};
|
|
_chapterSelectButtonList.Add(chapterSelectButton);
|
|
nowAreaAllNum++;
|
|
}
|
|
LimitAreaScroll();
|
|
ChapterListScrollView.ResetPosition();
|
|
}
|
|
|
|
private void mapMoveTarget(float time)
|
|
{
|
|
Vector3 mapIconPos = _mapIcon.GetMapIconPos(_selectChapterIndex, isLocal: true);
|
|
iTween.MoveUpdate(_BG.GetBGRoot(), iTween.Hash("islocal", true, "x", BG_SCALE_ZOOMIN.x * (mapIconPos.x * -1f), "y", BG_SCALE_ZOOMIN.y * (mapIconPos.y * -1f) + -400f, "time", time, "easetype", iTween.EaseType.easeOutExpo));
|
|
}
|
|
|
|
private void SetPlayerIconVisible(bool isvisible)
|
|
{
|
|
if (isvisible)
|
|
{
|
|
GameMgr.GetIns().GetEffectMgr().StartBuff(EffectMgr.EffectType.CMN_MAP_PLAYERICON, PlayerIcon);
|
|
}
|
|
else
|
|
{
|
|
GameMgr.GetIns().GetEffectMgr().StopBuff(EffectMgr.EffectType.CMN_MAP_PLAYERICON, PlayerIcon);
|
|
}
|
|
}
|
|
|
|
private void SwitchChapterEffectVisible(int previousChapter)
|
|
{
|
|
if (!(_chapterEffect.GetPlayingEffect() == _selectChapterData.ChapterEffectPath))
|
|
{
|
|
float? simulationSpeedAfterStop = null;
|
|
if (SectionId == 20 && AreaBGInfoSection20.IsSpeedUpParticleTransition(previousChapter, _selectChapterIndex))
|
|
{
|
|
simulationSpeedAfterStop = _chapterEffectSimulationSpeedAfterStop;
|
|
}
|
|
_chapterEffect.StopEffect(simulationSpeedAfterStop);
|
|
_chapterEffect.PlayEffect(_selectChapterData.ChapterEffectPath, _chapterEffectLocator.transform.localPosition);
|
|
}
|
|
}
|
|
|
|
public string GetChapterTitleStory(string chapterID)
|
|
{
|
|
if (_scenarioSummary == null)
|
|
{
|
|
return "";
|
|
}
|
|
return _scenarioSummary.GetData(chapterID).Title;
|
|
}
|
|
|
|
private TitlePanelBase CreateTitlePanel()
|
|
{
|
|
return StoryChapterSelectionUtility.CreateTitlePanel(_titlePanelRoot, _commonPrefabContainer.CharaInfoPanelPrefab, _commonPrefabContainer.SectionInfoPanelPrefab, SelectedStoryInfo);
|
|
}
|
|
|
|
private AreaSelInfo CreateChapterRewardPanel()
|
|
{
|
|
return StoryChapterSelectionUtility.CreateChapterRewardPanel(_chapterRewardPanelRoot, _commonPrefabContainer.ChapterRewardPanelPrefab);
|
|
}
|
|
|
|
private void ResetSelectedStoryInfo()
|
|
{
|
|
_beforeNextChapterId = SelectedStoryInfo.NextChapterId;
|
|
_beforeReleasedChapterNum = SelectedStoryInfo.ReleasedChapterNum;
|
|
_beforeReplayChapterIndex = SelectedStoryInfo.ReplayChapterIndex;
|
|
SelectedStoryInfo.ClearInfoForChapterSelectionScene();
|
|
}
|
|
|
|
private static IProcessing CreateSelectionProcessings(bool isTutorialCategory)
|
|
{
|
|
IProcessing[] array = ((!isTutorialCategory) ? new IProcessing[8]
|
|
{
|
|
new SubChapterSelectionDialogDisplay(),
|
|
new SummaryDialogDisplay(),
|
|
new DeckSelectionDialogDisplay(),
|
|
new ChapterCharaDecider(),
|
|
new DownloadInfoGetter(),
|
|
new DownloadConfirmDialogDisplay(),
|
|
new DeckSelectionConfirmDialogDisplay(),
|
|
new StoryStarter()
|
|
} : new IProcessing[3]
|
|
{
|
|
new SummaryDialogDisplay(),
|
|
new ChapterCharaDecider(),
|
|
new TutorialStoryStarter()
|
|
});
|
|
for (int i = 0; i < array.Length - 1; i++)
|
|
{
|
|
array[i].NextProcessing = array[i + 1];
|
|
}
|
|
return array.FirstOrDefault();
|
|
}
|
|
|
|
private void ExecuteSelectionProcessings()
|
|
{
|
|
if (_firstSelectionProcessing != null)
|
|
{
|
|
Parameter param = CreateSelectionProcessingParameter();
|
|
_firstSelectionProcessing.Execute(param);
|
|
}
|
|
}
|
|
|
|
private Parameter CreateSelectionProcessingParameter()
|
|
{
|
|
return new Parameter(this, _commonPrefabContainer, _scenarioSummary, SelectedStoryInfo, _selectChapterData, nowAreaAllNum, null, _selectChapterData.IsPlayedChapter ? new int?(_selectChapterIndex) : ((int?)null));
|
|
}
|
|
|
|
private void InitBGStartMove()
|
|
{
|
|
iTween.Stop(_BG.GetBGRoot());
|
|
}
|
|
|
|
private void SetupBGStartMove(int? focus)
|
|
{
|
|
int newIndex = (focus.HasValue ? focus.Value : GetStartFocusChapterIndex());
|
|
SelectChapter(newIndex, isplayse: false, iscalcscroll: true, ismapiconeffectenable: false);
|
|
MoveToScreenRightPartsRoot(isIn: false, isImmediate: true);
|
|
_chapterRewardPanel.MoveToScreen(isIn: false, isImmediate: true);
|
|
if (AspectCamera.SafeAreaRate < 1f)
|
|
{
|
|
float num = (float)Screen.width / (float)Screen.height / 1.7777778f;
|
|
_BG.GetBGRoot().transform.localScale = BG_SCALE_ZOOMOUT * num;
|
|
}
|
|
else
|
|
{
|
|
_BG.GetBGRoot().transform.localScale = BG_SCALE_ZOOMOUT;
|
|
}
|
|
_BG.GetBGRoot().transform.localPosition = BG_POS_ZOOMOUT;
|
|
SetPlayerIconVisible(isvisible: false);
|
|
InitAnotherEndingAppearanceEffect();
|
|
}
|
|
|
|
private void StartBGStartMove()
|
|
{
|
|
StartCoroutine(PlayAnimationCoroutine());
|
|
}
|
|
|
|
private IEnumerator PlayAnimationCoroutine()
|
|
{
|
|
_isPlayingBGStartMove = true;
|
|
yield return new WaitForSeconds(1f);
|
|
yield return ZoomInCoroutine();
|
|
if (HasAnotherEndingAppearanceAnimation)
|
|
{
|
|
yield return PlayAnotherEndingAppearanceAnimationCoroutine();
|
|
}
|
|
yield return PlayUiEntranceAnimationCoroutine();
|
|
_isPlayingBGStartMove = false;
|
|
}
|
|
|
|
private IEnumerator ZoomInCoroutine()
|
|
{
|
|
iTween.ScaleTo(_BG.GetBGRoot(), iTween.Hash("scale", BG_SCALE_ZOOMIN, "islocal", true, "time", 1f, "easetype", BG_ZOOMIN_EASETYPE));
|
|
Vector3 mapIconPos = _mapIcon.GetMapIconPos(_selectChapterIndex, isLocal: true);
|
|
iTween.MoveTo(_BG.GetBGRoot(), iTween.Hash("islocal", true, "x", BG_SCALE_ZOOMIN.x * (mapIconPos.x * -1f), "y", BG_SCALE_ZOOMIN.y * (mapIconPos.y * -1f) + -400f, "time", 1f, "easetype", BG_ZOOMIN_EASETYPE));
|
|
yield return new WaitForSeconds(1f);
|
|
}
|
|
|
|
private IEnumerator PlayAnotherEndingAppearanceAnimationCoroutine()
|
|
{
|
|
_anotherEndingAppearanceEffect.SetActive(value: true);
|
|
yield return new WaitForSeconds(1.5f);
|
|
}
|
|
|
|
private IEnumerator PlayUiEntranceAnimationCoroutine()
|
|
{
|
|
SetPlayerIconVisible(_selectChapterData.IsDisplayMapIcon);
|
|
if (_selectChapterData.IsDisplayMapIcon)
|
|
{
|
|
_mapIcon.StartMapIconEffect(_selectChapterData.ClearStatus, _selectChapterIndex);
|
|
}
|
|
StartCoroutine(assetSetting());
|
|
MoveToScreenRightPartsRoot(isIn: true, isImmediate: false);
|
|
MoveToScreenTitlePanel(isIn: true, isImmediate: false);
|
|
_chapterRewardPanel.MoveToScreen(isIn: true, isImmediate: false);
|
|
yield return new WaitForSeconds(1f);
|
|
StartEffectTap();
|
|
}
|
|
|
|
private int GetStartFocusChapterIndex()
|
|
{
|
|
if (HasAnotherEndingAppearanceAnimation)
|
|
{
|
|
return int.Parse(_anotherEndingAppearanceAnimationChapterData.ChapterId) - 1;
|
|
}
|
|
if (_beforeReplayChapterIndex.HasValue && _beforeReplayChapterIndex.Value < nowAreaAllNum - 1)
|
|
{
|
|
return _beforeReplayChapterIndex.Value + 1;
|
|
}
|
|
return nowAreaAllNum - 1;
|
|
}
|
|
|
|
private void InitAnotherEndingAppearanceEffect()
|
|
{
|
|
if (HasAnotherEndingAppearanceAnimation)
|
|
{
|
|
int chapterIndex = int.Parse(_anotherEndingAppearanceAnimationChapterData.ChapterId) - 1;
|
|
InitEffect(_anotherEndingAppearanceEffect, _mapIcon.GetMapIconObject(chapterIndex));
|
|
}
|
|
}
|
|
|
|
private static void InitEffect(GameObject effect, GameObject parent)
|
|
{
|
|
Transform transform = effect.transform;
|
|
Vector3 localScale = UIManager.GetInstance().UIManagerRoot.transform.localScale;
|
|
transform.parent = parent.transform;
|
|
transform.localPosition = Vector3.zero;
|
|
transform.localRotation = Quaternion.identity;
|
|
transform.localScale = new Vector3(1f / localScale.x, 1f / localScale.y, 1f / localScale.z);
|
|
UIManager.GetInstance().SetLayerRecursive(transform, parent.layer);
|
|
}
|
|
}
|