Ejemplo n.º 1
0
            }   // end of RunSimUpdateObj c'tor

            /// <summary>
            /// RunSimUpdateObj Update()
            /// </summary>
            /// <param name="camera"></param>
            public override void Update()
            {
                base.Update();

                parent.Camera.Update();

                float secs = Time.WallClockFrameSeconds;

                ThoughtBalloonManager.Update(shared.camera);
                SaidStringManager.Update();
#if !NETFX_CORE
                MicrobitManager.Update();
#endif

                // Start with visible cursor.
                parent.cursor3D.Activate();
                parent.cursor3D.Rep    = Cursor3D.Visual.RunSim;
                parent.cursor3D.Hidden = false;

                //
                // Determine the correct camera mode.
                //

                //
                //  The priorities used to determine the camera mode when the game is running are:
                //
                //  1)  First person.  This can be either via programming or because the user zoomed
                //      into a bot the camera was following.
                //  2)  Follow mode caused by bot(s) programmed with "follow" camera view.
                //  3)  World tweak screen fixed camera or fixed offset camera.
                //  4)  Follow mode caused by user controlled bot(s).
                //  5)  Free camera.
                //

                // Start with a fake loop to break out of.
                while (true)
                {
                    Terrain terrain = InGame.inGame.Terrain;    // Just a shortcut.

                    //
                    // Always use edit mode when the game is paused except during victory on level with one of the fixed cameras
                    // or when game is paused for a bot to speak (modal text display).
                    //
                    bool victoryActive = VictoryOverlay.ActiveGameOver || VictoryOverlay.ActiveWinner;
                    bool speaking      = InGame.inGame.shared.smallTextDisplay.Active || InGame.inGame.shared.scrollableTextDisplay.Active;
                    if (Time.Paused && !((terrain.FixedCamera || terrain.FixedOffsetCamera) && victoryActive) && !speaking)
                    {
                        CameraInfo.Mode = CameraInfo.Modes.Edit;
                        CameraInfo.CameraFocusGameActor = null;
                        break;
                    }

                    //
                    // 1) First person
                    //
                    if (CameraInfo.FirstPersonActive)
                    {
                        CameraInfo.Mode = CameraInfo.Modes.Actor;

                        // We're following a single actor so update the FollowActor camera values.
                        shared.camera.FollowCameraValid = false;

                        // Turn off 3d cursor since we don't need it.
                        parent.cursor3D.Deactivate();
                        if (parent.cursorClone != null)
                        {
                            parent.cursorClone.Deactivate();
                            parent.cursorClone = null;
                        }
                        break;
                    }

                    //
                    // 2)  Follow mode caused by bot(s) programmed with "follow" camera view.
                    //
                    if (CameraInfo.ProgrammedFollowList.Count > 0)
                    {
                        // Note that even though we looked at the count of bot programmed to
                        // have the camera follow them, for this mode we want to keep all
                        // deserving bots in camera.  So, the rest of this section will use
                        // the merged follow list instead of just the programmed follow list.

                        SetUpCameraFollowMode();

                        break;
                    }

                    //
                    // 3) World tweak fixed cameras.  Note for fixed offset we have to let
                    //    the later modes do their stuff and then override the camera.
                    //

                    if (terrain.FixedCamera)
                    {
                        CameraInfo.Mode = CameraInfo.Modes.FixedTarget;
                        CameraInfo.CameraFocusGameActor = null;

                        // Turn off 3d cursor since we don't need it.
                        parent.cursor3D.Deactivate();
                        if (parent.cursorClone != null)
                        {
                            parent.cursorClone.Deactivate();
                            parent.cursorClone = null;
                        }

                        break;
                    }

                    //
                    // 4) Follow mode caused by user controlled bot(s).
                    //
                    if (CameraInfo.MergedFollowList.Count > 0)
                    {
                        SetUpCameraFollowMode();

                        break;
                    }

                    //
                    // 5) Free!
                    //
                    // Not following an actor.
                    CameraInfo.Mode = CameraInfo.Modes.Edit;
                    CameraInfo.CameraFocusGameActor = null;

                    // Turn on 3d cursor in case we previously disabled it.
                    parent.cursor3D.Activate();
                    parent.CreateCursorClone();
                    parent.cursor3D.Hidden = false;

                    // We have no camera restrictions, so keep track of what the user is doing.
                    shared.camera.PlayValid      = true;
                    shared.camera.PlayCameraFrom = shared.camera.From;
                    shared.camera.PlayCameraAt   = shared.camera.At;

                    shared.camera.FollowCameraValid = false;


                    // Final break just to be sure the loop exits.
                    break;
                }

                //
                // Now that we're done, we need to check again to see if
                // we should be in FixedOffsetMode.
                //
                if (!Time.Paused && InGame.inGame.Terrain.FixedOffsetCamera && !CameraInfo.FirstPersonActive)
                {
                    CameraInfo.Mode = CameraInfo.Modes.FixedOffset;
                }

                // Zero out any offset while running.
                float t = Math.Min(Time.GameTimeFrameSeconds, 1.0f);
                shared.camera.HeightOffset = MyMath.Lerp(shared.camera.HeightOffset, 0.0f, t);

                //
                bool inputFocus = CommandStack.Peek() == commandMap;

                // Move the camera.
                switch (CameraInfo.Mode)
                {
                case CameraInfo.Modes.Edit:
                    MoveCameraEditMode(inputFocus, false);
                    break;

                case CameraInfo.Modes.Actor:
                    MoveCameraActorMode(true, false);
                    break;

                case CameraInfo.Modes.FixedTarget:
                    MoveCameraFixedTargetMode(inputFocus);
                    break;

                case CameraInfo.Modes.FixedOffset:
                    MoveCameraFixedOffsetMode(inputFocus);
                    break;

                case CameraInfo.Modes.MultiTarget:
                    MoveCameraMultiTargetMode(inputFocus, false);
                    break;
                }

                shared.camera.Update();

                // Update terrain.
                parent.terrain.Update(shared.camera);

                // Update the list of objects using our local camera.
                for (int i = 0; i < updateList.Count; i++)
                {
                    UpdateObject obj = (UpdateObject)updateList[i];
                    obj.Update();
                }
                parent.UpdateObjects();

                /// Pregame must update after parent.UpdateObjects, in case it
                /// decides to switchToMiniHub
                if (InGame.inGame.preGame != null)
                {
                    InGame.inGame.preGame.Update();
                }

                // Update the particle system.
                shared.particleSystemManager.Update();
                DistortionManager.Update();
                FirstPersonEffectMgr.Update();

                // This must be done after all brains are updated.
                Scoreboard.Update(shared.camera);

                // Update the TextDisplays.  Ignored if not active.
                shared.scrollableTextDisplay.Update(shared.camera);
                shared.smallTextDisplay.Update(shared.camera);

                VictoryOverlay.Update();

                // Do the input processing after object update because there will be order of operation issue if we don't
                //
                // Check if we have input focus.  Don't do any input
                // related update if we don't.
                if (inputFocus)
                {
                    // Grab the current state of the gamepad.
                    GamePadInput pad = GamePadInput.GetGamePad0();

                    // Switch to Mini-Hub?
                    if (Actions.MiniHub.WasPressed)
                    {
                        Actions.MiniHub.ClearAllWasPressedState();

                        //parent.ResetSim(CurrentLevelFilename());

                        // Needed to make sure that deactivated objects are actually removed from
                        // the list otherwise they may get saved along with the newly activated ones.
                        //parent.Refresh(BokuGame.gameListManager.updateList, BokuGame.gameListManager.renderList);

                        parent.SwitchToMiniHub();
                        return;
                    }

                    //handle swipe to return to edit for touch input
                    if (GamePadInput.ActiveMode == GamePadInput.InputMode.Touch)
                    {
                        SwipeGestureRecognizer swipeGesture = TouchGestureManager.Get().SwipeGesture;
                        if (swipeGesture.WasRecognized &&
                            swipeGesture.SwipeDirection == Directions.North)
                        {
#if NETFX_CORE
                            float halfWidth = (float)BokuGame.bokuGame.Window.ClientBounds.Width * 0.5f;
                            float height    = (float)BokuGame.bokuGame.Window.ClientBounds.Height;
#else
                            float halfWidth = (float)XNAControl.Instance.ClientSize.Width * 0.5f;
                            float height    = (float)XNAControl.Instance.ClientSize.Height;
#endif

                            //center half of the screen width-wise
                            float minX = halfWidth - (halfWidth * k_TouchExitAreaWidthPercent);
                            float maxX = halfWidth + (halfWidth * k_TouchExitAreaWidthPercent);

                            //bottom 20% height-wise
                            float minY = height - (height * k_TouchExitAreaHeightPercent);


                            Vector2 pos = swipeGesture.InitialPosition;
                            if (pos.X >= minX && pos.X <= maxX && pos.Y >= minY)
                            {
                                // User did a swipe from the bottom of the screen, enter edit mode
                                InGame.inGame.CurrentUpdateMode = UpdateMode.EditObject;
                                InGame.inGame.CurrentUpdateMode = UpdateMode.TouchEdit;

                                Foley.PlayPressStart();
                                return;
                            }
                        }

                        // HACKHACK (****) Put in a tap recognizer since swipe seems to fail.
                        {
                            TapGestureRecognizer hackTapGesture = TouchGestureManager.Get().TapGesture;
                            if (hackTapGesture.WasTapped())
                            {
#if NETFX_CORE
                                float halfWidth = (float)BokuGame.bokuGame.Window.ClientBounds.Width * 0.5f;
                                float height    = (float)BokuGame.bokuGame.Window.ClientBounds.Height;
#else
                                float halfWidth = (float)XNAControl.Instance.ClientSize.Width * 0.5f;
                                float height    = (float)XNAControl.Instance.ClientSize.Height;
#endif

                                //center area of the screen width-wise
                                float minX = halfWidth - (halfWidth * 0.1f);
                                float maxX = halfWidth + (halfWidth * 0.1f);

                                //bottom 10% height-wise
                                float minY = height - (height * 0.1f);

                                Vector2 pos = hackTapGesture.Position;
                                if (pos.X >= minX && pos.X <= maxX && pos.Y >= minY)
                                {
                                    // User did a tap on the bottom of the screen, enter edit mode
                                    InGame.inGame.CurrentUpdateMode = UpdateMode.EditObject;
                                    InGame.inGame.CurrentUpdateMode = UpdateMode.TouchEdit;

                                    Foley.PlayPressStart();
                                    return;
                                }
                            }
                        }
                    }

                    bool gameOver = VictoryOverlay.GameOver;

                    if (Time.Paused && !gameOver)
                    {
                        // We must be in user induced pause mode.
                        if (Actions.Unpause.WasPressed)
                        {
                            Actions.Unpause.ClearAllWasPressedState();

                            Time.Paused = false;
                            HelpOverlay.Pop();
                        }
                    }
                    else
                    {
                        if (gameOver)
                        {
                            // Game over man!  Let the user restart if they want.
                            if (Actions.Restart.WasPressed)
                            {
                                Actions.Restart.ClearAllWasPressedState();

                                InGame.inGame.ResetSim(preserveScores: false, removeCreatablesFromScene: true, keepPersistentScores: false);
                                // Since we're going right back into RunSim mode we need to first inline.
                                ApplyInlining();
                            }
                        }

                        // Open ToolMenu.
                        if (Actions.ToolMenu.WasPressed)
                        {
                            Actions.ToolMenu.ClearAllWasPressedState();

                            parent.CurrentUpdateMode = UpdateMode.ToolMenu;
                            Foley.PlayPressStart();
                            return;
                        }

                        // Pause?
                        // We want to make pause hard to get into so it requires both triggers and both stickButtons to be pressed.
                        if ((pad.LeftStickButton.IsPressed && pad.RightStickButton.IsPressed && pad.LeftTriggerButton.IsPressed && pad.RightTriggerButton.IsPressed) || Actions.Pause.WasPressed)
                        {
                            Actions.Pause.ClearAllWasPressedState();

                            if (!Time.Paused)
                            {
                                Time.Paused = true;
                                HelpOverlay.Push("PauseGame");
                                GamePadInput.GetGamePad0().IgnoreLeftStickUntilZero();
                                GamePadInput.GetGamePad0().IgnoreRightStickUntilZero();
                            }
                        }
                    }
                }

                // Force the the HelpOverlay to be correct.
                if (!Time.Paused || VictoryOverlay.Active)
                {
                    if (InGame.inGame.PreGame != null && InGame.inGame.PreGame.Active)
                    {
                        if (HelpOverlay.Depth() != 1 || HelpOverlay.Peek() != "RunSimulationPreGame")
                        {
                            HelpOverlay.Clear();
                            HelpOverlay.Push("RunSimulationPreGame");
                        }
                    }
                    else
                    {
                        if (HelpOverlay.Depth() != 1 || HelpOverlay.Peek() != "RunSimulation")
                        {
                            HelpOverlay.Clear();
                            HelpOverlay.Push("RunSimulation");
                        }
                    }
                }
                else
                {
                    // We're paused.
                    if (HelpOverlay.Depth() != 2 || HelpOverlay.Peek(1) != "RunSimulation")
                    {
                        HelpOverlay.Clear();
                        HelpOverlay.Push("RunSimulation");
                        HelpOverlay.Push("PauseGame");
                    }
                }

                // When in run mode, allow the user to click on the "Press [esc] to edit" text as if it was a button.
                if (MouseInput.Left.WasPressed)
                {
                    Point mousePos = MouseInput.Position;
                    if (HelpOverlay.MouseHitBottomText(mousePos))
                    {
                        // Switch to edit mode.
                        InGame.inGame.CurrentUpdateMode = UpdateMode.EditObject;
                    }
                }
                TapGestureRecognizer tapGesture = TouchGestureManager.Get().TapGesture;
                if (tapGesture.WasTapped())
                {
                    // JW - Until we have proper Touch help overlays, we are still using the mouse/keyboard
                    // overlays. The mouse handling code for these depends on being able to 'absorb' pressed
                    // info to hide it from later callers. Our touch stuff doesn't (and really shouldn't)
                    // do this. So, we handle cases here based on what type of overlay is being displayed.
                    if (HelpOverlay.Peek() == "RunSimulationPreGame")
                    {
                        // Tap during instructions: just begin game.
                        InGame.inGame.PreGame.Active = false;
                    }

                    // Also test if running sim for tapping on "tap to edit" at bottom.
                    if (HelpOverlay.Peek() == "RunSimulation")
                    {
                        Point pos = new Point((int)tapGesture.Position.X, (int)tapGesture.Position.Y);
                        if (HelpOverlay.MouseHitBottomText(pos))
                        {
                            // Switch to edit mode.
                            InGame.inGame.CurrentUpdateMode = UpdateMode.EditObject;
                        }
                    }
                }
            }   // end of RunSimUpdateObj Update()
