コード例 #1
0
        void IMyUseObject.Use(UseActionEnum actionEnum, MyCharacter user)
        {
            var relation = Block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);

            if (relation != Common.MyRelationsBetweenPlayerAndBlock.Owner && relation != Common.MyRelationsBetweenPlayerAndBlock.FactionShare)
            {
                if (user.ControllerInfo.IsLocallyHumanControlled())
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                }
                return;
            }

            switch (actionEnum)
            {
            case UseActionEnum.OpenTerminal:
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Block);
                break;

            case UseActionEnum.OpenInventory:
                if (Block as IMyInventoryOwner != null)
                {
                    MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
                }
                break;
            }
        }
コード例 #2
0
        public override void UpdateAfterSimulation10()
        {
            base.UpdateAfterSimulation10();
            if (!MyFakes.ENABLE_REMOTE_CONTROL)
            {
                return;
            }
            if (m_previousControlledEntity != null)
            {
                if (!RemoteIsInRangeAndPlayerHasAccess())
                {
                    RequestRelease(false);
                    if (MyGuiScreenTerminal.IsOpen && MyGuiScreenTerminal.InteractedEntity == this)
                    {
                        MyGuiScreenTerminal.Hide();
                    }
                }

                var receiver = GetFirstRadioReceiver();
                if (receiver != null)
                {
                    receiver.UpdateHud(true);
                }
            }
        }
コード例 #3
0
        void IMyUseObject.Use(UseActionEnum actionEnum, IMyEntity entity)
        {
            var user     = entity as MyCharacter;
            var relation = Block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);

            if (!relation.IsFriendly())
            {
                if (user.ControllerInfo.IsLocallyHumanControlled())
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                }
                return;
            }

            switch (actionEnum)
            {
            case UseActionEnum.OpenTerminal:
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Block);
                break;

            case UseActionEnum.OpenInventory:
                if (Block as IMyInventoryOwner != null)
                {
                    MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
                }
                break;
            }
        }
コード例 #4
0
        public void ShowTerminal(string blockId)
        {
            var block = m_lowLevelObserver.GetBlockById(blockId);

            block.FatBlock.ThrowIfNull("Block has to be functional to show terminal");
            MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, Character, block.FatBlock);
        }
コード例 #5
0
        private void RequestControl()
        {
            if (!MyFakes.ENABLE_REMOTE_CONTROL)
            {
                return;
            }

            //Do not take control if you are already the controller
            if (MySession.ControlledEntity == this)
            {
                return;
            }

            //Double check because it can be called from toolbar
            if (!CanControl())
            {
                return;
            }

            if (MyGuiScreenTerminal.IsOpen)
            {
                MyGuiScreenTerminal.Hide();
            }

            //Temporary fix to prevent crashes on DS
            //This happens when remote control is triggered by a sensor or a timer block
            //We need to prevent this from happening at all
            if (MySession.ControlledEntity != null)
            {
                SyncObject.RequestUse(UseActionEnum.Manipulate, MySession.ControlledEntity);
            }
        }
コード例 #6
0
 public override void ShowInventory()
 {
     if (m_enableShipControl)
     {
         MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, m_pilot, this);
     }
 }
コード例 #7
0
        public override void Use(UseActionEnum actionEnum, IMyEntity entity)
        {
            var user     = entity as MyCharacter;
            var relation = Door.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);

            if (!relation.IsFriendly())
            {
                if (user.ControllerInfo.IsLocallyHumanControlled())
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                }
                return;
            }

            switch (actionEnum)
            {
            case UseActionEnum.Manipulate:
                Door.SetOpenRequest(!Door.Open, user.ControllerInfo.ControllingIdentityId);
                break;

            case UseActionEnum.OpenTerminal:
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Door);
                break;
            }
        }
コード例 #8
0
        public void Use(UseActionEnum actionEnum, MyCharacter user)
        {
            var relation = GetUserRelationToOwner(user.ControllerInfo.Controller.Player.Identity.IdentityId);

            if (!relation.IsFriendly())
            {
                if (user.ControllerInfo.Controller.Player == MySession.LocalHumanPlayer)
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                }
                return;
            }

            if (actionEnum == UseActionEnum.OpenTerminal)
            {
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, this);
            }
            else if (actionEnum == UseActionEnum.Manipulate)
            {
                if (m_user != null && m_user != user)
                {
                    return;
                }
                SyncObject.RequestUse(actionEnum, user);
            }
        }
