PendulumGame.PendulumGameplayScreen Class Reference

This screen implements the actual game logic. More...

Inheritance diagram for PendulumGame.PendulumGameplayScreen:

List of all members.

Public Member Functions
	PendulumGameplayScreen ()
	Constructor of the screen instance.
override void	LoadContent ()
	Load graphics content for the game.
override void	UnloadContent ()
	Unload graphics content used by the game screen.
override void	Update (GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)
	Updates the state of the game. This method checks the GameScreen.IsActive property, so the game will stop updating when the pause menu is active, or if you tab away to a different application.
override void	HandleInput (InputState input)
	Lets the game respond to player input. Unlike the Update method, this will only be called when the gameplay screen is active.
override void	Draw (GameTime gameTime)
	Draws the gameplay screen.

---

Detailed Description

This screen implements the actual game logic.

Definition at line 30 of file PendulumGameplayScreen.cs.

---

Constructor & Destructor Documentation

PendulumGame.PendulumGameplayScreen.PendulumGameplayScreen

(

)

Constructor of the screen instance.

Definition at line 156 of file PendulumGameplayScreen.cs.

        {
            TransitionOnTime = TimeSpan.FromSeconds(1.0);
            TransitionOffTime = TimeSpan.FromSeconds(1.0);

            // Create playback streamer
            this.audioPlayer = new DirectXAudio((Device)null, 22050, (short)16, (short)2);
        }

---

Member Function Documentation

override void PendulumGame.PendulumGameplayScreen.Draw

(

GameTime

gameTime

)

[virtual]

Draws the gameplay screen.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 754 of file PendulumGameplayScreen.cs.

        {
            // This game has a blue background. Why? Because!
            ScreenManager.GraphicsDevice.Clear(ClearOptions.Target,
                                               Color.Black, 0, 0);

            SpriteBatch spriteBatch = ScreenManager.SpriteBatch;
            PrimitiveBatch primitiveBatch = ScreenManager.PrimitiveBatch;
            Viewport viewport = ScreenManager.GraphicsDevice.Viewport;

            // Draw physical elements
            // Plotter            
            dotPlotters[0].Draw(gameTime, primitiveBatch);
            dotPlotters[1].Draw(gameTime, primitiveBatch);

            // Bloom dot plotters using shaders
            if (!PendulumGame.State.DisablePixelShaderEffects)
            {
                this.bloomOverlay.Draw(gameTime);
            }

            // Laplace-render the targets using shaders
            if ((!PendulumGame.State.DisablePixelShaderEffects) && 
                (this.shootingGallery.NumActiveTargets > 0))
            {
                shootingGallery.Draw(gameTime);
                this.laplaceOverlay.Draw(gameTime);
            }

            // Draw the two pendulums
            animatedDoubleRegularPendulum.Draw(
                gameTime);
            animatedDoubleSquarePendulum.Draw(
                gameTime);

            // Draw action markers
            actionIndicators[0].Draw(gameTime);
            actionIndicators[1].Draw(gameTime);

            // Draw targets again
            shootingGallery.Draw(gameTime);

            // Indicators for both players
            energyIndicators[0].Draw(gameTime);
            energyIndicators[1].Draw(gameTime);
            valueIndicators[PendulumGame.State.Players[0].SelectedIndicator * 2].Draw(gameTime);
            valueIndicators[PendulumGame.State.Players[1].SelectedIndicator * 2 + 1].Draw(gameTime);

            // Separator
            primitiveBatch.Begin(PrimitiveType.LineList);
            primitiveBatch.AddVertex(new Vector2(viewport.Width * 0.5f, viewport.Height - 50.0f), Color.White);
            primitiveBatch.AddVertex(new Vector2(viewport.Width * 0.5f, viewport.Height - 10.0f), Color.White);
            primitiveBatch.End();

            // Draw entropy state
            DrawEntropyStatus(spriteBatch);

            // Draw player score
            DrawPlayers(spriteBatch);

            // If the game is transitioning on or off, fade it out to black.
            if (TransitionPosition > 0)
            {
                ScreenManager.FadeBackBufferToBlack(255 - TransitionAlpha);
            }
        }

