public override void Release()
{
this.data.pack?.Receive(SceneParameter.advScene.Scenario);
SceneParameter.advScene.Scenario.SetPackage((IPack)null);
MapUIContainer.SetActiveChoiceUI(false);
Singleton <MapUIContainer> .Instance.CloseADV();
}
public static void LateUpdate()
{
if (playerController == null)
{
return;
}
if (PlayerDeath.Value != DeathType.None && playerController["health"] == 0)
{
if (MapUIContainer.AnyUIActive())
{
debounce = 1f;
}
else if (debounce > 0f)
{
debounce -= Time.unscaledDeltaTime;
}
if (!wasDead && PlayerDeathReset.Value)
{
foreach (var controller in agentControllers.Where(n => n != null))
{
Status.ResetAgentStats(controller);
}
}
wasDead = true;
PlayerActor player = Map.Instance.Player;
player.Controller.enabled = debounce > 0f;
if (player.ChaControl.enabled)
{
player.ChaControl.enabled = false;
}
if (player.Animation.enabled)
{
player.Animation.enabled = false;
}
if (player.Locomotor.enabled)
{
player.Locomotor.enabled = false;
}
if (player.ChaControl.visibleAll)
{
player.ChaControl.visibleAll = false;
}
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
}
else if (wasDead)
{
wasDead = false;
Map.Instance.Player.EnableEntity();
}
}
protected override void OnAwake(PlayerActor player)
{
MapUIContainer.SetActivePlayerChangeUI(true);
Singleton <Input> .Instance.ReserveState(Input.ValidType.UI);
Singleton <Input> .Instance.SetupState();
player.SetScheduledInteractionState(false);
player.ReleaseInteraction();
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
PlayerData playerData = Singleton <Game> .Instance.WorldData.PlayerData;
this._prevSex = playerData.Sex;
this._prevChaFileName = playerData.CharaFileName;
ObservableExtensions.Subscribe <Unit>(Observable.Take <Unit>((IObservable <M0>) this._onEndMenu, 1), (Action <M0>)(_ =>
{
if (this.CheckChange(player))
{
this.StartChange(player);
}
else
{
player.Controller.ChangeState("DeviceMenu");
}
}));
}
protected override void Start()
{
if (Object.op_Equality((Object)this._commandBasePoint, (Object)null))
{
this._commandBasePoint = ((Component)this).get_transform().FindLoop(Singleton <Resources> .Instance.DefinePack.MapDefines.CommandTargetName)?.get_transform() ?? ((Component)this).get_transform();
}
CommonDefine.CommonIconGroup icon = Singleton <Resources> .Instance.CommonDefine.Icon;
DefinePack.MapGroup mapDefines = Singleton <Resources> .Instance.DefinePack.MapDefines;
Sprite sprite;
Singleton <Resources> .Instance.itemIconTables.ActionIconTable.TryGetValue(Singleton <Resources> .Instance.CommonDefine.Icon.ShipIconID, out sprite);
Transform transform = ((Component)this).get_transform().FindLoop(mapDefines.ShipPointLabelTargetName)?.get_transform() ?? ((Component)this).get_transform();
this._labels = new CommandLabel.CommandInfo[1]
{
new CommandLabel.CommandInfo()
{
Text = "船",
Icon = sprite,
IsHold = true,
TargetSpriteInfo = icon.ActionSpriteInfo,
Transform = transform,
Condition = (Func <PlayerActor, bool>)null,
Event = (Action)(() =>
{
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
Singleton <Manager.Map> .Instance.Player.Controller.ChangeState("ShipMenu");
})
}
};
}
static public void OnGUI()
{
if (PlayerDeath.Value == DeathType.None ||
playerController == null ||
playerController["health"] > 0 ||
!MapUIContainer.IsInstance() ||
MapUIContainer.AnyUIActive())
{
return;
}
if (labelStyle == null)
{
labelStyle = new GUIStyle(GUI.skin.label)
{
fontSize = 14,
fontStyle = FontStyle.Bold,
alignment = TextAnchor.MiddleCenter
};
subLabelStyle = new GUIStyle(GUI.skin.label)
{
fontSize = 12,
alignment = TextAnchor.MiddleCenter
};
}
rect = GUI.Window(
WindowIDDead.Value,
rect,
Draw,
"",
GUI.skin.box
);
}
protected override void OnRelease(PlayerActor player)
{
IState state = player.PlayerController.State;
if (state is Normal || state is Onbu)
{
this._prevInteractionState = true;
this._prevValidType = Input.ValidType.Action;
this._prevAcceptionState = CommandLabel.AcceptionState.InvokeAcception;
}
if (this._prevInteractionState != player.CurrentInteractionState)
{
player.SetScheduledInteractionState(this._prevInteractionState);
player.ReleaseInteraction();
}
if (this._prevValidType != Singleton <Input> .Instance.State)
{
Singleton <Input> .Instance.ReserveState(this._prevValidType);
Singleton <Input> .Instance.SetupState();
}
if (this._prevAcceptionState == MapUIContainer.CommandLabel.Acception)
{
return;
}
MapUIContainer.SetCommandLabelAcception(this._prevAcceptionState);
}
private void ExitState()
{
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
ObservableExtensions.Subscribe <Unit>(Observable.Take <Unit>((IObservable <M0>)Observable.FromCoroutine((Func <IEnumerator>)(() =>
{
PlayerActor player = Singleton <Manager.Map> .Instance.Player;
return(player.Controller.State.End((Actor)player));
}), false), 1), (System.Action <M0>)(__ =>
{
PlayerActor player = Singleton <Manager.Map> .Instance.Player;
player.CameraControl.CrossFade.FadeStart(-1f);
player.PlayerController.ChangeState("Normal");
player.CameraControl.Mode = CameraMode.Normal;
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.InvokeAcception);
AgentActor agentPartner = player.AgentPartner;
agentPartner.ChangeBehavior(agentPartner.PrevMode);
agentPartner.Partner = (Actor)null;
agentPartner.IsSlave = false;
((Behaviour)agentPartner.NavMeshAgent).set_enabled(true);
Vector3 point = Vector3.op_Addition(player.Position, Vector3.op_Multiply(player.Back, 10f));
LayerMask hlayer = Singleton <Resources> .Instance.DefinePack.MapDefines.HLayer;
GameObject[] gameObjectsWithTag = GameObject.FindGameObjectsWithTag(Singleton <Resources> .Instance.DefinePack.MapDefines.OnbuMeshTag);
List <MeshCollider> toRelease = ListPool <MeshCollider> .Get();
foreach (GameObject gameObject in gameObjectsWithTag)
{
MeshCollider[] componentsInChildren = (MeshCollider[])gameObject.GetComponentsInChildren <MeshCollider>();
toRelease.AddRange((IEnumerable <MeshCollider>)componentsInChildren);
}
float num1 = float.PositiveInfinity;
Vector3 vector3_1 = Vector3.get_zero();
using (List <MeshCollider> .Enumerator enumerator = toRelease.GetEnumerator())
{
while (enumerator.MoveNext())
{
Vector3 vector3_2 = enumerator.Current.NearestVertexTo(point);
float num2 = Vector3.Distance(player.Position, vector3_2);
if ((double)num2 < (double)num1)
{
num1 = num2;
vector3_1 = vector3_2;
}
}
}
ListPool <MeshCollider> .Release(toRelease);
NavMeshHit navMeshHit;
if (NavMesh.SamplePosition(vector3_1, ref navMeshHit, 100f, -1))
{
vector3_1 = ((NavMeshHit) ref navMeshHit).get_position();
}
player.Partner.NavMeshAgent.Warp(vector3_1);
Vector3 vector3_3 = Vector3.op_Addition(vector3_1, Vector3.op_Multiply(player.Partner.Forward, 10f));
if (NavMesh.SamplePosition(vector3_3, ref navMeshHit, 100f, -1))
{
vector3_3 = ((NavMeshHit) ref navMeshHit).get_position();
}
player.NavMeshAgent.Warp(vector3_3);
player.Partner = (Actor)null;
agentPartner.IsVisible = true;
}));
}
protected override void OnAwake(PlayerActor player)
{
Singleton <Input> .Instance.ReserveState(Input.ValidType.UI);
Singleton <Input> .Instance.SetupState();
DateActionPointInfo outInfo;
player.CurrentPoint.TryGetPlayerDateActionPointInfo(player.ChaControl.sex, EventType.Lesbian, out outInfo);
player.HPoseID = outInfo.poseIDA;
MapUIContainer.RefreshCommands(0, player.SpecialHCommandInfo);
MapUIContainer.CommandList.CancelEvent = (Action)(() =>
{
Singleton <Resources> .Instance.SoundPack.Play(SoundPack.SystemSE.Cancel);
MapUIContainer.SetActiveCommandList(false);
player.Controller.ChangeState("Normal");
player.ReleaseCurrentPoint();
if (Object.op_Inequality((Object)player.PlayerController.CommandArea, (Object)null))
{
((Behaviour)player.PlayerController.CommandArea).set_enabled(true);
}
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.InvokeAcception);
player.ActivateNavMeshAgent();
player.IsKinematic = false;
});
MapUIContainer.SetActiveCommandList(true, "特殊エッチ");
}
private void Complete()
{
MapUIContainer.SetVisibleHUD(true);
PlayerActor player = Singleton <Manager.Map> .Instance.Player;
switch (player.Mode)
{
case Desire.ActionType.Normal:
case Desire.ActionType.Date:
player.CameraControl.Mode = CameraMode.Normal;
player.Controller.ChangeState("Normal");
player.CameraControl.OnCameraBlended = (System.Action)(() => Singleton <Manager.Map> .Instance.Player.ChaControl.visibleAll = player.CameraControl.ShotType != ShotType.PointOfView);
break;
}
this.Agent.Animation.ResetDefaultAnimatorController();
if (Object.op_Equality((Object)this._prevPartner, (Object)player))
{
this.Agent.CommandPartner = (Actor)null;
}
else
{
this.Agent.CommandPartner = this._prevPartner;
}
MapUIContainer.SetVisibleHUD(true);
}
protected override void OnAwake(PlayerActor player)
{
player.EventKey = EventType.Eat;
player.SetActiveOnEquipedItem(false);
player.ChaControl.setAllLayerWeight(0.0f);
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
Singleton <Input> .Instance.ReserveState(Input.ValidType.UI);
Singleton <Input> .Instance.SetupState();
MapUIContainer.RefreshCommands(0, player.ExitEatEventCommandInfo);
MapUIContainer.SetActiveCommandList(true, "食事");
MapUIContainer.CommandList.CancelEvent = (Action)null;
player.OldEnabledHoldingHand = ((Behaviour)player.HandsHolder).get_enabled();
if (!player.OldEnabledHoldingHand)
{
return;
}
((Behaviour)player.HandsHolder).set_enabled(false);
if (!player.HandsHolder.EnabledHolding)
{
return;
}
player.HandsHolder.EnabledHolding = false;
}
private void Close()
{
Time.set_timeScale(1f);
this.IsActiveControl = false;
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.InvokeAcception);
this.playSE.Play(SoundPack.SystemSE.Cancel);
}
protected override void OnAwake(PlayerActor player)
{
MapUIContainer.SetActiveCharaMigrationUI(true);
Singleton <Input> .Instance.ReserveState(Input.ValidType.UI);
Singleton <Input> .Instance.SetupState();
player.SetScheduledInteractionState(false);
player.ReleaseInteraction();
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
this._agentCharaFiles.Clear();
this._agentCharaMapIDs.Clear();
foreach (KeyValuePair <int, AgentData> keyValuePair in Singleton <Game> .Instance.WorldData.AgentTable)
{
this._agentCharaFiles[keyValuePair.Key] = keyValuePair.Value.CharaFileName;
this._agentCharaMapIDs[keyValuePair.Key] = keyValuePair.Value.MapID;
}
ObservableExtensions.Subscribe <Unit>(Observable.Take <Unit>((IObservable <M0>) this._onEndMenu, 1), (Action <M0>)(_ =>
{
if (this.CheckChange(player))
{
return;
}
player.Controller.ChangeState("DeviceMenu");
}));
}
protected override void OnAwake(PlayerActor player)
{
player.SetActiveOnEquipedItem(false);
player.ChaControl.setAllLayerWeight(0.0f);
Resources instance = Singleton <Resources> .Instance;
Sprite actionIcon;
instance.itemIconTables.ActionIconTable.TryGetValue(instance.PlayerProfile.CommonActionIconID, out actionIcon);
this.ChangeModeRelatedSleep(player);
ObservableExtensions.Subscribe <Unit>(Observable.Take <Unit>((IObservable <M0>)MapUIContainer.CommandList.OnCompletedStopAsObservable(), 1), (System.Action <M0>)(_ =>
{
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.CancelAcception);
MapUIContainer.CommandLabel.CancelCommand = new CommandLabel.CommandInfo()
{
Text = "もどる",
Icon = actionIcon,
TargetSpriteInfo = (CommandTargetSpriteInfo)null,
Transform = (Transform)null,
Event = (System.Action)(() =>
{
MapUIContainer.CommandLabel.CancelCommand = (CommandLabel.CommandInfo)null;
player.Controller.ChangeState("Sleep");
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
})
};
}));
}
protected override void OnAwake(PlayerActor player)
{
player.EventKey = (AIProject.EventType) 0;
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
ObservableExtensions.Subscribe <Unit>(Observable.Take <Unit>((IObservable <M0>) this._onEndFadeIn, 1), (System.Action <M0>)(_ =>
{
this.Refresh(player);
ObservableExtensions.Subscribe <long>((IObservable <M0>)Observable.Timer(TimeSpan.FromMilliseconds(100.0)), (System.Action <M0>)(__ =>
{
this._completeWait = true;
ObservableExtensions.Subscribe <Unit>((IObservable <M0>)MapUIContainer.StartFade(FadeCanvas.PanelType.Blackout, (global::FadeType)1, 1f, false), (System.Action <M0>)(___ => {}), (System.Action)(() => this._onEndFadeOut.OnNext(Unit.get_Default())));
}));
}));
ObservableExtensions.Subscribe <Unit>(Observable.Take <Unit>((IObservable <M0>) this._onEndFadeOut, 1), (System.Action <M0>)(_ => this.StartEventSeq(player)));
Singleton <Manager.Input> .Instance.ReserveState(Manager.Input.ValidType.UI);
Singleton <Manager.Input> .Instance.SetupState();
// ISSUE: cast to a reference type
// ISSUE: explicit reference operation
this._prevStyle = (CinemachineBlendDefinition.Style)(^ (CinemachineBlendDefinition&)ref player.CameraControl.CinemachineBrain.m_DefaultBlend).m_Style;
// ISSUE: cast to a reference type
// ISSUE: explicit reference operation
(^ (CinemachineBlendDefinition&)ref player.CameraControl.CinemachineBrain.m_DefaultBlend).m_Style = (__Null)0;
ObservableExtensions.Subscribe <Unit>((IObservable <M0>)MapUIContainer.StartFade(FadeCanvas.PanelType.Blackout, (global::FadeType)0, 1f, true), (System.Action <M0>)(_ => {}), (System.Action)(() => this._onEndFadeIn.OnNext(Unit.get_Default())));
}
protected override void Start()
{
if (DevicePointAnimData.AnimatorItemTable.TryGetValue(this._id, ref this._animator))
{
this._animator.set_runtimeAnimatorController(Singleton <Resources> .Instance.Animation.GetItemAnimator(Singleton <Resources> .Instance.CommonDefine.ItemAnims.PodAnimatorID));
}
if (Object.op_Equality((Object)this._commandBasePoint, (Object)null))
{
this._commandBasePoint = ((Component)this).get_transform().FindLoop(Singleton <Resources> .Instance.DefinePack.MapDefines.CommandTargetName)?.get_transform() ?? ((Component)this).get_transform();
}
if (Object.op_Equality((Object)this._pivotPoint, (Object)null))
{
this._pivotPoint = ((Component)this).get_transform().FindLoop(Singleton <Resources> .Instance.DefinePack.MapDefines.DevicePointPivotTargetName)?.get_transform() ?? ((Component)this).get_transform();
}
if (this._recoverPoints.IsNullOrEmpty <Transform>() || this._recoverPoints.Count < 4)
{
this._recoverPoints.Clear();
foreach (string recoveryTargetName in Singleton <Resources> .Instance.DefinePack.MapDefines.DevicePointRecoveryTargetNames)
{
GameObject loop = ((Component)this).get_transform().FindLoop(recoveryTargetName);
if (Object.op_Inequality((Object)loop, (Object)null))
{
this._recoverPoints.Add(loop.get_transform());
}
}
}
if (Object.op_Equality((Object)this._playerRecoverPoint, (Object)null))
{
this._playerRecoverPoint = ((Component)this).get_transform().FindLoop(Singleton <Resources> .Instance.DefinePack.MapDefines.DevicePointPlayerRecoveryTargetName)?.get_transform();
}
base.Start();
CommonDefine.CommonIconGroup icon = Singleton <Resources> .Instance.CommonDefine.Icon;
DefinePack.MapGroup mapDefines = Singleton <Resources> .Instance.DefinePack.MapDefines;
Sprite sprite;
Singleton <Resources> .Instance.itemIconTables.ActionIconTable.TryGetValue(Singleton <Resources> .Instance.CommonDefine.Icon.DeviceIconID, out sprite);
Transform transform = ((Component)this).get_transform().FindLoop(mapDefines.DevicePointLabelTargetName)?.get_transform() ?? ((Component)this).get_transform();
this._labels = new CommandLabel.CommandInfo[1]
{
new CommandLabel.CommandInfo()
{
Text = "データ端末",
Icon = sprite,
IsHold = true,
TargetSpriteInfo = icon.ActionSpriteInfo,
Transform = transform,
Condition = (Func <PlayerActor, bool>)null,
Event = (Action)(() =>
{
Singleton <Resources> .Instance.SoundPack.Play(SoundPack.SystemSE.BootDevice);
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
Singleton <Manager.Map> .Instance.Player.CurrentDevicePoint = this;
Singleton <Manager.Map> .Instance.Player.StashData();
Singleton <Manager.Map> .Instance.Player.Controller.ChangeState("DeviceMenu");
})
}
};
}
public override void Release(Actor actor, EventType type)
{
PlayerActor player = actor as PlayerActor;
this.OnRelease(player);
switch (this)
{
case Normal _:
case Houchi _:
case Onbu _:
label_4:
actor.ActivateNavMeshAgent();
actor.IsKinematic = false;
break;
default:
player.ReleaseCurrentPoint();
if (Object.op_Inequality((Object)player.PlayerController.CommandArea, (Object)null))
{
((Behaviour)player.PlayerController.CommandArea).set_enabled(true);
}
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.InvokeAcception);
goto label_4;
}
}
public virtual void OnStart()
{
Debug.Log((object)string.Format("開始するEvent = {0}", (object)this._eventID));
((Task)this).OnStart();
Singleton <MapUIContainer> .Instance.MinimapUI.ChangeCamera(false, false);
MapUIContainer.SetVisibleHUD(false);
PlayerActor player = Singleton <Manager.Map> .Instance.Player;
AgentActor agent = this.Agent;
this._prevPartner = agent.CommandPartner;
agent.CommandPartner = agent.TargetInSightActor;
agent.TargetInSightActor = (Actor)null;
agent.ChaControl.ChangeLookEyesTarget(1, ((Component)player.CameraControl.CameraComponent).get_transform(), 0.5f, 0.0f, 1f, 2f);
agent.ChaControl.ChangeLookEyesPtn(1);
agent.ChaControl.ChangeLookNeckPtn(3, 1f);
agent.ChaControl.ChangeLookNeckTarget(0, (Transform)null, 0.5f, 0.0f, 1f, 0.8f);
Singleton <Manager.Map> .Instance.Player.CameraControl.OnCameraBlended = (System.Action)(() => ObservableExtensions.Subscribe <long>(Observable.Take <long>(Observable.SkipWhile <long>(Observable.SkipWhile <long>((IObservable <M0>)Observable.EveryUpdate(), (Func <M0, bool>)(_ => agent.Animation.PlayingTurnAnimation)), (Func <M0, bool>)(_ => !Singleton <Manager.ADV> .IsInstance() || Singleton <Manager.ADV> .Instance.Captions.IsProcEndADV)), 1), (System.Action <M0>)(_ => this.OpenADV(player, agent))));
player.CommCompanion = (Actor)agent;
player.Controller.ChangeState("Communication");
agent.StopNavMeshAgent();
agent.ChangeStaticNavMeshAgentAvoidance();
PoseKeyPair poseKeyPair = Singleton <Resources> .Instance.AgentProfile.ADVIdleTable[agent.ChaControl.fileParam.personality];
PlayState playState = Singleton <Resources> .Instance.Animation.AgentActionAnimTable[poseKeyPair.postureID][poseKeyPair.poseID];
AssetBundleInfo assetBundleInfo = playState.MainStateInfo.AssetBundleInfo;
agent.ChangeAnimator((string)assetBundleInfo.assetbundle, (string)assetBundleInfo.asset);
agent.Animation.PlayTurnAnimation(player.Position, 1f, playState.MainStateInfo.InStateInfo, false);
agent.DisableBehavior();
Manager.ADV.ChangeADVCamera((Actor)agent);
MapUIContainer.SetVisibleHUD(false);
Singleton <Manager.ADV> .Instance.TargetCharacter = agent;
}
protected override void OnAwake(PlayerActor player)
{
player.SetActiveOnEquipedItem(false);
player.ChaControl.setAllLayerWeight(0.0f);
this.isEnd = false;
this.isWait = (Func <PlayerActor, bool>)null;
this.isNextEnabled = false;
if (this.disposable != null)
{
this.disposable.Clear();
}
this.disposable = new CompositeDisposable();
if (Object.op_Equality((Object)(this.hasAnimal = player.Animal), (Object)null))
{
this.isEnd = true;
this.ToErrorEnd(player);
}
else
{
this.animalName = this.hasAnimal.Name;
this.isCameraBlend = true;
this.getPercent = 30f;
if (this.hasAnimal is WildGround)
{
this.getPercent = (this.hasAnimal as WildGround).GetPercent;
}
this.getAnimalFlag = (double)Random.Range(0.0f, 100f) <= (double)this.getPercent;
if (this.getAnimalFlag && Singleton <Resources> .IsInstance() && Singleton <Manager.Map> .IsInstance())
{
List <StuffItem> itemList = Singleton <Manager.Map> .Instance.Player?.PlayerData?.ItemList;
if (itemList != null)
{
this.getIteminfo = this.hasAnimal.ItemInfo;
if (this.getIteminfo != null)
{
this.addItem = new StuffItem(this.getIteminfo.CategoryID, this.getIteminfo.ID, 1);
itemList.AddItem(this.addItem);
}
}
}
if (Singleton <Manager.Map> .IsInstance())
{
List <StuffItem> itemList = Singleton <Manager.Map> .Instance.Player?.PlayerData?.ItemList;
if (itemList != null && this.hasAnimal is WildGround)
{
ItemIDKeyPair getItemId = (this.hasAnimal as WildGround).GetItemID;
itemList.RemoveItem(new StuffItem(getItemId.categoryID, getItemId.itemID, 1));
}
}
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
if (this.hasAnimal.AnimalType == AnimalTypes.Cat || this.hasAnimal.AnimalType == AnimalTypes.Chicken)
{
this.Initialize(player);
}
else
{
this.ToErrorEnd(player);
}
}
}
private void SetActiveControl(bool isActive)
{
Input instance = Singleton <Input> .Instance;
IEnumerator coroutine;
if (isActive)
{
MapUIContainer.SetVisibleHUD(false);
instance.FocusLevel = 0;
instance.MenuElements = this.MenuUIList;
coroutine = this.DoOpen();
}
else
{
MapUIContainer.SetVisibleHUD(true);
instance.ClearMenuElements();
instance.FocusLevel = -1;
coroutine = this.DoClose();
}
if (this._fadeDisposable != null)
{
this._fadeDisposable.Dispose();
}
this._fadeDisposable = ObservableExtensions.Subscribe <Unit>((IObservable <M0>)Observable.FromCoroutine((Func <IEnumerator>)(() => coroutine), false), (Action <M0>)(_ => {}), (Action <Exception>)(ex => Debug.LogException(ex)));
}
protected override void OnAwake(PlayerActor player)
{
player.EventKey = EventType.StorageIn;
if (Object.op_Inequality((Object)player.CurrentPoint, (Object)null))
{
this._chestAnimation = (ChestAnimation)((Component)player.CurrentPoint).GetComponent <ChestAnimation>();
if (Object.op_Inequality((Object)this._chestAnimation, (Object)null))
{
this._chestAnimation.PlayInAnimation();
}
}
ObservableExtensions.Subscribe <Unit>(Observable.Take <Unit>((IObservable <M0>) this._onEndInAnimation, 1), (Action <M0>)(_ => MapUIContainer.SetActiveItemBoxUI(true)), (Action)(() => ObservableExtensions.Subscribe <Unit>(Observable.Take <Unit>((IObservable <M0>) this._onEndMenu, 1), (Action <M0>)(_ =>
{
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.InvokeAcception);
player.Controller.ChangeState("Normal");
}))));
Singleton <Input> .Instance.ReserveState(Input.ValidType.UI);
Singleton <Input> .Instance.SetupState();
ActorAnimInfo animInfo = player.Animation.AnimInfo;
animInfo.outEnableBlend = true;
animInfo.outBlendSec = 0.0f;
player.Animation.AnimInfo = animInfo;
}
protected void OpenInventory(int cnt, List <StuffItem> itemList)
{
MapUIContainer.ReserveSystemMenuMode(SystemMenuUI.MenuMode.InventoryEnter);
SystemMenuUI systemUI = MapUIContainer.SystemMenuUI;
InventoryUIController inventoryUI = systemUI.InventoryEnterUI;
inventoryUI.isConfirm = true;
inventoryUI.CountViewerVisible(true);
inventoryUI.itemList = (Func <List <StuffItem> >)(() => itemList);
inventoryUI.SetItemFilter(InventoryBase.ToFilter(this.GetArgToSplitLastTable(cnt)));
inventoryUI.OnSubmit = (Action <StuffItem>)(item =>
{
this.Item = item;
InventoryUIController inventoryUiController = inventoryUI;
if (inventoryUiController == null)
{
return;
}
inventoryUiController.OnClose();
});
inventoryUI.OnClose = (Action)(() =>
{
inventoryUI.OnSubmit = (Action <StuffItem>)null;
inventoryUI.IsActiveControl = false;
systemUI.IsActiveControl = false;
Singleton <Input> .Instance.FocusLevel = 0;
Singleton <Input> .Instance.ReserveState(Input.ValidType.UI);
this.isClose = true;
inventoryUI.OnClose = (Action)null;
});
MapUIContainer.SetActiveSystemMenuUI(true);
}
public static bool Condition()
{
if (!MapUIContainer.IsInstance())
{
return(false);
}
if (current != null && !current.IsActiveControl)
{
Manager.Input input = Manager.Input.Instance;
current = null;
input.ReserveState(Manager.Input.ValidType.Action);
input.SetupState();
Map.Instance.Player.Controller.ChangeState("Normal");
}
SystemMenuUI ui = MapUIContainer.SystemMenuUI;
if (!ui.IsActiveControl || !ui.HomeMenu.IsActiveControl)
{
return(false);
}
return(true);
}
public virtual TaskStatus OnUpdate()
{
if (this._storyID == 0)
{
MapUIContainer.OpenStorySupportUI(Popup.StorySupport.Type.ExamineAround);
}
return((TaskStatus)2);
}
private void Elapsed(PlayerActor player)
{
player.CurrentDevicePoint = (DevicePoint)null;
MapUIContainer.SetVisibleHUD(true);
MapUIContainer.StorySupportUI.Open();
player.PlayerController.CommandArea.UpdateCollision(player);
player.Controller.ChangeState("Normal");
}
protected override void OnAwake(PlayerActor player)
{
this.minimapUI = Singleton <MapUIContainer> .Instance.MinimapUI;
this.input = Singleton <Input> .Instance;
this.dt = 0.0f;
this.minimapUI.OpenAllMap(this.minimapUI.VisibleMode);
Singleton <MapUIContainer> .Instance.MinimapUI.VisibleMode = 1;
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
Singleton <Input> .Instance.ReserveState(Input.ValidType.UI);
Singleton <Input> .Instance.SetupState();
this.minimapUI.FromHomeMenu = false;
Singleton <MapUIContainer> .Instance.MinimapUI.WarpProc = (MiniMapControler.OnWarp)(x =>
{
Singleton <MapUIContainer> .Instance.MinimapUI.AllMapClosedAction = (Action)(() => {});
string prevStateName = player.PlayerController.PrevStateName;
Singleton <Manager.Map> .Instance.WarpToBasePoint(x, (Action)(() =>
{
if (prevStateName == "Onbu")
{
player.Controller.ChangeState("Onbu");
}
else
{
player.Controller.ChangeState("Normal");
}
player.Controller.ChangeState("Idle");
GC.Collect();
if (this.minimapUI.prevVisibleMode != 0 || !Manager.Config.GameData.MiniMap)
{
return;
}
this.minimapUI.OpenMiniMap();
}), (Action)(() =>
{
if (prevStateName == "Onbu")
{
player.Controller.ChangeState("Onbu");
}
else
{
player.Controller.ChangeState("Normal");
}
Singleton <Input> .Instance.ReserveState(Input.ValidType.Action);
Singleton <Input> .Instance.SetupState();
Singleton <Manager.Map> .Instance.Player.SetScheduledInteractionState(true);
Singleton <Manager.Map> .Instance.Player.ReleaseInteraction();
}));
Singleton <MapUIContainer> .Instance.MinimapUI.WarpProc = (MiniMapControler.OnWarp)null;
});
ActorAnimInfo animInfo = player.Animation.AnimInfo;
animInfo.outEnableBlend = true;
animInfo.outBlendSec = 0.0f;
player.Animation.AnimInfo = animInfo;
}
private void Refresh(PlayerActor player)
{
int id = player.CurrentDevicePoint.ID;
AgentData agentData = Singleton <Game> .Instance.WorldData.AgentTable[id];
MapUIContainer.SetVisibleHUD(false);
AgentActor agentActor = Singleton <Manager.Map> .Instance.AddAgent(id, agentData);
agentActor.DisableBehavior();
Actor.BehaviorSchedule schedule = agentActor.Schedule;
schedule.enabled = false;
agentActor.Schedule = schedule;
agentActor.TargetInSightActor = (Actor)null;
agentActor.DeactivateNavMeshAgent();
if (Object.op_Inequality((Object)agentActor.CurrentPoint, (Object)null))
{
agentActor.CurrentPoint.SetActiveMapItemObjs(true);
agentActor.CurrentPoint.ReleaseSlot((Actor)agentActor);
agentActor.CurrentPoint = (ActionPoint)null;
}
agentActor.TargetInSightActionPoint = (ActionPoint)null;
player.ChaControl.visibleAll = false;
Transform pivotPoint = player.CurrentDevicePoint.PivotPoint;
agentActor.Position = pivotPoint.get_position();
agentActor.Rotation = pivotPoint.get_rotation();
agentData.Position = player.CurrentDevicePoint.RecoverPoints[0].get_position();
agentData.Rotation = player.CurrentDevicePoint.RecoverPoints[0].get_rotation();
Animator animator = this._locator = player.CameraControl.EventCameraLocator;
((Component)animator).get_transform().set_position(pivotPoint.get_position());
((Component)animator).get_transform().set_rotation(pivotPoint.get_rotation());
CommonDefine commonDefine = Singleton <Resources> .Instance.CommonDefine;
RuntimeAnimatorController itemAnimator = Singleton <Resources> .Instance.Animation.GetItemAnimator(commonDefine.ItemAnims.AppearCameraAnimatorID);
animator.set_runtimeAnimatorController(itemAnimator);
((Component)animator).get_transform().set_position(pivotPoint.get_position());
((Component)animator).get_transform().set_rotation(pivotPoint.get_rotation());
animator.set_speed(0.0f);
animator.Play(commonDefine.AppearCameraInStates[agentActor.ChaControl.fileParam.personality][0]);
this._eventCamera = ((Component)player.CameraControl.EventCamera).get_transform();
((Component)this._eventCamera).get_transform().SetParent(player.CameraControl.EventCameraParent, false);
((Component)this._eventCamera).get_transform().set_localPosition(Vector3.get_zero());
((Component)this._eventCamera).get_transform().set_localRotation(Quaternion.Euler(0.0f, 180f, 0.0f));
player.SetActiveOnEquipedItem(false);
player.CameraControl.Mode = CameraMode.Event;
Transform playerRecoverPoint = player.CurrentDevicePoint.PlayerRecoverPoint;
if (Object.op_Inequality((Object)playerRecoverPoint, (Object)null))
{
player.NavMeshAgent.Warp(playerRecoverPoint.get_position());
player.Rotation = playerRecoverPoint.get_rotation();
}
this._agent = agentActor;
Resources.UnloadUnusedAssets();
GC.Collect();
}
internal static void LogError(Type source, string text)
{
string prefix = $"[{Name}]";
Debug.LogError($"{prefix}\n{text}");
if (NotifyCrash.Value && MapUIContainer.IsInstance())
{
MapUIContainer.AddNotify($"{prefix} '{source.Name}' crashed! Disabling then enabling will reload it.");
}
}
public void ChangeState(string target, ActionPoint point, Action onCompleted = null)
{
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
if (Object.op_Inequality((Object)this.CommandArea, (Object)null))
{
this.CommandArea.SequenceSetConsiderations((Action <ICommandable>)(x => this.CleanPoint(x, point)));
}
this._actor.CurrentPoint = point;
this.ChangeState(target);
(this._state as PlayerStateBase).OnCompleted = onCompleted;
}
protected override void OnAwake(PlayerActor player)
{
player.ChaControl.visibleAll = false;
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
player.SetScheduledInteractionState(false);
player.ReleaseInteraction();
if (!Object.op_Inequality((Object)player.CommCompanion, (Object)null))
{
return;
}
player.CommCompanion.Animation.BeginIgnoreExpression();
}
protected override void OnAwake(PlayerActor player)
{
MapUIContainer.SetActivePlayerLookEditUI(true);
Singleton <Input> .Instance.ReserveState(Input.ValidType.UI);
Singleton <Input> .Instance.SetupState();
player.SetScheduledInteractionState(false);
player.ReleaseInteraction();
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
ObservableExtensions.Subscribe <Unit>(Observable.Take <Unit>((IObservable <M0>) this._onEndMenu, 1), (Action <M0>)(_ => player.Controller.ChangeState("DeviceMenu")));
}