コード例 #9
0
        void IMyUseObject.Use(UseActionEnum actionEnum, IMyEntity entity)
        {
            var user     = entity as MyCharacter;
            var relation = Door.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);

            if (relation != Common.MyRelationsBetweenPlayerAndBlock.Owner && relation != Common.MyRelationsBetweenPlayerAndBlock.FactionShare)
            {
                if (user.ControllerInfo.IsLocallyHumanControlled())
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                }
                return;
            }

            switch (actionEnum)
            {
            case UseActionEnum.Manipulate:
                Door.SetOpenRequest(!Door.Open, user.ControllerInfo.ControllingIdentityId);
                break;

            case UseActionEnum.OpenTerminal:
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Door);
                break;
            }
        }
コード例 #10
0
        public void Use(UseActionEnum actionEnum, MyCharacter user)
        {
            var relation = GetUserRelationToOwner(user.ControllerInfo.Controller.Player.Identity.IdentityId);
            var player   = MyPlayer.GetPlayerFromCharacter(user);

            if (!(relation.IsFriendly() || (player != null && MySession.Static.IsUserSpaceMaster(player.Client.SteamUserId))))
            {
                if (user.ControllerInfo.Controller.Player == MySession.Static.LocalHumanPlayer)
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                }
                return;
            }

            if (actionEnum == UseActionEnum.OpenTerminal)
            {
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, this);
            }
            else if (actionEnum == UseActionEnum.Manipulate)
            {
                if (m_user != null && m_user != user)
                {
                    return;
                }

                MyMultiplayer.RaiseEvent(this, x => x.RequestUse, actionEnum, user.EntityId);
            }
        }
コード例 #11
0
        void IMyUseObject.Use(UseActionEnum actionEnum, IMyEntity entity)
        {
            var user     = entity as MyCharacter;
            var relation = Block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);

            if (relation != Sandbox.Common.MyRelationsBetweenPlayerAndBlock.Owner && relation != Sandbox.Common.MyRelationsBetweenPlayerAndBlock.FactionShare)
            {
                if (user.ControllerInfo.IsLocallyHumanControlled())
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                }
                return;
            }

            switch (actionEnum)
            {
            case UseActionEnum.OpenInventory:
            case UseActionEnum.OpenTerminal:
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
                break;

            default:
                //MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
                break;
            }
        }
コード例 #12
0
        public override void Use(UseActionEnum actionEnum, IMyEntity entity)
        {
            var user  = entity as MyCharacter;
            var block = Entity as MyCubeBlock;

            if (block != null)
            {
                var relation = block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);
                if (!relation.IsFriendly())
                {
                    if (user.ControllerInfo.IsLocallyHumanControlled())
                    {
                        MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                    }
                    return;
                }
            }

            switch (actionEnum)
            {
            case UseActionEnum.OpenInventory:
            case UseActionEnum.OpenTerminal:
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Entity);
                break;

            default:
                //MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
                break;
            }
        }
コード例 #13
0
        public override void Use(UseActionEnum actionEnum, IMyEntity entity)
        {
            var user     = entity as MyCharacter;
            var relation = Block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);

            if (!relation.IsFriendly() && !MySession.Static.AdminSettings.HasFlag(AdminSettingsEnum.UseTerminals))
            {
                if (user.ControllerInfo.IsLocallyHumanControlled())
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                }
                return;
            }

            switch (actionEnum)
            {
            case UseActionEnum.OpenTerminal:
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Block);
                break;

            case UseActionEnum.OpenInventory:
                if (Block.GetInventory(0) as MyInventory != null)
                {
                    MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
                }
                break;
            }
        }
コード例 #14
0
        static object GetItemInControlPanel()
        {
            if (MyGuiScreenTerminal.GetCurrentScreen() == MyTerminalPageEnum.ControlPanel)
            {
                return(MyGuiScreenTerminal.InteractedEntity);
            }

            return(null);
        }