override void PendulumGame.PendulumGameplayScreen.HandleInput

(

InputState

input

)

[virtual]

Lets the game respond to player input. Unlike the Update method, this will only be called when the gameplay screen is active.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 609 of file PendulumGameplayScreen.cs.

        {
            if (input == null)
            {
                throw new ArgumentNullException("input");
            }

            PlayerIndex playerIndex;

            if (input.IsInputCancel(null) || input.IsDisconnected(null))
            {
                ScreenManager.AddScreen(new PendulumPauseMenuScreen(), null);
            }
            else
            {
                // Keep track of action intensity
                for (int i = 0; i < PendulumGameState.NumPlayers; i++)
                {
                    PendulumGame.State.Players[i].TrackActionIntensity();
                }

                // Player 1 - top actuator
                if (input.IsNewKeyPress(Keys.Q, null, out playerIndex) ||
                    input.IsNewButtonPress(Buttons.B, PlayerIndex.One, out playerIndex))
                {
                    PendulumGame.State.Players[0].ActionMarker = DoublePendulumHinges.Hinge1;
                }

                // Player 1 - bottom actuator
                if (input.IsNewKeyPress(Keys.A, null, out playerIndex) ||
                    input.IsNewButtonPress(Buttons.A, PlayerIndex.One, out playerIndex))
                {
                    PendulumGame.State.Players[0].ActionMarker = DoublePendulumHinges.Hinge2;
                }

                // Player 2 - top actuator
                if (input.IsNewKeyPress(Keys.Up, null, out playerIndex) ||
                    input.IsNewButtonPress(Buttons.B, PlayerIndex.Two, out playerIndex) ||
                    (PendulumGame.State.UseOnlyOneGamepad && input.IsNewButtonPress(Buttons.Y, PlayerIndex.One, out playerIndex)))
                {
                    PendulumGame.State.Players[1].ActionMarker = DoublePendulumHinges.Hinge1;
                }

                // Player 2 - bottom actuator
                if (input.IsNewKeyPress(Keys.Down, null, out playerIndex) ||
                    input.IsNewButtonPress(Buttons.A, PlayerIndex.Two, out playerIndex) ||
                    (PendulumGame.State.UseOnlyOneGamepad && input.IsNewButtonPress(Buttons.X, PlayerIndex.One, out playerIndex)))
                {
                    PendulumGame.State.Players[1].ActionMarker = DoublePendulumHinges.Hinge2;
                }

                // Player 1 - swing left or right
                if (input.IsKeyDown(Keys.Z, null, out playerIndex))
                {
                    PendulumGame.State.Players[0].ActionIntensity = -1.0;
                }
                else if (input.IsKeyDown(Keys.X, null, out playerIndex))
                {
                    PendulumGame.State.Players[0].ActionIntensity = 1.0;
                }
                else
                {
                    PendulumGame.State.Players[0].ActionIntensity =
                        input.CurrentGamePadStates[0].ThumbSticks.Left.X;
                }

                // Player 2 - swing left or right
                if (input.IsKeyDown(Keys.Left, null, out playerIndex))
                {
                    PendulumGame.State.Players[1].ActionIntensity = -1.0;
                }
                else if (input.IsKeyDown(Keys.Right, null, out playerIndex))
                {
                    PendulumGame.State.Players[1].ActionIntensity = 1.0;
                }
                else
                {

                    // Player 2 - swing with gamepad
                    if (PendulumGame.State.UseOnlyOneGamepad)
                    {
                        PendulumGame.State.Players[1].ActionIntensity =
                            input.CurrentGamePadStates[0].ThumbSticks.Right.X;
                    }
                    else
                    {
                        PendulumGame.State.Players[1].ActionIntensity =
                            input.CurrentGamePadStates[1].ThumbSticks.Left.X;
                    }
                }

                // Keep track of action intensity
                for (int i = 0; i < PendulumGameState.NumPlayers; i++)
                {
                    PendulumGame.State.Players[i].TrackActionIntensity();
                }

                // Player 1 - display switch
                if (input.IsNewKeyPress(Keys.LeftShift, null, out playerIndex) ||
                    input.IsNewButtonPress(Buttons.LeftTrigger, PlayerIndex.One, out playerIndex))
                {
                    PendulumGame.State.Players[0].SelectedIndicator++;
                    PendulumGame.State.Players[0].SelectedIndicator %= (valueIndicators.Length / 2);
                    triggerAudio1 = true;
                }
                else if (input.IsNewButtonPress(Buttons.RightTrigger, PlayerIndex.One, out playerIndex))
                {
                    PendulumGame.State.Players[0].SelectedIndicator--;
                    if (PendulumGame.State.Players[0].SelectedIndicator < 0)
                    {
                        PendulumGame.State.Players[0].SelectedIndicator += (valueIndicators.Length / 2);
                    }
                }

                // Player 2 - display switch audio trigger
                if (input.IsNewKeyPress(Keys.RightShift, null, out playerIndex) ||
                    input.IsNewButtonPress(Buttons.LeftTrigger, PlayerIndex.Two, out playerIndex) ||
                    (PendulumGame.State.UseOnlyOneGamepad &&
                     input.IsNewButtonPress(Buttons.RightTrigger, PlayerIndex.One, out playerIndex)))
                {
                    PendulumGame.State.Players[1].SelectedIndicator++;
                    PendulumGame.State.Players[1].SelectedIndicator %= (valueIndicators.Length / 2);
                    triggerAudio2 = true;
                }
                else if (input.IsNewButtonPress(Buttons.RightTrigger, PlayerIndex.Two, out playerIndex))
                {
                    PendulumGame.State.Players[1].SelectedIndicator--;
                    if (PendulumGame.State.Players[1].SelectedIndicator < 0)
                    {
                        PendulumGame.State.Players[1].SelectedIndicator += (valueIndicators.Length / 2);
                    }
                }

                // Early game-over
                if (input.IsNewKeyPress(Keys.G, null, out playerIndex))
                {
                    ScreenManager.AddScreen(
                        new PendulumGameOverScreen(), null);
                }
            }
        }

