private void UpdateVisibility()
{
var isCharacterMode = OWInput.IsInputMode(InputMode.Character);
var hand = HandsController.Behaviour.RightHand;
var isHandClose = !ModSettings.AutoHideToolbelt || (hand.position - transform.position).sqrMagnitude < _minHandDistance;
var shouldBeVisible = !ToolHelper.IsUsingAnyTool() && isCharacterMode && isHandClose;
if (!_visible && shouldBeVisible)
{
SetVisible(true);
}
if (_visible && !shouldBeVisible)
{
SetVisible(false);
}
}
private void OpenInfoPopup(string message, string okButtonText, string cancelButtonText)
{
TwoButtonInfoPopup.SetUpPopup(message, InputLibrary.menuConfirm, InputLibrary.cancel, new ScreenPrompt(okButtonText), new ScreenPrompt(cancelButtonText));
OWTime.Pause(OWTime.PauseType.Menu);
OWInput.ChangeInputMode(InputMode.Menu);
var pauseCommandListener = Locator.GetPauseCommandListener();
if (pauseCommandListener != null)
{
pauseCommandListener.AddPauseCommandLock();
_addedPauseLock = true;
}
TwoButtonInfoPopup.EnableMenu(true);
}
private static void PatchTurning(OWCamera ____playerCam, Transform ____transform)
{
var runSpeedX = _playerAnimator.GetFloat("RunSpeedX");
var runSpeedY = _playerAnimator.GetFloat("RunSpeedY");
var isStopped = runSpeedX + runSpeedY == 0;
var isControllerOriented = !isStopped && NomaiVR.Config.controllerOrientedMovement;
if ((OWInput.GetInputMode() != InputMode.Character))
{
return;
}
var rotationSource = isControllerOriented ? LaserPointer.Behaviour.LeftHandLaser : ____playerCam.transform;
var fromTo = Quaternion.FromToRotation(____transform.forward, Vector3.ProjectOnPlane(rotationSource.transform.forward, ____transform.up));
var magnitude = 0f;
if (!isControllerOriented)
{
var magnitudeUp = 1 - Vector3.ProjectOnPlane(rotationSource.transform.up, ____transform.up).magnitude;
var magnitudeForward = 1 - Vector3.ProjectOnPlane(rotationSource.transform.up, ____transform.right).magnitude;
magnitude = magnitudeUp + magnitudeForward;
if (magnitude < 0.3f)
{
return;
}
}
var targetRotation = fromTo * ____transform.rotation;
var inverseRotation = Quaternion.Inverse(fromTo) * _playArea.rotation;
if (isControllerOriented)
{
_playArea.rotation = inverseRotation;
____transform.rotation = targetRotation;
}
else
{
var maxDegreesDelta = magnitude * 3f;
_playArea.rotation = Quaternion.RotateTowards(_playArea.rotation, inverseRotation, maxDegreesDelta);
____transform.rotation = Quaternion.RotateTowards(____transform.rotation, targetRotation, maxDegreesDelta);
}
}
private static bool PreUpdateRumble(object[] ___m_theList, bool ___m_isEnabled)
{
if (OWTime.IsPaused())
{
return(false);
}
var a = Vector2.zero;
if (___m_isEnabled && OWInput.UsingGamepad())
{
var deltaTime = Time.deltaTime;
for (var i = 0; i < ___m_theList.Length; i++)
{
var rumble = ___m_theList[i];
var isAlive = (bool)rumble.GetType().GetMethod("IsAlive").Invoke(rumble, new object[] { });
if (isAlive)
{
rumble.Invoke("Update", deltaTime);
}
var isAliveAgain = (bool)rumble.GetType().GetMethod("IsAlive").Invoke(rumble, new object[] { });
if (isAliveAgain)
{
var power = (Vector2)rumble.GetType().GetMethod("GetPower").Invoke(rumble, new object[] { });
a += power;
}
}
a.x *= 1.42857146f;
a.y *= 1.42857146f;
var haptic = SteamVR_Actions.default_Haptic;
var frequency = 0.1f;
var amplitudeY = a.y * ModSettings.VibrationStrength;
var amplitudeX = a.x * ModSettings.VibrationStrength;
haptic.Execute(0, frequency, 10, amplitudeY, SteamVR_Input_Sources.RightHand);
haptic.Execute(0, frequency, 50, amplitudeX, SteamVR_Input_Sources.RightHand);
haptic.Execute(0, frequency, 10, amplitudeY, SteamVR_Input_Sources.LeftHand);
haptic.Execute(0, frequency, 50, amplitudeX, SteamVR_Input_Sources.LeftHand);
}
return(false);
}
private void UpdateGrab()
{
if (!OWInput.IsInputMode(InputMode.Character))
{
if (IsEquipped())
{
Unequip();
}
return;
}
if (ControllerInput.Behaviour.IsGripping && !IsEquipped() && Detector.isInside && _visible)
{
Equip();
}
if (!ControllerInput.Behaviour.IsGripping && IsEquipped())
{
Unequip();
}
}
public void UpdateObjectsFromStates()
{
if (OWInput.GetInputMode() == InputMode.None)
{
// ? why is this here lmao
return;
}
if (CameraBody == null)
{
return;
}
FlashLight?.UpdateState(FlashlightActive);
Translator?.ChangeEquipState(TranslatorEquipped);
ProbeLauncher?.ChangeEquipState(ProbeLauncherEquipped);
Signalscope?.ChangeEquipState(SignalscopeEquipped);
AnimationSync.SetSuitState(SuitedUp);
}
public static void DoubleAxisUpdatePost(
DoubleAxisCommand __instance,
ref Vector2 ____value,
List <KeyCode> ____posXKeyCodes,
List <KeyCode> ____negXKeyCodes,
List <KeyCode> ____posYKeyCodes,
List <KeyCode> ____negYKeyCodes
)
{
if (OWInput.UsingGamepad())
{
return;
}
foreach (var key in ____posXKeyCodes)
{
if (ModInputHandler.Instance.IsPressedAndIgnored(key))
{
____value.x = 0f;
}
}
foreach (var key in ____negXKeyCodes)
{
if (ModInputHandler.Instance.IsPressedAndIgnored(key))
{
____value.x = 0f;
}
}
foreach (var key in ____posYKeyCodes)
{
if (ModInputHandler.Instance.IsPressedAndIgnored(key))
{
____value.y = 0f;
}
}
foreach (var key in ____negYKeyCodes)
{
if (ModInputHandler.Instance.IsPressedAndIgnored(key))
{
____value.y = 0f;
}
}
}
public Texture2D KeyTexture(KeyCode key)
{
if (_loadedTextures == null)
{
FillTextureLibrary();
}
var keyName = ModInputLibrary.KeyCodeToString(key);
if (_loadedTextures.ContainsKey(keyName))
{
return(_loadedTextures[keyName]);
}
var config = OWInput.GetActivePadConfig() ?? InputUtil.GamePadConfig_Xbox;
var toStore = (int)key >= ModInputLibrary.MinGamepadKey ?
ButtonPromptLibrary.SharedInstance.GetButtonTexture(InputTranslator.ConvertKeyCodeToButton(key, config)) :
ButtonPromptLibrary.SharedInstance.GetButtonTexture(key);
_loadedTextures.Add(keyName, toStore);
return(toStore);
}
public void SwitchTo1stPerson()
{
if (!IsSetUp)
{
DebugLog.ToConsole("Warning - Camera not set up!", MessageType.Warning);
OWInput.ChangeInputMode(InputMode.Character);
Mode = CameraMode.FirstPerson;
return;
}
if (Mode == CameraMode.FirstPerson)
{
DebugLog.ToConsole("Warning - Already in 1st person!", MessageType.Warning);
return;
}
OWInput.ChangeInputMode(InputMode.Character);
QSBEventManager.FireEvent("SwitchActiveCamera", Locator.GetPlayerCamera());
Locator.GetActiveCamera().mainCamera.enabled = true;
_camera.enabled = false;
Mode = CameraMode.FirstPerson;
}
private void Update()
{
if (OWInput.IsInputMode(InputMode.ShipCockpit) && Input.GetKeyDown(KeyCode.L))
{
lowSpeedMode = !lowSpeedMode;
if (lowSpeedMode)
{
NotificationManager.SharedInstance.PostNotification(modeActive, true);
}
else
{
if (NotificationManager.SharedInstance.IsPinnedNotification(modeActive))
{
NotificationManager.SharedInstance.UnpinNotification(modeActive);
}
NotificationManager.SharedInstance.PostNotification(modeDeactivated);
}
}
}
private void UpdateLocal()
{
_serverTime += Time.unscaledDeltaTime;
if (_state == State.NotLoaded)
{
return;
}
if (_state == State.FastForwarding)
{
var diff = _serverTime - Time.timeSinceLevelLoad;
Time.timeScale = Mathf.Lerp(MinFastForwardSpeed, MaxFastForwardSpeed, Mathf.Abs(diff) / MaxFastForwardDiff);
if (QSBSceneManager.CurrentScene == OWScene.SolarSystem && _isFirstFastForward)
{
var spawnPoint = Locator.GetPlayerBody().GetComponent <PlayerSpawner>().GetInitialSpawnPoint().transform;
Locator.GetPlayerTransform().position = spawnPoint.position;
Locator.GetPlayerTransform().rotation = spawnPoint.rotation;
Physics.SyncTransforms();
}
}
else
{
Time.timeScale = _timeScale;
}
var isDoneFastForwarding = _state == State.FastForwarding && Time.timeSinceLevelLoad >= _serverTime;
var isDonePausing = _state == State.Pausing && Time.timeSinceLevelLoad < _serverTime;
if (isDoneFastForwarding || isDonePausing)
{
ResetTimeScale();
}
if (!_isInputEnabled && OWInput.GetInputMode() != InputMode.None)
{
DisableInput();
}
}
private void Update()
{
if (_currentDialogueBox != null && OWInput.GetInputMode() == InputMode.Dialogue)
{
if (OWInput.IsNewlyPressed(InputLibrary.interact) || OWInput.IsNewlyPressed(InputLibrary.cancel) || OWInput.IsNewlyPressed(InputLibrary.enter) || OWInput.IsNewlyPressed(InputLibrary.enter2))
{
if (!_currentDialogueBox.AreTextEffectsComplete())
{
_currentDialogueBox.FinishAllTextEffects();
return;
}
if (_currentDialogueBox.TimeCompletelyRevealed() < 0.1f)
{
return;
}
var selectedOption = _currentDialogueBox.GetSelectedOption();
if (!InputDialogueOption(selectedOption))
{
EndConversation();
return;
}
}
else
{
if (OWInput.IsNewlyPressed(InputLibrary.down) || OWInput.IsNewlyPressed(InputLibrary.down2))
{
_currentDialogueBox.OnDownPressed();
return;
}
if (OWInput.IsNewlyPressed(InputLibrary.up) || OWInput.IsNewlyPressed(InputLibrary.up2))
{
_currentDialogueBox.OnUpPressed();
}
}
}
}
public void Open(InputType inputType, string value)
{
_inputMenu.OnPopupConfirm += OnPopupConfirm;
_inputMenu.OnPopupCancel += OnPopupCancel;
if (inputType == InputType.Number)
{
_inputMenu.OnInputPopupValidateChar += OnValidateCharNumber;
_inputMenu.OnPopupValidate += OnValidateNumber;
}
var message = inputType == InputType.Number ? "Write a number" : "Write some text";
_inputMenu.EnableMenu(true);
var okPrompt = new ScreenPrompt(InputLibrary.confirm2, "OK");
var cancelCommand = OWInput.UsingGamepad() ? InputLibrary.cancel : InputLibrary.escape;
var cancelPrompt = new ScreenPrompt(cancelCommand, "Cancel");
_inputMenu.SetUpPopup(message, InputLibrary.confirm2, cancelCommand, okPrompt, cancelPrompt);
_inputMenu.SetInputFieldPlaceholderText("");
_inputMenu.GetInputField().text = value;
_inputMenu.GetValue <Text>("_labelText").text = message;
}
private void OnInteractChange(SteamVR_Action_Boolean fromAction, SteamVR_Input_Sources fromSource, bool newState)
{
var value = newState ? 1 : 0;
if (!SceneHelper.IsInGame())
{
_buttons[JoystickButton.FaceLeft] = value;
return;
}
var button = IsGripping ? JoystickButton.RightBumper : JoystickButton.FaceLeft;
var isRepairPromptVisible = _repairPrompt != null && _repairPrompt.IsVisible();
var canRepairSuit = _playerResources.IsSuitPunctured() && OWInput.IsInputMode(InputMode.Character) && !ToolHelper.Swapper.IsSuitPatchingBlocked();
var isUsingTranslator = ToolHelper.Swapper.IsInToolMode(ToolMode.Translator);
if (!isRepairPromptVisible && !canRepairSuit && !isUsingTranslator)
{
if (newState)
{
_primaryLastTime = fromAction.changedTime;
}
else
{
_primaryLastTime = -1;
if (!_justHeld)
{
SimulateInput(button);
}
_justHeld = false;
}
}
else
{
_buttons[button] = value;
}
}
internal void FillTextureLibrary()
{
_loadedTextures = new Dictionary <string, Texture2D>();
var config = OWInput.GetActivePadConfig() ?? InputUtil.GamePadConfig_Xbox;
for (var code = ModInputLibrary.MinUsefulKey; code < ModInputLibrary.MaxUsefulKey; code++)
{
var key = (KeyCode)code;
if (!Enum.IsDefined(typeof(KeyCode), key))
{
continue;
}
var keyName = ModInputLibrary.KeyCodeToString(key);
if (_loadedTextures.ContainsKey(keyName))
{
continue;
}
var button = InputTranslator.ConvertKeyCodeToButton(key, config);
var toStore = (int)key >= ModInputLibrary.MinGamepadKey ?
ButtonPromptLibrary.SharedInstance.GetButtonTexture(button) :
ButtonPromptLibrary.SharedInstance.GetButtonTexture(key);
_loadedTextures.Add(keyName, toStore);
}
}
private void InstantWakeUp()
{
_isSolarSystemLoaded = false;
// Skip wake up animation.
var cameraEffectController = FindObjectOfType <PlayerCameraEffectController>();
cameraEffectController.OpenEyes(0, true);
cameraEffectController.SetValue("_wakeLength", 0f);
cameraEffectController.SetValue("_waitForWakeInput", false);
// Skip wake up prompt.
LateInitializerManager.pauseOnInitialization = false;
Locator.GetPauseCommandListener().RemovePauseCommandLock();
Locator.GetPromptManager().RemoveScreenPrompt(cameraEffectController.GetValue <ScreenPrompt>("_wakePrompt"));
OWTime.Unpause(OWTime.PauseType.Sleeping);
cameraEffectController.Invoke("WakeUp");
// Enable all inputs immedeately.
OWInput.ChangeInputMode(InputMode.Character);
typeof(OWInput).SetValue("_inputFadeFraction", 0f);
GlobalMessenger.FireEvent("TakeFirstFlashbackSnapshot");
Locator.GetPlayerSuit().SuitUp();
}
void Update()
{
if (Input.GetKeyDown(KeyCode.CapsLock) || OWInput.GetAxisPressed(PlayerCameraInput.toggleFlashlight, -1))
{
if (!IsFreeCamEnable())
{
if (isThereAPlayer)
{
debugger.SendLog("Congelando o mov. do player", DebugType.LOG, LogingType.SEND_AND_LOG);
playerTransform.gameObject.GetComponent <CharacterMovementModel>().LockMovement();
GlobalMessenger <Camera> .FireEvent("SwitchActiveCamera", gameObject.camera);
playerCamController.LockOn(playerLockingViewOn.transform);
}
debugger.SendLog("Coisas Magicas", DebugType.UNKNOWN, LogingType.SEND_AND_LOG);
currentCameraTransform.camera.enabled = false;
gameObject.camera.enabled = true;
}
else
{
if (!((SettingsMenu)FindObjectsOfType(typeof(SettingsMenu))[0]).enabled || Application.loadedLevel == 0)
{
Time.timeScale = 1f;
}
if (isThereAPlayer)
{
debugger.SendLog("Descongelando o mov. do player", DebugType.LOG, LogingType.SEND_AND_LOG);
playerTransform.gameObject.GetComponent <CharacterMovementModel>().UnlockMovement();
GlobalMessenger <Camera> .FireEvent("SwitchActiveCamera", currentCameraTransform.camera);
playerCamController.BreakLock();
}
debugger.SendLog("Mais coisas magicas", DebugType.UNKNOWN, LogingType.SEND_AND_LOG);
currentCameraTransform.camera.enabled = true;
gameObject.camera.enabled = false;
gameObject.transform.position = currentCameraTransform.position;
freeCamPosition = Vector3.zero;
freeCamRotationAround = 0f;
freeCamRotationX = 0f;
}
}
if (IsFreeCamEnable())
{
if (Input.GetKeyDown(KeyCode.Z) || Input.GetKeyDown(KeyCode.JoystickButton8))
{
if (Time.timeScale != 0) //Se o timeScale já não é zero, fazer ele virar zero
{
Time.timeScale = 0f;
}//Se estamos no menu, não tem que se preocupar em voltar ao normal, mas se estamos no Solar System, vereficar se o settings menu ta aberto
else if (!((SettingsMenu)FindObjectsOfType(typeof(SettingsMenu))[0]).enabled || Application.loadedLevel == 0)
{
Time.timeScale = 1f;
}
}
//Cuidar da aceleração e veloc. da camera
if (Input.GetKey(KeyCode.Tab))
{
cameraSpeed = 9f;
}
else
{
cameraSpeed = 3f;
}
//Direção q a camera vai virar
if (Time.timeScale != 0)
{
freeCamRotationAround += PlayerCameraInput.lookX.GetInput() * Time.deltaTime * 500f % 360;
freeCamRotationX -= PlayerCameraInput.lookY.GetInput() * Time.deltaTime * 500f;
}
else
{
freeCamRotationAround += PlayerCameraInput.lookX.GetInput() * DeltaTimeWhenFreezed() * 500f % 360;
freeCamRotationX -= PlayerCameraInput.lookY.GetInput() * DeltaTimeWhenFreezed() * 500f;
}
freeCamRotationX = Mathf.Clamp(freeCamRotationX, -90f, 90f);
if (rotateWithTheCamera)
{
gameObject.transform.rotation = currentCameraTransform.rotation;
}
else
{
gameObject.transform.eulerAngles = Vector3.zero;
}
gameObject.transform.rotation = gameObject.transform.rotation * Quaternion.Euler(freeCamRotationAround * playerLockingViewOn.transform.up) * Quaternion.Euler(freeCamRotationX, 0f, 0f);
//Direção q a camera vai andar
gameObject.transform.position = currentCameraTransform.position;
float variacaoDoTempo;
if (Time.timeScale != 0)
{
variacaoDoTempo = Time.deltaTime;
}
else
{
variacaoDoTempo = DeltaTimeWhenFreezed();
if (Input.GetKey(KeyCode.W))
{
freeCamPosition += gameObject.transform.forward * cameraSpeed * variacaoDoTempo;
}
if (Input.GetKey(KeyCode.S))
{
freeCamPosition += -gameObject.transform.forward * cameraSpeed * variacaoDoTempo;
}
if (Input.GetKey(KeyCode.D))
{
freeCamPosition += gameObject.transform.right * cameraSpeed * variacaoDoTempo;
}
if (Input.GetKey(KeyCode.A))
{
freeCamPosition += -gameObject.transform.right * cameraSpeed * variacaoDoTempo;
}
}
freeCamPosition += (gameObject.transform.forward * InputChannels.moveZ.GetAxis() + gameObject.transform.right * InputChannels.moveX.GetAxis()) * 9 * variacaoDoTempo;
gameObject.transform.position += freeCamPosition;
//Fazer com q isso sempre esteja uma unidade afrente da camera principal
playerLockingViewOn.transform.position = currentCameraTransform.position + currentCameraTransform.forward;
//Ver qual foi o tempo desse frame
timeWhenFreezed = Time.realtimeSinceStartup;
}
}
private static bool IsSelectNewlyPressed()
{
return(OWInput.IsNewlyPressed(InputLibrary.menuConfirm));
}
public static bool RoastingStickController_UpdateMarshmallowInput(
float ____extendFraction,
Marshmallow ____marshmallow,
GameObject ____mallowBodyPrefab,
Transform ____stickTransform,
Campfire ____campfire,
ref string ____promptText,
ScreenPrompt ____mallowPrompt,
ref bool ____showMallowPrompt,
ref bool ____showRemovePrompt)
{
var changePromptText = false;
var showRemovePrompt = false;
var text = string.Empty;
if (____extendFraction == 0f)
{
if (____marshmallow.IsEdible())
{
text = UITextLibrary.GetString(UITextType.RoastingEatPrompt);
changePromptText = true;
if (____marshmallow.IsBurned())
{
showRemovePrompt = true;
if (OWInput.IsNewlyPressed(InputLibrary.cancel, true, InputMode.Roasting))
{
____marshmallow.Remove();
Locator.GetPlayerAudioController().PlayMarshmallowToss();
var spawnedMarshmallow = UnityEngine.Object.Instantiate <GameObject>(____mallowBodyPrefab, ____stickTransform.position, ____stickTransform.rotation);
var rigidbody = spawnedMarshmallow.GetComponent <OWRigidbody>();
rigidbody.SetVelocity(____campfire.GetAttachedOWRigidbody(false).GetPointVelocity(____stickTransform.position) + (____stickTransform.forward * 3f));
rigidbody.SetAngularVelocity(____stickTransform.right * 10f);
var burntColor = ____marshmallow.GetBurntColor();
spawnedMarshmallow.GetComponentInChildren <MeshRenderer>().material.color = burntColor;
QSBEventManager.FireEvent(EventNames.QSBMarshmallowEvent, MarshmallowEventType.Toss);
}
}
if (OWInput.IsNewlyPressed(InputLibrary.interact, InputMode.Roasting) && ____marshmallow.IsEdible())
{
____marshmallow.Eat();
}
}
else if (____marshmallow.GetState() == Marshmallow.MallowState.Burning)
{
text = UITextLibrary.GetString(UITextType.RoastingExtinguishPrompt);
changePromptText = true;
if (OWInput.IsNewlyPressed(InputLibrary.interact, InputMode.Roasting))
{
____marshmallow.Extinguish();
QSBEventManager.FireEvent(EventNames.QSBMarshmallowEvent, MarshmallowEventType.Extinguish);
}
}
else if (____marshmallow.GetState() == Marshmallow.MallowState.Gone)
{
text = UITextLibrary.GetString(UITextType.RoastingReplacePrompt);
changePromptText = true;
if (OWInput.IsNewlyPressed(InputLibrary.interact, InputMode.Roasting))
{
____marshmallow.SpawnMallow(true);
}
}
if (changePromptText && ____promptText != text)
{
____promptText = text;
____mallowPrompt.SetText(____promptText);
}
if (OWInput.IsNewlyPressed(InputLibrary.cancel, InputMode.Roasting))
{
____campfire.StopRoasting();
return(false);
}
}
____showMallowPrompt = changePromptText;
____showRemovePrompt = showRemovePrompt;
return(false);
}
public static bool MapController_LateUpdate(
MapController __instance
)
{
__instance._lockTimer = Mathf.Min(__instance._lockTimer + Time.deltaTime, __instance._lockOnMoveLength);
__instance._revealTimer = Mathf.Min(__instance._revealTimer + Time.deltaTime, __instance._revealLength);
var revealFraction = Mathf.Clamp01(__instance._revealTimer / __instance._revealLength);
var smoothedRevealFraction = Mathf.SmoothStep(0f, 1f, revealFraction);
var canInteractWith = __instance._revealTimer > 18f;
if (__instance._screenPromptsVisible && __instance._isPaused)
{
__instance._closePrompt.SetVisibility(false);
__instance._panPrompt.SetVisibility(false);
__instance._rotatePrompt.SetVisibility(false);
__instance._zoomPrompt.SetVisibility(false);
__instance._screenPromptsVisible = false;
}
else if (!__instance._screenPromptsVisible && canInteractWith && !__instance._isPaused)
{
__instance._closePrompt.SetVisibility(false);
__instance._panPrompt.SetVisibility(true);
__instance._rotatePrompt.SetVisibility(true);
__instance._zoomPrompt.SetVisibility(true);
__instance._screenPromptsVisible = true;
}
var XZinput = Vector2.zero;
var lookInput = Vector2.zero;
var zoomInput = 0f;
if (canInteractWith)
{
XZinput = OWInput.GetAxisValue(InputLibrary.moveXZ);
lookInput = InputLibrary.look.GetAxisValue(false);
zoomInput = OWInput.GetValue(InputLibrary.mapZoomIn) - OWInput.GetValue(InputLibrary.mapZoomOut);
lookInput.y *= -1f;
zoomInput *= -1f;
}
__instance._lockedToTargetTransform &= XZinput.sqrMagnitude < 0.01f;
__instance._interpPosition &= XZinput.sqrMagnitude < 0.01f;
__instance._interpPitch &= Mathf.Abs(lookInput.y) < 0.1f;
__instance._interpZoom &= Mathf.Abs(zoomInput) < 0.1f;
if (__instance._interpPosition)
{
var a = __instance._activeCam.transform.position - Locator.GetCenterOfTheUniverse().GetOffsetPosition();
var b = Vector3.zero;
__instance._position = Vector3.Lerp(a, b, smoothedRevealFraction);
}
else
{
var normalized = Vector3.Scale(__instance.transform.forward + __instance.transform.up, new Vector3(1f, 0f, 1f)).normalized;
var a2 = (__instance.transform.right * XZinput.x) + (normalized * XZinput.y);
__instance._position += a2 * __instance._panSpeed * __instance._zoom * Time.deltaTime;
__instance._position.y = 0f;
if (__instance._position.sqrMagnitude > __instance._maxPanDistance * __instance._maxPanDistance)
{
__instance._position = __instance._position.normalized * __instance._maxPanDistance;
}
}
__instance._yaw += lookInput.x * __instance._yawSpeed * Time.deltaTime;
__instance._yaw = OWMath.WrapAngle(__instance._yaw);
if (__instance._interpPitch)
{
__instance._pitch = Mathf.Lerp(__instance._initialPitchAngle, __instance._defaultPitchAngle, smoothedRevealFraction);
}
else
{
__instance._pitch += lookInput.y * __instance._pitchSpeed * Time.deltaTime;
__instance._pitch = Mathf.Clamp(__instance._pitch, __instance._minPitchAngle, __instance._maxPitchAngle);
}
if (__instance._interpZoom)
{
__instance._zoom = Mathf.Lerp(__instance._initialZoomDist, __instance._targetZoom, smoothedRevealFraction);
}
else
{
__instance._zoom += zoomInput * __instance._zoomSpeed * Time.deltaTime;
__instance._zoom = Mathf.Clamp(__instance._zoom, __instance._minZoomDistance, __instance._maxZoomDistance);
}
__instance._mapCamera.nearClipPlane = Mathf.Lerp(0.1f, 1f, smoothedRevealFraction);
var finalRotation = Quaternion.Euler(__instance._pitch, __instance._yaw, 0f);
var num4 = revealFraction * (2f - revealFraction);
var num5 = Mathf.SmoothStep(0f, 1f, num4);
// Create rotation that's looking down at the player from above
var lookingDownAtPlayer = Quaternion.LookRotation(-RespawnOnDeath.Instance.DeathPlayerUpVector, Vector3.up);
// Get starting position - distance above player
var startingPosition = RespawnOnDeath.Instance.DeathPositionWorld;
startingPosition += RespawnOnDeath.Instance.DeathPlayerUpVector * num5 * __instance._observatoryRevealDist;
// Lerp to final rotation
__instance.transform.rotation = Quaternion.Lerp(lookingDownAtPlayer, finalRotation, num5);
// Lerp reveal twist
__instance.transform.rotation *= Quaternion.AngleAxis(Mathf.Lerp(__instance._observatoryRevealTwist, 0f, num4), Vector3.forward);
var endPosition = __instance._position + (-__instance.transform.forward * __instance._zoom) + Locator.GetCenterOfTheUniverse().GetStaticReferenceFrame().GetPosition();
// Lerp to final position
__instance.transform.position = Vector3.Lerp(startingPosition, endPosition, num5);
return(false);
}
private void DisableInput()
{
_isInputEnabled = false;
OWInput.ChangeInputMode(InputMode.None);
}
void Update()
{
if (inputEnabled)
{
if (Input.GetKeyDown(KeyCode.UpArrow))
{
SetupCamera();
}
if (Input.GetKeyDown(KeyCode.LeftArrow))
{
if (Locator.GetPlayerSuit().IsWearingHelmet())
{
Locator.GetPlayerSuit().RemoveHelmet();
}
else
{
Locator.GetPlayerSuit().PutOnHelmet();
}
}
if (Input.GetKeyDown(KeyCode.KeypadDivide))
{
Time.timeScale = 0f;
}
if (Input.GetKeyDown(KeyCode.KeypadMultiply))
{
Time.timeScale = 0.5f;
}
if (Input.GetKeyDown(KeyCode.KeypadMinus))
{
Time.timeScale = 1f;
}
if (Input.GetKeyDown(KeyCode.Keypad0))
{
_freeCam.transform.parent = Locator.GetPlayerTransform();
}
if (Input.GetKeyDown(KeyCode.Keypad1))
{
_freeCam.transform.parent = Locator.GetSunTransform();
}
if (Input.GetKeyDown(KeyCode.Keypad2))
{
_freeCam.transform.parent = Locator.GetAstroObject(AstroObject.Name.Comet).gameObject.transform;
}
if (Input.GetKeyDown(KeyCode.Keypad3))
{
_freeCam.transform.parent = Locator.GetAstroObject(AstroObject.Name.CaveTwin).gameObject.transform;
}
if (Input.GetKeyDown(KeyCode.Keypad4))
{
_freeCam.transform.parent = Locator.GetAstroObject(AstroObject.Name.TowerTwin).gameObject.transform;
}
if (Input.GetKeyDown(KeyCode.Keypad5))
{
_freeCam.transform.parent = Locator.GetAstroObject(AstroObject.Name.TimberHearth).gameObject.transform;
}
if (Input.GetKeyDown(KeyCode.Keypad6))
{
_freeCam.transform.parent = Locator.GetAstroObject(AstroObject.Name.BrittleHollow).gameObject.transform;
}
if (Input.GetKeyDown(KeyCode.Keypad7))
{
_freeCam.transform.parent = Locator.GetAstroObject(AstroObject.Name.GiantsDeep).gameObject.transform;
}
if (Input.GetKeyDown(KeyCode.Keypad8))
{
_freeCam.transform.parent = Locator.GetAstroObject(AstroObject.Name.DarkBramble).gameObject.transform;
}
if (Input.GetKeyDown(KeyCode.Keypad9))
{
_freeCam.transform.position = Locator.GetPlayerTransform().position;
}
if (Input.GetKeyDown(KeyCode.KeypadPlus))
{
_moveSpeed = 7f;
}
if (Input.GetKeyDown(KeyCode.KeypadEnter))
{
_moveSpeed = 1000f;
}
if (Input.GetKeyDown(KeyCode.KeypadPeriod))
{
if (mode)
{
mode = false;
if (_storedMode == InputMode.None)
{
_storedMode = InputMode.Character;
}
OWInput.ChangeInputMode(_storedMode);
GlobalMessenger <OWCamera> .FireEvent("SwitchActiveCamera", Locator.GetPlayerCamera());
_camera.enabled = false;
Locator.GetActiveCamera().mainCamera.enabled = true;
}
else
{
mode = true;
_storedMode = OWInput.GetInputMode();
OWInput.ChangeInputMode(InputMode.None);
GlobalMessenger <OWCamera> .FireEvent("SwitchActiveCamera", _OWCamera);
Locator.GetActiveCamera().mainCamera.enabled = false;
_camera.enabled = true;
}
}
}
}
void Update()
{
if (OWInput.GetInputMode() == InputMode.None)
{
this._degreesY = OWInput.GetValue(InputLibrary.look, InputMode.All).y * 2f;
this._degreesX = OWInput.GetValue(InputLibrary.look, InputMode.All).x * 2f;
MainClass._camera.transform.Rotate(Vector3.up, _degreesX);
MainClass._camera.transform.Rotate(Vector3.right, -_degreesY);
if (Input.GetKey(KeyCode.LeftShift))
{
if (MainClass._moveSpeed == 7f)
{
MainClass._moveSpeed = 14f;
}
if (MainClass._moveSpeed == 1000f)
{
MainClass._moveSpeed = 2000;
}
}
else
{
if (MainClass._moveSpeed == 14f)
{
MainClass._moveSpeed = 7f;
}
if (MainClass._moveSpeed == 2000f)
{
MainClass._moveSpeed = 1000;
}
}
if (Input.GetKey(KeyCode.W))
{
MainClass._freeCam.transform.position += MainClass._freeCam.transform.forward * 0.02f * MainClass._moveSpeed;
}
if (Input.GetKey(KeyCode.S))
{
MainClass._freeCam.transform.position -= MainClass._freeCam.transform.forward * 0.02f * MainClass._moveSpeed;
}
if (Input.GetKey(KeyCode.A))
{
MainClass._freeCam.transform.position -= MainClass._freeCam.transform.right * 0.02f * MainClass._moveSpeed;
}
if (Input.GetKey(KeyCode.D))
{
MainClass._freeCam.transform.position += MainClass._freeCam.transform.right * 0.02f * MainClass._moveSpeed;
}
if (Input.GetKey(KeyCode.Q))
{
MainClass._freeCam.transform.Rotate(Vector3.forward, 1);
}
if (Input.GetKey(KeyCode.E))
{
MainClass._freeCam.transform.Rotate(Vector3.forward, -1);
}
}
}
private void OnGUI()
{
if (_playerController == null || _playerForceDetector == null)
{
this._playerForceDetector = Locator.GetPlayerForceDetector();
this._playerController = Locator.GetPlayerController();
if (_playerController == null || _playerForceDetector == null)
{
return;
}
}
float num = 400f;
if (GUIMode.IsHiddenMode() || PlayerState.UsingShipComputer())
{
return;
}
if (inputHUD == 1)
{
GUI.Label(new Rect(10f + num, 10f, 200f, 20f), "Time Scale: " + Mathf.Round(Time.timeScale * 100f) / 100f);
GUI.Label(new Rect(10f + num, 25f, 200f, 20f), string.Concat(new object[]
{
"Time Remaining: ",
Mathf.Floor(TimeLoop.GetSecondsRemaining() / 60f),
":",
Mathf.Round(TimeLoop.GetSecondsRemaining() % 60f * 100f / 100f)
}));
GUI.Label(new Rect(10f + num, 40f, 200f, 20f), "Loop Count: " + TimeLoop.GetLoopCount());
GUI.Label(new Rect(10f + num, 55f, 90f, 40f), "PauseFlags: ");
GUI.Label(new Rect(100f + num, 55f, 50f, 40f), "MENU\n" + ((!OWTime.IsPaused(OWTime.PauseType.Menu)) ? "FALSE" : "TRUE "));
GUI.Label(new Rect(150f + num, 55f, 50f, 40f), "LOAD\n" + ((!OWTime.IsPaused(OWTime.PauseType.Loading)) ? "FALSE" : "TRUE "));
GUI.Label(new Rect(200f + num, 55f, 50f, 40f), "READ\n" + ((!OWTime.IsPaused(OWTime.PauseType.Reading)) ? "FALSE" : "TRUE "));
GUI.Label(new Rect(250f + num, 55f, 50f, 40f), "SLP\n" + ((!OWTime.IsPaused(OWTime.PauseType.Sleeping)) ? "FALSE" : "TRUE "));
GUI.Label(new Rect(300f + num, 55f, 50f, 40f), "INIT\n" + ((!OWTime.IsPaused(OWTime.PauseType.Initializing)) ? "FALSE" : "TRUE "));
GUI.Label(new Rect(350f + num, 55f, 50f, 40f), "STRM\n" + ((!OWTime.IsPaused(OWTime.PauseType.Streaming)) ? "FALSE" : "TRUE "));
GUI.Label(new Rect(400f + num, 55f, 50f, 40f), "SYS\n" + ((!OWTime.IsPaused(OWTime.PauseType.System)) ? "FALSE" : "TRUE "));
GUI.Label(new Rect(10f + num, 85f, 200f, 20f), "Input Mode: " + OWInput.GetInputMode().ToString());
this._inputModeArray = OWInput.GetInputModeStack();
GUI.Label(new Rect(10f + num, 100f, 200f, 20f), "Input Mode Stack: ");
int num2 = 150;
int num3 = 0;
while (num3 < this._inputModeArray.Length && this._inputModeArray[num3] != InputMode.None)
{
GUI.Label(new Rect((float)num2 + num, 100f, 200f, 20f), this._inputModeArray[num3].ToString());
num2 += 75;
num3++;
}
GUI.Label(new Rect(10f + num, 115f, 300f, 20f), "Net Force Accel: " + Mathf.Round(this._playerForceDetector.GetForceAcceleration().magnitude * 100f) / 100f);
GUI.Label(new Rect(210f + num, 115f, 300f, 20f), "G-Force: " + Mathf.Round(this._gForce * 100f) / 100f);
GUI.Label(new Rect(10f + num, 130f, 200f, 20f), "Load Time: " + LoadTimeTracker.GetLatestLoadTime());
if (DynamicResolutionManager.isEnabled)
{
GUI.Label(new Rect(10f + num, 145f, 200f, 20f), "Resolution Scale: " + DynamicResolutionManager.currentResolutionScale);
}
GUI.Label(new Rect(10f + num, 160f, 200f, 20f), "Player Speed: " + (Locator.GetCenterOfTheUniverse().GetOffsetVelocity() + Locator.GetPlayerBody().GetVelocity()).magnitude.ToString());
GUI.Label(new Rect(210f + num, 160f, 200f, 20f), "Player Accel: " + Locator.GetPlayerBody().GetAcceleration().magnitude.ToString());
if (Locator.GetPlayerSuit().GetComponent <JetpackThrusterModel>())
{
GUI.Label(new Rect(10f + num, 175f, 200f, 20f), string.Concat(new object[]
{
"Jetpack Max Accel: ",
Locator.GetPlayerSuit().GetComponent <JetpackThrusterModel>().GetMaxTranslationalThrust().ToString(),
"/",
Locator.GetPlayerSuit().GetComponent <JetpackThrusterModel>().GetBoostMaxThrust().ToString()
}));
}
if (Locator.GetShipBody().GetComponent <ShipThrusterModel>())
{
GUI.Label(new Rect(210f + num, 175f, 200f, 20f), "Ship Max Accel: " + Locator.GetShipBody().GetComponent <ShipThrusterModel>().GetMaxTranslationalThrust().ToString());
}
GUI.Label(new Rect(10f + num, 190f, 400f, 20f), string.Concat(new object[]
{
"Inspector layer: ",
rayMask,
" ",
LayerMask.LayerToName(rayMask)
}));
if (GetWarpOWRigidbody())
{
GUI.Label(new Rect(10f + num, 205f, 400f, 20f), string.Concat(new string[]
{
"Warp Body: ",
GetWarpOWRigidbody().gameObject.name,
" layer: ",
GetWarpOWRigidbody().gameObject.layer.ToString(),
" ",
LayerMask.LayerToName(GetWarpOWRigidbody().gameObject.layer)
}));
}
if (hit.collider)
{
GUI.Label(new Rect(10f + num, 220f, 400f, 20f), string.Concat(new string[]
{
"Latest hit layer: ",
hit.collider.gameObject.layer.ToString(),
" ",
LayerMask.LayerToName(hit.collider.gameObject.layer)
}));
GUI.Label(new Rect(10f + num, 235f, 600f, 20f), "Name: " + hit.collider.gameObject.name + " Distance: " + (hit.point - Locator.GetPlayerBody().transform.position).magnitude.ToString());
}
/*if (PadEZ.PadManager.GetActiveController()!=null)
* {
* GUI.Label(new Rect(10f + num, 250f, 600f, 20f), PadEZ.PadManager.GetActiveController().GetIndex().ToString() + " " + PadEZ.PadManager.GetActiveController().GetPadType().ToString() +" "+ UnityEngine.Input.GetJoystickNames()[PadEZ.PadManager.GetActiveController().GetIndex()]);
* }*/
}
if (inputHUD == 2)
{
GUI.Label(new Rect(10f, 10f, 300f, 2500f), ReadInputManager.ReadCommandInputs(false));
}
if (inputHUD == 3)
{
GUI.Label(new Rect(0f, 0f, 300f, 2500f), ReadInputManager.ReadCommandInputs(false));
GUI.Label(new Rect(300f, 0f, 300f, 2500f), ReadInputManager.ReadCommandInputs(true));
}
if (inputHUD == 4)
{
GUI.Label(new Rect(0f, 0f, 500f, 2500f), ReadInputManager.ReadInputAxes());
GUI.Label(new Rect(500f, 0f, 500f, 2500f), ReadInputManager.ReadRawInputManagerButtons());
}
}
public static void Prefix(ThrusterModel __instance, ref Vector3 ____translationalInput)
{
if (!SmoothThrust.container.ContainsKey(__instance))
{
SmoothThrust.container.Add(__instance, new SmoothThrust.SmoothCont());
}
SmoothThrust.SmoothCont iter = SmoothThrust.container[__instance];
if (OWInput.IsNewlyPressed(InputLibrary.interact))
{
iter._prevTranslation = ____translationalInput;
iter._buildupVelocity = Vector3.zero;
}
if (OWInput.IsPressed(InputLibrary.interact, 0.05f))
{
iter._prevTranslation.x = Mathf.SmoothDamp(iter._prevTranslation.x, ____translationalInput.x, ref iter._buildupVelocity.x, SmoothThrust._analogSmoothTime);
iter._prevTranslation.z = Mathf.SmoothDamp(iter._prevTranslation.z, ____translationalInput.z, ref iter._buildupVelocity.z, SmoothThrust._analogSmoothTime);
iter._prevTranslation.y = Mathf.SmoothDamp(iter._prevTranslation.y, ____translationalInput.y, ref iter._buildupVelocity.y, SmoothThrust._analogSmoothTime);
____translationalInput = iter._prevTranslation;
}
if (SmoothThrust.anglerSafety && (SmoothThrust.ShipNMBody != null || SmoothThrust.PlayerNMBody != null))
{
Vector3 myPos;
if (__instance is ShipThrusterModel)
{
myPos = SmoothThrust.ShipNMBody.GetCenterOfMass();
}
else
{
myPos = SmoothThrust.PlayerNMBody.GetCenterOfMass();
}
float mindist = Mathf.Infinity;
bool triggered = false;
foreach (AnglerfishController fish in SmoothThrust.fishes)
{
if (fish.gameObject.activeSelf)
{
if (fish.GetAnglerState() == AnglerfishController.AnglerState.Chasing)
{
triggered = true;
}
float dist = Vector3.Distance(myPos, fish.transform.position);
mindist = Mathf.Min(dist, mindist);
}
}
if (triggered)
{
mindist = Mathf.Infinity;
}
SmoothThrust.limiter = Mathf.Infinity;
if (__instance is ShipThrusterModel)
{
if (mindist <= 400.1f)
{
if (____translationalInput.magnitude * __instance.GetMaxTranslationalThrust() >= mindist / 20f)
{
____translationalInput = ____translationalInput.normalized * (mindist / 21f) / __instance.GetMaxTranslationalThrust();
}
}
}
else
{
if (mindist <= 210f)
{
if (____translationalInput.magnitude * 100f * __instance.GetMaxTranslationalThrust() >= mindist * 3f)
{
____translationalInput = ____translationalInput.normalized * (mindist / 35f) / __instance.GetMaxTranslationalThrust();
}
}
}
}
iter._prevTranslation = ____translationalInput;
SmoothThrust.container[__instance] = iter;
}
internal void LateUpdate()
{
var isInShip = ToolHelper.Swapper.GetToolGroup() == ToolGroup.Ship;
var isUsingFixedProbeTool = OWInput.IsInputMode(InputMode.StationaryProbeLauncher) || OWInput.IsInputMode(InputMode.SatelliteCam);
if (!isInShip && !isUsingFixedProbeTool)
{
foreach (var prompt in _toolUnequipPrompts)
{
prompt.SetVisibility(false);
}
}
}
private void OnPrimaryActionChange(SteamVR_Action_Boolean fromAction, SteamVR_Input_Sources fromSource, bool newState)
{
var value = newState ? 1 : 0;
if (!SceneHelper.IsInGame())
{
_buttons[JoystickButton.FaceLeft] = value;
return;
}
var toolSwapper = ToolHelper.Swapper;
var isInShip = toolSwapper.GetToolGroup() == ToolGroup.Ship;
var isUsingSignalscope = toolSwapper.IsInToolMode(ToolMode.SignalScope);
var isUsingProbeLauncher = toolSwapper.IsInToolMode(ToolMode.Probe);
var isUsingFixedProbeTool = OWInput.IsInputMode(InputMode.StationaryProbeLauncher) || OWInput.IsInputMode(InputMode.SatelliteCam);
if (!isUsingFixedProbeTool && !ToolHelper.IsUsingAnyTool())
{
var isRepairPromptVisible = _repairPrompt != null && !_repairPrompt.IsVisible();
var canRepairSuit = _playerResources.IsSuitPunctured() && OWInput.IsInputMode(InputMode.Character) && !ToolHelper.Swapper.IsSuitPatchingBlocked();
if (isRepairPromptVisible && !isInShip && !canRepairSuit)
{
if (newState)
{
_primaryLastTime = fromAction.changedTime;
}
else
{
_primaryLastTime = -1;
if (!_justHeld)
{
SimulateInput(JoystickButton.FaceLeft);
}
_justHeld = false;
}
}
else
{
_buttons[JoystickButton.FaceLeft] = value;
}
}
else if (!isInShip || isUsingProbeLauncher || isUsingFixedProbeTool)
{
_buttons[JoystickButton.RightBumper] = value;
}
else if (isUsingSignalscope)
{
_axes[XboxAxis.dPadX.GetInputAxisName(0)] = value;
}
if (isInShip)
{
if (!newState)
{
_buttons[JoystickButton.FaceLeft] = value;
}
}
}
public static bool RoastingStickController_UpdateMarshmallowInput(
RoastingStickController __instance
)
{
var changePromptText = false;
var showRemovePrompt = false;
var text = string.Empty;
if (__instance._extendFraction == 0f)
{
if (__instance._marshmallow.IsEdible())
{
text = UITextLibrary.GetString(UITextType.RoastingEatPrompt);
changePromptText = true;
if (__instance._marshmallow.IsBurned())
{
showRemovePrompt = true;
if (OWInput.IsNewlyPressed(InputLibrary.cancel, InputMode.Roasting))
{
InputLibrary.cancel.ConsumeInput();
__instance._marshmallow.Remove();
Locator.GetPlayerAudioController().PlayMarshmallowToss();
var spawnedMarshmallow = Object.Instantiate(__instance._mallowBodyPrefab, __instance._stickTransform.position, __instance._stickTransform.rotation);
var rigidbody = spawnedMarshmallow.GetComponent <OWRigidbody>();
rigidbody.SetVelocity(__instance._campfire.GetAttachedOWRigidbody().GetPointVelocity(__instance._stickTransform.position) + __instance._stickTransform.forward * 3f);
rigidbody.SetAngularVelocity(__instance._stickTransform.right * 10f);
var burntColor = __instance._marshmallow.GetBurntColor();
spawnedMarshmallow.GetComponentInChildren <MeshRenderer>().material.color = burntColor;
new MarshmallowEventMessage(MarshmallowMessageType.Toss).Send();
}
}
if (OWInput.IsNewlyPressed(InputLibrary.interact, InputMode.Roasting) && __instance._marshmallow.IsEdible())
{
__instance._marshmallow.Eat();
}
}
else if (__instance._marshmallow.GetState() == Marshmallow.MallowState.Burning)
{
text = UITextLibrary.GetString(UITextType.RoastingExtinguishPrompt);
changePromptText = true;
if (OWInput.IsNewlyPressed(InputLibrary.interact, InputMode.Roasting))
{
__instance._marshmallow.Extinguish();
new MarshmallowEventMessage(MarshmallowMessageType.Extinguish).Send();
}
}
else if (__instance._marshmallow.GetState() == Marshmallow.MallowState.Gone)
{
text = UITextLibrary.GetString(UITextType.RoastingReplacePrompt);
changePromptText = true;
if (OWInput.IsNewlyPressed(InputLibrary.interact, InputMode.Roasting))
{
__instance._marshmallow.SpawnMallow(true);
}
}
if (changePromptText && __instance._promptText != text)
{
__instance._promptText = text;
__instance._mallowPrompt.SetText(__instance._promptText);
}
if (OWInput.IsNewlyPressed(InputLibrary.cancel, InputMode.Roasting))
{
__instance._campfire.StopRoasting();
return(false);
}
}
__instance._showMallowPrompt = changePromptText;
__instance._showRemovePrompt = showRemovePrompt;
return(false);
}
private void EnableInput()
{
_isInputEnabled = true;
OWInput.ChangeInputMode(InputMode.Character);
}