コード例 #15
0
        void Write(BitStream stream)
        {
            // TODO: Make sure sleeping, server controlled entities are not moving locally (or they can be but eventually their position should be corrected)

            stream.WriteBool(MySession.ControlledEntity != null);
            if (MySession.ControlledEntity == null)
            {
                Vector3D pos = MySpectatorCameraController.Static.Position;
                stream.WriteDouble(pos.X);
                stream.WriteDouble(pos.Y);
                stream.WriteDouble(pos.Z);
            }
            else
            {
                var controlledEntity = MySession.ControlledEntity.Entity.GetTopMostParent();

                // Send controlled entity every other frame to server
                if (MyMultiplayer.Static.FrameCounter % 2 == 0)
                {
                    // TODO: Write additional client data, context

                    if (controlledEntity != null && controlledEntity.SyncFlag && ((MySyncEntity)controlledEntity.SyncObject).ResponsibleForUpdate(Sync.Clients.LocalClient))
                    {
                        stream.WriteInt64(controlledEntity.EntityId);
                        switch (MyGuiScreenTerminal.GetCurrentScreen())
                        {
                        case MyTerminalPageEnum.Inventory:
                            stream.WriteInt32((int)MyContextKind.Inventory, 2);
                            break;

                        case MyTerminalPageEnum.ControlPanel:
                            stream.WriteInt32((int)MyContextKind.Terminal, 2);
                            break;

                        case MyTerminalPageEnum.Production:
                            stream.WriteInt32((int)MyContextKind.Production, 2);
                            break;

                        default:
                            stream.WriteInt32((int)MyContextKind.None, 2);
                            break;
                        }

                        if (MyGuiScreenTerminal.InteractedEntity != null)
                        {
                            stream.WriteInt64(MyGuiScreenTerminal.InteractedEntity.EntityId);
                        }
                        else
                        {
                            stream.WriteInt64(0);
                        }

                        ((MySyncEntity)controlledEntity.SyncObject).SerializePhysics(stream, null);
                    }
                }
            }
        }
コード例 #16
0
 private void OnOwnerUse(UseActionEnum actionEnum, MyCharacter user)
 {
     if (actionEnum == UseActionEnum.Manipulate)
     {
         OpenWindow(true, true, false);
     }
     else if (actionEnum == UseActionEnum.OpenTerminal)
     {
         MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, this);
     }
 }
コード例 #17
0
        protected override void WriteInternal(BitStream stream, MyEntity controlledEntity)
        {
            MyContextKind context = GetContextByPage(MyGuiScreenTerminal.GetCurrentScreen());

            stream.WriteInt32((int)context, 2);
            if (context != MyContextKind.None)
            {
                var entityId = MyGuiScreenTerminal.InteractedEntity != null ? MyGuiScreenTerminal.InteractedEntity.EntityId : 0;
                stream.WriteInt64(entityId);
            }
        }
コード例 #18
0
        protected override void WriteInternal(BitStream stream, MyEntity controlledEntity)
        {
            MyContextKind contextByPage = GetContextByPage(MyGuiScreenTerminal.GetCurrentScreen());

            stream.WriteInt32((int)contextByPage, 2);
            if (contextByPage != MyContextKind.None)
            {
                long value = (MyGuiScreenTerminal.InteractedEntity != null) ? MyGuiScreenTerminal.InteractedEntity.EntityId : 0L;
                stream.WriteInt64(value, 64);
            }
        }
コード例 #19
0
 public override void ShowInventory()
 {
     base.ShowInventory();
     if (m_enableShipControl)
     {
         var user = GetUser();
         if (user != null)
         {
             MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, this);
         }
     }
 }
コード例 #20
0
        public void SelectBlueprint()
        {
            if (MyGuiScreenTerminal.IsOpen)
            {
                MyGuiScreenTerminal.Hide();
            }

            RemoveProjection(false);
            var blueprintScreen = new MyGuiBlueprintScreen(m_clipboard);

            blueprintScreen.Closed += OnBlueprintScreen_Closed;
            MyGuiSandbox.AddScreen(blueprintScreen);
        }
コード例 #21
0
        protected override void OnUpdate()
        {
            if (_available)
            {
                var screen = MyGuiScreenTerminal.GetCurrentScreen();
                if (screen != _currentScreen)
                {
                    _currentScreen = screen;
                    OnScreenChanged(screen);
                }
            }

            base.OnUpdate();
        }
コード例 #22
0
        public void RequestSetView()
        {
            if (IsWorking)
            {
                MyHud.Notifications.Remove(m_hudNotification);
                MyHud.Notifications.Add(m_hudNotification);

                CubeGrid.GridSystems.CameraSystem.SetAsCurrent(this);
                SetView();
                if (MyGuiScreenTerminal.IsOpen)
                {
                    MyGuiScreenTerminal.Hide();
                }
            }
        }