Ejemplo n.º 2
0
            }   // end of UpdateCamera()

            /// <summary>
            /// Common camera controls for edit modes.
            /// </summary>
            /// <param name="preventZoom">Lock the zoom.  This is kind of a hack used
            /// by the tool palette since that palette uses the shoulder buttons to
            /// cycle through it.  Without locking the zoom we'd zoom in and out
            /// as we're moving though the tool options.</param>
            public void UpdateCamera(bool preventZoom)
            {
                float secs = Time.WallClockFrameSeconds;

                Vector3 lookAt   = parent.Camera.At;
                Vector3 lookFrom = parent.Camera.From;

                // If we were in first person mode, reset things as needed.
                if (CameraInfo.FirstPersonActive)
                {
                    CameraInfo.FirstPersonActor.SetFirstPerson(false);
                    CameraInfo.ResetAllLists();
                    CameraInfo.Mode = CameraInfo.Modes.Edit;
                    InGame.inGame.Camera.FollowCameraDistance = 10.0f;
                }

                // Check if we have input focus.  Don't do any input
                // related update if we don't.
                if (CommandStack.Peek() == commandMap)
                {
                    // Grab the current state of the gamepad.
                    GamePadInput pad = GamePadInput.GetGamePad0();

                    // From all edit modes, <back> should bring up the tool menu.
                    if (Actions.ToolMenu.WasPressed)
                    {
                        Actions.ToolMenu.ClearAllWasPressedState();

                        Foley.PlayBack();
                        parent.CurrentUpdateMode = UpdateMode.ToolMenu;

                        return;
                    }

                    // From all edit modes, <start> should to to the mini-hub.
                    if (Actions.MiniHub.WasPressed)
                    {
                        Actions.MiniHub.ClearAllWasPressedState();

                        Foley.PlayPressStart();
                        parent.SwitchToMiniHub();

                        return;
                    }

                    // From all edit modes the B button should activate the ToolMenu.
                    // Edit object handles the B button itself since it may be in Waypoint mode.
                    if (Actions.AltToolMenu.WasPressed && parent.CurrentUpdateMode != UpdateMode.EditObject)
                    {
                        Actions.AltToolMenu.ClearAllWasPressedState();
                        parent.CurrentUpdateMode = UpdateMode.ToolMenu;

                        return;
                    }

                    // If the ToolMenu is active and it's modal, don't allow the camera to move.
                    if (InGame.inGame.toolMenuUpdateObj.active && XmlOptionsData.ModalToolMenu)
                    {
                        return;
                    }

                    //
                    // Use common camera controls for all edit modes.
                    //

                    const float cursorSpeed = 20.0f;    // Meters per second.
                    const float orbitSpeed  = 2.0f;     // Radians per second.
                    const float zoomFactor  = 1.1f;

                    // Right stick to orbit around cursor.
                    float drot   = GamePadInput.InvertCamX() ? -pad.RightStick.X : pad.RightStick.X;
                    float dpitch = GamePadInput.InvertCamY() ? -pad.RightStick.Y : pad.RightStick.Y;
                    parent.Camera.DesiredRotation += drot * Time.WallClockFrameSeconds * orbitSpeed;
                    parent.Camera.DesiredPitch    -= dpitch * Time.WallClockFrameSeconds * orbitSpeed;

                    // Left/right arrow keys also orbit but not if the tool menu or a picker is up.
                    //if (inGame.CurrentUpdateMode != UpdateMode.ToolMenu && !HelpOverlay.Peek().EndsWith("Picker") )
                    //{
                    //    if (KeyboardInput.IsPressed(Keys.Left))
                    //    {
                    //        parent.Camera.DesiredRotation -= 1.0f * Time.WallClockFrameSeconds * orbitSpeed;
                    //    }
                    //    else if (KeyboardInput.IsPressed(Keys.Right))
                    //    {
                    //        parent.Camera.DesiredRotation += 1.0f * Time.WallClockFrameSeconds * orbitSpeed;
                    //    }
                    //}

                    // Shoulder buttons track camera in/out.
                    if (!preventZoom)
                    {
                        if (Actions.ZoomOut.IsPressed)
                        {
                            parent.Camera.DesiredDistance *= 1.0f + Time.WallClockFrameSeconds * zoomFactor;
                        }
                        if (Actions.ZoomIn.IsPressed)
                        {
                            float desiredDistance = parent.Camera.DesiredDistance * (1.0f - Time.WallClockFrameSeconds * zoomFactor);
                            // If not in RunSim mode, don't allow the camera to get closer than 4 meters.
                            if (InGame.inGame.CurrentUpdateMode != UpdateMode.RunSim)
                            {
                                desiredDistance = Math.Max(4.0f, desiredDistance);
                            }
                            parent.Camera.DesiredDistance = desiredDistance;
                        }
                        parent.MouseEdit.DoZoom(parent.Camera);
                    }

                    if (GamePadInput.ActiveMode == GamePadInput.InputMode.KeyboardMouse)
                    {
                        parent.MouseEdit.DoCamera(parent.Camera);
                    }

                    // Left stick to control cursor position.
                    // Cursor movement is relative to view heading.
                    // Cursor speed grows with view distance.
                    Vector2 position    = new Vector2(shared.CursorPosition.X, shared.CursorPosition.Y);
                    Vector2 forward     = new Vector2((float)Math.Cos(parent.Camera.Rotation), (float)Math.Sin(parent.Camera.Rotation));
                    Vector2 right       = new Vector2(forward.Y, -forward.X);
                    float   speedFactor = (parent.Camera.Distance - 10.0f) / 50.0f;     // At 10 meters out start growing the speedFactor.
                    speedFactor = MathHelper.Clamp(speedFactor, 1.0f, 3.0f);
                    position   += forward * pad.LeftStick.Y * Time.WallClockFrameSeconds * cursorSpeed * speedFactor;
                    position   += right * pad.LeftStick.X * Time.WallClockFrameSeconds * cursorSpeed * speedFactor;

                    // Numpad controls cursor position. NumLock must be on!
                    float y = KeyboardInput.IsPressed(Keys.NumPad7) || KeyboardInput.IsPressed(Keys.NumPad8) || KeyboardInput.IsPressed(Keys.NumPad9) ? 1.0f : 0.0f;
                    y += KeyboardInput.IsPressed(Keys.NumPad1) || KeyboardInput.IsPressed(Keys.NumPad2) || KeyboardInput.IsPressed(Keys.NumPad3) ? -1.0f : 0.0f;
                    float x = KeyboardInput.IsPressed(Keys.NumPad3) || KeyboardInput.IsPressed(Keys.NumPad6) || KeyboardInput.IsPressed(Keys.NumPad9) ? 1.0f : 0.0f;
                    x        += KeyboardInput.IsPressed(Keys.NumPad1) || KeyboardInput.IsPressed(Keys.NumPad4) || KeyboardInput.IsPressed(Keys.NumPad7) ? -1.0f : 0.0f;
                    position += forward * y * Time.WallClockFrameSeconds * cursorSpeed * speedFactor;
                    position += right * x * Time.WallClockFrameSeconds * cursorSpeed * speedFactor;

                    // Allow LeftStickClick RightStickClick to cycle though actors.
                    if (inGame.gameThingList.Count > 0)
                    {
                        // Move to next actor
                        if (Actions.NextActor.WasPressed)
                        {
                            Actions.NextActor.ClearAllWasPressedState();

                            // If we have an actor in focus, find index.
                            GameActor focusActor = InGame.inGame.EditFocusObject;
                            if (focusActor != null)
                            {
                                for (int i = 0; i < inGame.gameThingList.Count; i++)
                                {
                                    if (focusActor == inGame.gameThingList[i])
                                    {
                                        actorTabIndex = i;
                                        break;
                                    }
                                }
                            }

                            // Increment index.
                            actorTabIndex = (actorTabIndex + 1) % inGame.gameThingList.Count;

                            Vector3 actorPos = inGame.gameThingList[actorTabIndex].Movement.Position;
                            Vector2 delta    = new Vector2(actorPos.X - position.X, actorPos.Y - position.Y);
                            position += delta;
                        }

                        // Move to prev actor
                        if (Actions.PrevActor.WasPressed)
                        {
                            Actions.PrevActor.ClearAllWasPressedState();

                            // If we have an actor in focus, find index.
                            GameActor focusActor = InGame.inGame.EditFocusObject;
                            if (focusActor != null)
                            {
                                for (int i = 0; i < inGame.gameThingList.Count; i++)
                                {
                                    if (focusActor == inGame.gameThingList[i])
                                    {
                                        actorTabIndex = i;
                                        break;
                                    }
                                }
                            }

                            // Decrement index.
                            actorTabIndex = (actorTabIndex + inGame.gameThingList.Count - 1) % inGame.gameThingList.Count;

                            Vector3 actorPos = inGame.gameThingList[actorTabIndex].Movement.Position;
                            Vector2 delta    = new Vector2(actorPos.X - position.X, actorPos.Y - position.Y);
                            position += delta;
                        }
                    }

                    if (!shared.editWayPoint.Dragging)
                    {
                        // TODO (mouse)  Why was this here?
                        //position = parent.MouseEdit.DoCursor(parent.Camera, position);
                    }
                    position = shared.editWayPoint.DoCursor(position);

                    // Keep cursor within 50 units of existing terrain.
                    float   maxBrush = InGame.kMaxBrushRadius;
                    Vector2 min      = new Vector2(InGame.inGame.totalBounds.Min.X, InGame.inGame.totalBounds.Min.Y) - new Vector2(maxBrush, maxBrush);
                    Vector2 max      = new Vector2(InGame.inGame.totalBounds.Max.X, InGame.inGame.totalBounds.Max.Y) + new Vector2(maxBrush, maxBrush);

                    position.X = MathHelper.Clamp(position.X, min.X, max.X);
                    position.Y = MathHelper.Clamp(position.Y, min.Y, max.Y);

                    shared.CursorPosition = new Vector3(position, shared.CursorPosition.Z);
                }   // end if we have input focus.

                // Keep the camera from going into the ground.
                shared.KeepCameraAboveGround();

                // Update camera based on new position/orientation.
                parent.Camera.DesiredAt = shared.CursorPosition;

                // Finally, call Update on the camera to let all the changes filter through.
                parent.Camera.Update();
            }   // end of BaseEditUpdateObj UpdateCamera()