override void PendulumGame.PendulumGameplayScreen.LoadContent

(

)

[virtual]

Load graphics content for the game.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 168 of file PendulumGameplayScreen.cs.

        {
            if (contentManager == null)
            {
                contentManager = new ContentManager(ScreenManager.Game.Services, "Content");
            }

            // Local viewport
            Viewport viewport = ScreenManager.GraphicsDevice.Viewport;

            // Initialize the game players
            for (int i = 0; i < PendulumGameState.NumPlayers; i++)
            {
                PendulumGame.State.Players[i] = new GamePlayer();
                PendulumGame.State.Players[i].ActionMarker = DoublePendulumHinges.Hinge1;
            }

            // Set gravity
            GravityCalculator gravityCalculator = new GravityCalculator(PendulumGame.State.CurrentCelestialObject);
            PendulumGame.State.CurrentGravity = gravityCalculator.Value;

            // Create physical element(s)
            double size = 1.0;
            double size2 = 1.0;
            double mass = 1.0;
            double mass2 = 1.0;

            this.screenOrigin =
                new Vector2((float)(viewport.Width / 2.0), (float)(viewport.Height / 2.0));
            this.screenScale = 140.0;

            // Pendulums
            this.animatedDoubleRegularPendulum = new DoubleRegularPendulum(
                ScreenManager,
                new Vector2(-2.0f, 0.0f),
                size,
                mass,
                size2,
                mass2,
                PendulumGame.State.CurrentGravity,
                PendulumGame.State.CurrentRotationalFrictionType,
                screenOrigin,
                screenScale);

            this.animatedDoubleSquarePendulum = new DoubleSquarePendulum(
                ScreenManager,
                new Vector2(2.0f, 0.0f),
                size * (82.8427 / 100.0),
                mass,
                PendulumGame.State.CurrentGravity,
                PendulumGame.State.CurrentRotationalFrictionType,
                screenOrigin,
                screenScale);

            // Plotters
            dotPlotters = new DotPlotter[2];
            dotPlotters[0] = new DotPlotter(2 * 1024);
            dotPlotters[1] = new DotPlotter(2 * 1024);
            dotPlotterDisplacement = new Vector2[2];
            dotPlotterDisplacement[0] =
                new Vector2(0.5f * PendulumGame.State.Scale.X, 0.0f);
            dotPlotterDisplacement[1] =
                new Vector2(-0.5f * PendulumGame.State.Scale.X, 0.0f);

            // Energy Indicators
            energyIndicators = new EnergyIndicator[2];
            energyIndicators[0] = new EnergyIndicator(ScreenManager, "E");
            energyIndicators[1] = new EnergyIndicator(ScreenManager, "E");

            // Indicators
            valueIndicators = new ValueIndicator[8];
            valueIndicators[0] = new ValueIndicator(ScreenManager, "A Angle Inner", "{0,20:####.##} deg", -180, 180);
            valueIndicators[1] = new ValueIndicator(ScreenManager, "B Angle Inner", "{0,20:####.##} deg", -180, 180);
            valueIndicators[2] = new ValueIndicator(ScreenManager, "A Angle Outer", "{0,20:####.##} deg", -180, 180);
            valueIndicators[3] = new ValueIndicator(ScreenManager, "B Angle Outer", "{0,20:####.##} deg", -180, 180);
            valueIndicators[4] = new ValueIndicator(ScreenManager, "A Speed Inner", "{0,20:####.##} 1/s", -20, 20);
            valueIndicators[5] = new ValueIndicator(ScreenManager, "B Speed Inner", "{0,20:####.##} 1/s", -20, 20);
            valueIndicators[6] = new ValueIndicator(ScreenManager, "A Speed Outer", "{0,20:####.##} 1/s", -20, 20);
            valueIndicators[7] = new ValueIndicator(ScreenManager, "B Speed Outer", "{0,20:####.##} 1/s", -20, 20);

            // Place all indicators at the bottom in the same spot
            float yPos;
            yPos = viewport.Height - EnergyIndicator.Height - 10.0f;
            energyIndicators[0].SetPosition(new Vector2(5.0f, yPos));
            energyIndicators[1].SetPosition(new Vector2(viewport.Width - EnergyIndicator.Width - 5.0f, yPos));
            yPos = viewport.Height - ValueIndicator.Height - 10.0f + 1.0f;
            for (int i = 0; i < 4; i++)
            {
                valueIndicators[2 * i].SetPosition(new Vector2(25.0f, yPos));
                valueIndicators[2 * i + 1].SetPosition(new Vector2(viewport.Width - ValueIndicator.Width - 25.0f, yPos));
            }

            // Create shooting gallery across screen
            float simulationHeight = 0.3f;
            float simulationWidth = 8.0f;
            this.shootingGallery =
                new ShootingGallery(
                    ScreenManager,
                    new Vector2(-simulationWidth / 2.0f, -2.0f),
                    simulationWidth,
                    simulationHeight,
                    screenOrigin,
                    screenScale);
            this.shootingGallery.TargetConveyerSpeed = 0.005;
            CelestialBody celestialBody =
                new CelestialBody(PendulumGame.State.CurrentCelestialObject);
            string[] targetTypes = new string[12];
            string[] targetChoices = Enum.GetNames(typeof(ShootingGalleryTargetType));
            for (int i = 0; i < targetTypes.Length; i++)
            {
                int randomChoice = PendulumGame.State.PhysicalRandomNumberGenerator.Next(
                        0,
                        targetChoices.Length - 1);
                targetTypes[i] = targetChoices[randomChoice];
            }

            shootingGallery.Reset(
                targetTypes,
                PendulumGame.State.CurrentGravity,
                celestialBody.GetAtmosphericDensity());

            PendulumGame.State.PhysicalRandomNumberGenerator.Next(0, 2);

            // Action indicators
            actionIndicators = new RotationalActionIndicator[2];
            actionIndicators[0] = new RotationalActionIndicator(ScreenManager);
            actionIndicators[1] = new RotationalActionIndicator(ScreenManager);

            // Random number generators
            entropyCollectors = new AdvancedEntropyCollector[2];
            entropyCollectors[0] = new AdvancedEntropyCollector();
            entropyCollectors[1] = new AdvancedEntropyCollector();

            // Reset bit count
            PendulumGame.State.SubmittedEntropyBits = 0;

            // Pick random info link on 'randomness' and send it
            Program.Game.SendRandomInfoLink("Randomness");

            // Load laplace effect
            this.laplaceOverlay = new LaplaceOverlay(this.ScreenManager);
            this.laplaceOverlay.LoadContent();

            // Load bloom effect
            this.bloomOverlay = new BloomOverlay(this.ScreenManager);
            this.bloomOverlay.LoadContent();

            // Reset game time
            ScreenManager.Game.ResetElapsedTime();

            // Start audio playback
            this.audioPlayer.Play(new PullAudioCallback(PendulumFiller));
        }