コード例 #23
0
ファイル: Tool.cs プロジェクト: Jimmacle/ManipulationToolMod
        private void Grab()
        {
            if (MyAPIGateway.Session.ControlledObject != null && MyGuiScreenTerminal.GetCurrentScreen() == MyTerminalPageEnum.None && MyGuiScreenGamePlay.ActiveGameplayScreen == null)
            {
                if (grabber.TryGrabNew(5))
                {
                    var packet = new List <byte>();
                    packet.AddRange(BitConverter.GetBytes(true));
                    packet.AddRange(BitConverter.GetBytes(MyAPIGateway.Session.Player.IdentityId));

                    MyAPIGateway.Multiplayer.SendMessageToOthers(HANDLER_ID, packet.ToArray());

                    grabbed = true;
                }
            }
        }
コード例 #24
0
        private void OnFactionUse(UseActionEnum actionEnum, MyCharacter user)
        {
            bool isAccessible         = IsAccessibleForFaction;
            bool readOnlyNotification = false;

            if (IsAccessibleForFaction)
            {
                if (actionEnum == UseActionEnum.Manipulate)
                {
                    if (IsWritableForFaction)
                    {
                        OpenWindow(true, true, false);
                    }
                    else if (IsReadableForFaction)
                    {
                        OpenWindow(false, true, false);
                    }
                    else
                    {
                        Debug.Fail("Unknown state of text panel");
                    }
                }
                else if (actionEnum == UseActionEnum.OpenTerminal)
                {
                    if (IsWritableForFaction)
                    {
                        MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, this);
                    }
                    else
                    {
                        readOnlyNotification = true;
                    }
                }
            }

            if (user.ControllerInfo.Controller.Player == MySession.LocalHumanPlayer)
            {
                if (!isAccessible)
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                }
                else if (readOnlyNotification)
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.TextPanelReadOnly);
                }
            }
        }
コード例 #25
0
        public override void Use(UseActionEnum actionEnum, IMyEntity entity)
        {
            var user  = entity as MyCharacter;
            var block = Entity as MyCubeBlock;

            if (block != null)
            {
                var relation = block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);
                if (!relation.IsFriendly())
                {
                    if (user.ControllerInfo.IsLocallyHumanControlled())
                    {
                        MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                    }
                    return;
                }
            }

            //by Gregory: on use action the button pressed should be checked because on use action we will always get only Inventory TODO: refactor somehow
            if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.TERMINAL))
            {
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Entity);
            }
            else
            {
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Entity);
            }

            /*
             * switch (actionEnum)
             * {
             *  case UseActionEnum.OpenInventory:
             *      MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Entity);
             *      break;
             *  case UseActionEnum.OpenTerminal:
             *      MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Entity);
             *      break;
             *  default:
             *      //MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Entity);
             *      break;
             * }
             */
        }
コード例 #26
0
        private bool OpenPropertiesByEntityId(long entityId)
        {
            MyEntity openTerminalEntity;

            MyEntities.TryGetEntityById(entityId, out openTerminalEntity);

            //rule: When you want to open character terminal you pass null as interactedEntity
            if (openTerminalEntity is MyCharacter)
            {
                MyGuiScreenTerminal.ChangeInteractedEntity(null);
                return(true);
            }

            //grid = null -> has been destroyed or something like that
            if (openTerminalEntity != null && openTerminalEntity is MyCubeGrid)
            {
                var grid = openTerminalEntity as MyCubeGrid;

                m_tempSendingToGrid.Clear();
                m_tempReceivingFromGrid.Clear();
                GridBroadcastersFromPlayer(grid, m_tempSendingToGrid);
                PlayerBroadcastersFromGrid(grid, m_tempReceivingFromGrid);

                if ((m_tempSendingToGrid.Count > 0 && m_tempReceivingFromGrid.Count > 0) || m_openInventoryInteractedEntityRepresentative == grid)
                {
                    //This will only happen when you have a grid with no radio connection, in which case the entity itself is the only available option
                    if (m_tempReceivingFromGrid.Count <= 0)
                    {
                        MyGuiScreenTerminal.ChangeInteractedEntity(MyGuiScreenTerminal.InteractedEntity);
                    }

                    //pick the first antenna from cube grid to switch (could've been any one anyways)
                    else
                    {
                        MyGuiScreenTerminal.ChangeInteractedEntity(m_tempReceivingFromGrid.ElementAt(0).Entity as MyTerminalBlock);
                    }
                    return(true);
                }
            }

            //Else throw an alert to the user saying "ship has been disconnected" or something?
            return(false);
        }
コード例 #27
0
        private static void ShowError(MyStringId errorText, IMyGuiControlsParent controlsParent)
        {
            foreach (var control in controlsParent.Controls)
            {
                control.Visible = false;
            }

            var label = (MyGuiControlLabel)controlsParent.Controls.GetControlByName("ErrorMessage");

            if (label == null)
            {
                label = MyGuiScreenTerminal.CreateErrorLabel(errorText, "ErrorMessage");
            }
            label.TextEnum = errorText;
            if (!controlsParent.Controls.Contains(label))
            {
                controlsParent.Controls.Add(label);
            }
        }
コード例 #28
0
ファイル: Projector.cs プロジェクト: zrisher/ARMS
        /// <summary>
        /// Updates positions & orientations
        /// </summary>
        public void Update1()
        {
            if (!Enabled || !m_playerCanSee)
            {
                foreach (SeenHolo sh in m_holoEntities.Values)
                {
                    if (sh.Holo.Render.Visible)
                    {
                        Log.DebugLog("hiding holo: " + sh.Seen.Entity.getBestName());
                        SetVisible(sh.Holo, false);
                    }
                }
                return;
            }

            if (MyGuiScreenTerminal.GetCurrentScreen() == MyTerminalPageEnum.None && MyAPIGateway.Session.ControlledObject.Entity is IMyCharacter && Static.MouseControls)
            {
                CheckInput();
            }

            PositionWorld projectionCentre = m_offset.ToWorld(m_block);

            float distanceScale = m_radiusHolo / m_rangeDetection;
            float sizeScale     = distanceScale * m_sizeDistScale;

            foreach (SeenHolo sh in m_holoEntities.Values)
            {
                MatrixD worldMatrix = sh.Seen.Entity.WorldMatrix;
                worldMatrix.Translation = projectionCentre + (sh.Seen.Entity.GetPosition() - m_centreEntity.GetPosition()) * distanceScale + (sh.Seen.Entity.GetPosition() - sh.Seen.Entity.GetCentre()) * (sizeScale - distanceScale);
                Log.DebugLog("entity: " + sh.Seen.Entity.getBestName() + "(" + sh.Seen.Entity.EntityId + "), centre: " + projectionCentre + ", offset: " + (worldMatrix.Translation - projectionCentre) + ", position: " + worldMatrix.Translation);
                sh.Holo.PositionComp.SetWorldMatrix(worldMatrix);
                sh.Holo.PositionComp.Scale = sizeScale;
            }

            if (ShowBoundary)
            {
                MatrixD sphereMatrix = m_block.WorldMatrix;
                sphereMatrix.Translation = projectionCentre;
                Color c = Color.Yellow;
                MySimpleObjectDraw.DrawTransparentSphere(ref sphereMatrix, m_radiusHolo, ref c, MySimpleObjectRasterizer.Wireframe, 8);
            }
        }
コード例 #29
0
        public override void Use(UseActionEnum actionEnum, IMyEntity entity)
        {
            MyCharacter user = entity as MyCharacter;

            if (!this.Door.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId).IsFriendly() && !MySession.Static.AdminSettings.HasFlag(AdminSettingsEnum.UseTerminals))
            {
                if (user.ControllerInfo.IsLocallyHumanControlled())
                {
                    MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
                }
            }
            else if (actionEnum == UseActionEnum.Manipulate)
            {
                this.Door.SetOpenRequest(!this.Door.Open, user.ControllerInfo.ControllingIdentityId);
            }
            else if (actionEnum == UseActionEnum.OpenTerminal)
            {
                MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, this.Door);
            }
        }
コード例 #30
0
        public void SetView()
        {
            if (!MyFakes.ENABLE_CAMERA_BLOCK)
            {
                return;
            }
            if (MySession.Static.CameraController is MyCameraBlock)
            {
                var oldCamera = MySession.Static.CameraController as MyCameraBlock;
                oldCamera.IsActive = false;
            }

            MySession.SetCameraController(MyCameraControllerEnum.Entity, this);
            if (MyGuiScreenTerminal.IsOpen)
            {
                MyGuiScreenTerminal.Hide();
            }

            SetFov(m_fov);

            IsActive = true;
        }