override void PendulumGame.PendulumGameplayScreen.UnloadContent

(

)

[virtual]

Unload graphics content used by the game screen.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 325 of file PendulumGameplayScreen.cs.

        {
            // Stop playback
            this.audioPlayer.Stop();

            // Unload laplace effect
            this.laplaceOverlay.UnloadContent();

            // Unload bloom effect
            this.bloomOverlay.UnloadContent();

            // Pick random info link on 'randomness' and send it 
            Program.Game.SendRandomInfoLink("Randomness");

            // Maybe send entropy to service
            CheckAndSubmitEntropy(0, 1);
            CheckAndSubmitEntropy(1, 1);

            // Unload all content
            contentManager.Unload();

            // Unload base 
            base.UnloadContent();
        }

override void PendulumGame.PendulumGameplayScreen.Update	(	GameTime	gameTime,
		bool	otherScreenHasFocus,
		bool	coveredByOtherScreen
	)			[virtual]

Updates the state of the game. This method checks the GameScreen.IsActive property, so the game will stop updating when the pause menu is active, or if you tab away to a different application.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 360 of file PendulumGameplayScreen.cs.

        {
            base.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen);

            if (IsActive)
            {
                Vector2[] pendulumPoints;
                double rotation;

                // ----------- Update simulations ---------

                Viewport viewport = ScreenManager.GraphicsDevice.Viewport;

                // Move plotter points
                dotPlotters[0].MoveDots(dotPlotterDisplacement[0]);
                dotPlotters[1].MoveDots(dotPlotterDisplacement[1]);

                // Player A: Animate double pendulum

                // Maybe drive pendulum
                rotation = animatedDoubleRegularPendulum.Pendulum.Drive(
                        PendulumGame.State.Players[0].ActionMarker,
                        PendulumGame.State.Players[0].ActionIntensity);

                // Update action indicator
                actionIndicators[0].Animate(rotation);

                // Update pendulum animation
                animatedDoubleRegularPendulum.Pendulum.Animate();

                // Get pendulum locations in screen coordinates
                pendulumPoints =
                    animatedDoubleRegularPendulum.Pendulum.GetPosition(this.screenOrigin, this.screenScale);

                // Updated Plotter
                dotPlotters[0].AddDot(pendulumPoints[2], new Color(255, 0, 0), 0);

                // Update action indicator position
                switch (PendulumGame.State.Players[0].ActionMarker)
                {
                    case DoublePendulumHinges.Hinge1:
                        actionIndicators[0].SetPosition(pendulumPoints[0]);
                        break;
                    case DoublePendulumHinges.Hinge2:
                        actionIndicators[0].SetPosition(pendulumPoints[1]);
                        break;
                }

                // Get pendulum locations in simulation coordinates
                pendulumPoints =
                    animatedDoubleRegularPendulum.Pendulum.GetPosition();

                // Check if Player A hits targets
                int hitsA = shootingGallery.ShootAtTargets(pendulumPoints[2], 0.01);
                if (hitsA > 0)
                {
                    PendulumGame.State.Players[0].Points += hitsA;

                    // Pick random info link on 'pendulums' and send it 
                    Program.Game.SendRandomInfoLink("DoublePendulum");
                }

                // Player B: Animate double square pendulum

                // Maybe drive pendulum
                rotation = animatedDoubleSquarePendulum.Pendulum.Drive(
                        PendulumGame.State.Players[1].ActionMarker,
                        PendulumGame.State.Players[1].ActionIntensity);

                // Update action indicator
                actionIndicators[1].Animate(rotation);

                // Update pendulum animation
                animatedDoubleSquarePendulum.Pendulum.Animate();

                // Get pendulum locations in screen coordinates
                pendulumPoints =
                    animatedDoubleSquarePendulum.Pendulum.GetPosition(this.screenOrigin, this.screenScale);

                // Updated Plotter
                dotPlotters[1].AddDot(pendulumPoints[6], new Color(0, 0, 192), 0);

                // Update action indicator position
                switch (PendulumGame.State.Players[1].ActionMarker)
                {
                    case DoublePendulumHinges.Hinge1:
                        actionIndicators[1].SetPosition(pendulumPoints[0]);
                        break;
                    case DoublePendulumHinges.Hinge2:
                        actionIndicators[1].SetPosition(pendulumPoints[4]);
                        break;
                }

                // Get pendulum locations in simulation coordinates
                pendulumPoints =
                    animatedDoubleSquarePendulum.Pendulum.GetPosition();

                // Check if Player B hits targets
                int hitsB = shootingGallery.ShootAtTargets(pendulumPoints[6], 0.01);
                if (hitsB > 0)
                {
                    PendulumGame.State.Players[1].Points += hitsB;

                    // Pick random info link on 'pendulums' and send it 
                    Program.Game.SendRandomInfoLink("DoublePendulum");
                }

                // Animate shooting gallery
                shootingGallery.Update(gameTime);

                // Check for game over
                if (shootingGallery.NumActiveTargets == 0)
                {
                    // Maybe send entropy to service
                    CheckAndSubmitEntropy(0, 1);
                    CheckAndSubmitEntropy(1, 1);

                    ScreenManager.AddScreen(
                        new PendulumGameOverScreen(), null);
                }

                // Update all indicator values
                double e1 = animatedDoubleRegularPendulum.Pendulum.GetEnergy();
                energyIndicators[0].SetValue(e1);

                double e2 = animatedDoubleSquarePendulum.Pendulum.GetEnergy();
                energyIndicators[1].SetValue(e2);

                double[] a1 = animatedDoubleRegularPendulum.Pendulum.GetAngle();
                valueIndicators[0].SetValue(ToDegree(a1[0]));
                valueIndicators[2].SetValue(ToDegree(a1[1]));

                double[] a2 = animatedDoubleSquarePendulum.Pendulum.GetAngle();
                valueIndicators[1].SetValue(ToDegree(a2[0]));
                valueIndicators[3].SetValue(ToDegree(a2[1]));

                double[] v1 = animatedDoubleRegularPendulum.Pendulum.GetVelocity();
                valueIndicators[4].SetValue(v1[0]);
                valueIndicators[6].SetValue(v1[1]);

                double[] v2 = animatedDoubleSquarePendulum.Pendulum.GetVelocity();
                valueIndicators[5].SetValue(v2[0]);
                valueIndicators[7].SetValue(v2[1]);

                // Pick up randomness

                // Enough energy in the pendulum of player A?
                if (e1 > MinimumEnergyForEntropyCollection)
                {
                    if (PendulumGame.State.Players[1].ActionIntensityChanged())
                    {
                        CollectEntropyFromPlayerA();
                    }
                }

                // Enough energy in the pendulum of player B
                if (e2 > MinimumEnergyForEntropyCollection)
                {
                    if (PendulumGame.State.Players[0].ActionIntensityChanged())
                    {
                        CollectEntropyFromPlayerB();
                    }
                }

                // Active pendulum 1 sound
                if ((this.audioPendulum1 == null) &&
                    (this.audioPendulumSamplesRemaining[0] == 0))
                {
                    if ((!PendulumGame.State.RealtimeAudioOnDemand) || (triggerAudio1))
                    {
                        // Reset trigger
                        triggerAudio1 = false;

                        // Current state
                        double[] angles = this.animatedDoubleRegularPendulum.Pendulum.GetAngle();
                        double[] velocities = this.animatedDoubleRegularPendulum.Pendulum.GetVelocity();

                        float theta1 = MathHelper.WrapAngle((float)angles[0]);
                        float theta2 = MathHelper.WrapAngle((float)angles[1]);

                        // New Pendulum
                        DoubleRegularPendulumSimulation audioPendulum =
                            new DoubleRegularPendulumSimulation(
                                new Vector2(),
                                0.1, 1.0, 0.1, 1.0,
                                PendulumGame.State.CurrentGravity,
                                PendulumGame.State.CurrentRotationalFrictionType);
                        audioPendulum.SetInitialConditions(
                                (double)theta1, velocities[0], (double)theta2, velocities[1]);

                        // Activate
                        this.audioPendulumSamplesRemaining[0] = 38000;
                        this.audioPendulum1 = audioPendulum;
                    }
                }
                else
                {
                    if (this.audioPendulumSamplesRemaining[0] == 0)
                    {
                        this.audioPendulum1 = null;
                    }
                }

                // Active pendulum 2 sound
                if ((this.audioPendulum2 == null) &&
                    (this.audioPendulumSamplesRemaining[1] == 0))
                {
                    if ((!PendulumGame.State.RealtimeAudioOnDemand) || (triggerAudio2))
                    {
                        // Reset trigger
                        triggerAudio2 = false;

                        // Current state
                        double[] angles = this.animatedDoubleSquarePendulum.Pendulum.GetAngle();
                        double[] velocities = this.animatedDoubleSquarePendulum.Pendulum.GetVelocity();

                        float theta1 = MathHelper.WrapAngle((float)angles[0]);
                        float theta2 = MathHelper.WrapAngle((float)angles[1]);

                        // New Pendulum
                        DoubleSquarePendulumSimulation audioPendulum =
                            new DoubleSquarePendulumSimulation(
                                new Vector2(),
                                0.1, 1.0,
                                PendulumGame.State.CurrentGravity,
                                PendulumGame.State.CurrentRotationalFrictionType);
                        audioPendulum.SetInitialConditions(
                                (double)theta1, velocities[0], (double)theta2, velocities[1]);

                        // Activate
                        this.audioPendulumSamplesRemaining[1] = 44000;
                        this.audioPendulum2 = audioPendulum;
                    }
                }
                else
                {
                    if (this.audioPendulumSamplesRemaining[1] == 0)
                    {
                        this.audioPendulum2 = null;
                    }
                }
            }
        }

---

The documentation for this class was generated from the following file:

• C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/PendulumGame/Screens/PendulumGameplayScreen.cs