public override IMethodReturn Invoke(Microsoft.Practices.Unity.InterceptionExtension.IMethodInvocation input, Microsoft.Practices.Unity.InterceptionExtension.GetNextHandlerDelegate getNext)
 {
     IMethodReturn methodReturn = null;
     try
     {
         try
         {
             methodReturn = getNext()(input, getNext);
         }
         catch (Exception exception1)
         {
             Exception exception = exception1;
             methodReturn = input.CreateMethodReturn(null);
             methodReturn.Exception = exception;
         }
     }
     finally
     {
         if (methodReturn.Exception != null)
         {
             methodReturn.Exception = this.HandlerException(input, methodReturn.Exception);
         }
     }
     return methodReturn;
 }

        /// <summary>
        /// Main game loop, checks for UI-related inputs and tells game objects to update.
        /// </summary>
        /// <param name="gameTime"></param>
        /// <returns></returns>
        public override void update(Microsoft.Xna.Framework.GameTime gameTime)
        {
            //if (InputSet.getInstance().getButton(InputsEnum.BUTTON_3))
            //{
            //    EngineManager.pushState(new EngineStateMap());
            //    return;
            //}

            Area area = GameplayManager.ActiveArea;
            area.GameObjects.ForEach(i => i.update());
            area.GameObjects.ForEach(i => { if (!i.isAlive() && i is ICollidable) ((ICollidable)i).getCollider().unregister(); });
            area.GameObjects.RemoveAll(i => !i.isAlive());

            // This is the code to add a house when the mouse is clicked. We don't need this.
            //if (InputSet.getInstance().getButton(InputsEnum.LEFT_TRIGGER))
            //{
            //    InputSet.getInstance().setToggle(InputsEnum.LEFT_TRIGGER);

            //    Vector2 rclickspot = new Vector2(InputSet.getInstance().getRightDirectionalX(), InputSet.getInstance().getRightDirectionalY());
            //    DecorationSet ds = DecorationSet.construct("World/town");
            //    Decoration d = ds.makeDecoration("house1", rclickspot);

            //    GameplayManager.ActiveArea.add(d);
            //}
        }

 public override void Draw(Microsoft.Xna.Framework.GameTime gameTime)
 {
     spriteBatch.Begin();
     spriteBatch.Draw(Art.gameover, new Rectangle(0, 0, 1280, 720), Microsoft.Xna.Framework.Color.White);
     //spriteBatch.DrawString(Art.Font, "GAME OVER MOTHERFUCKER", new Microsoft.Xna.Framework.Vector2(550, 360),Microsoft.Xna.Framework.Color.Red);
     spriteBatch.End();
 }

        public override void Draw(Microsoft.Xna.Framework.Graphics.Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
        {

            if (firstTime)
            {
                oldViewProjection = world.CameraManager.ActiveCamera.ViewProjection;
                firstTime = false;
            }

            effect.Parameters["attenuation"].SetValue(Attenuation);
            effect.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
            effect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(world.CameraManager.ActiveCamera.ViewProjection));
            effect.Parameters["oldViewProjection"].SetValue(oldViewProjection);
            effect.Parameters["numSamples"].SetValue(NumSamples);
            effect.Parameters["depth"].SetValue(rHelper[PrincipalConstants.DephRT]);
            effect.Parameters["extra"].SetValue(rHelper[PrincipalConstants.extra1RT]);
            effect.Parameters["cena"].SetValue(ImageToProcess);

            oldViewProjection = world.CameraManager.ActiveCamera.ViewProjection;

            if (useFloatBuffer)
                rHelper.RenderFullScreenQuadVertexPixel(effect, SamplerState.PointClamp);
            else
                rHelper.RenderFullScreenQuadVertexPixel(effect, GraphicInfo.SamplerState);
        }

 public static void FeatureSetup(Microsoft.VisualStudio.TestTools.UnitTesting.TestContext testContext)
 {
     testRunner = TechTalk.SpecFlow.TestRunnerManager.GetTestRunner();
     TechTalk.SpecFlow.FeatureInfo featureInfo = new TechTalk.SpecFlow.FeatureInfo(new System.Globalization.CultureInfo("de-DE"), "Speichern der Personenstammdaten", "Als Verwaltungsfachangestellter möchte ich eine Person mit ihrem Vor- und Zunahme" +
             "n, sowie Geburtsdatum anlegen können.", ProgrammingLanguage.CSharp, ((string[])(null)));
     testRunner.OnFeatureStart(featureInfo);
 }

 private AudioManager(Microsoft.Xna.Framework.Game game, string settingsFile, string waveBankFile, string soundBankFile)
     : base(game)
 {
     this.SoundEffectInstances = new List<SoundEffectInstance>();
     try
     {
         this.audioEngine = new AudioEngine(settingsFile);
         this.waveBank = new WaveBank(this.audioEngine, waveBankFile, 0, 16);
         this.soundBank = new SoundBank(this.audioEngine, soundBankFile);
     }
     catch (NoAudioHardwareException)
     {
         this.audioEngine = null;
         this.waveBank = null;
         this.soundBank = null;
     }
     catch (InvalidOperationException)
     {
         this.audioEngine = null;
         this.waveBank = null;
         this.soundBank = null;
     }
     while (!this.waveBank.IsPrepared)
     {
         this.audioEngine.Update();
     }
 }

 public static void FeatureSetup(Microsoft.VisualStudio.TestTools.UnitTesting.TestContext testContext)
 {
     testRunner = TechTalk.SpecFlow.TestRunnerManager.GetTestRunner();
     TechTalk.SpecFlow.FeatureInfo featureInfo = new TechTalk.SpecFlow.FeatureInfo(new System.Globalization.CultureInfo("en-US"), "Score Calculation", "As a player\r\nI want the system to calculate my total score\r\nSo that I know my per" +
             "formance", GenerationTargetLanguage.CSharp, ((string[])(null)));
     testRunner.OnFeatureStart(featureInfo);
 }

 /// <summary>
 /// Handles the button press event to track which focused menu item will get the activation
 /// </summary>
 /// <param name="backButton"></param>
 /// <param name="startButton"></param>
 /// <param name="systemButton"></param>
 /// <param name="aButton"></param>
 /// <param name="bButton"></param>
 /// <param name="xButton"></param>
 /// <param name="yButton"></param>
 /// <param name="leftShoulder"></param>
 /// <param name="rightShoulder"></param>
 /// <param name="player"></param>
 protected override void OnGamePadButtonUpdate(CCGamePadButtonStatus backButton, CCGamePadButtonStatus startButton, CCGamePadButtonStatus systemButton, CCGamePadButtonStatus aButton, CCGamePadButtonStatus bButton, CCGamePadButtonStatus xButton, CCGamePadButtonStatus yButton, CCGamePadButtonStatus leftShoulder, CCGamePadButtonStatus rightShoulder, Microsoft.Xna.Framework.PlayerIndex player)
 {
     base.OnGamePadButtonUpdate(backButton, startButton, systemButton, aButton, bButton, xButton, yButton, leftShoulder, rightShoulder, player);
     if (!HasFocus)
     {
         return;
     }
     if (backButton == CCGamePadButtonStatus.Pressed || aButton == CCGamePadButtonStatus.Pressed || bButton == CCGamePadButtonStatus.Pressed ||
         xButton == CCGamePadButtonStatus.Pressed || yButton == CCGamePadButtonStatus.Pressed || leftShoulder == CCGamePadButtonStatus.Pressed ||
         rightShoulder == CCGamePadButtonStatus.Pressed)
     {
         CCMenuItem item = FocusedItem;
         item.Selected();
         m_pSelectedItem = item;
         m_eState = CCMenuState.TrackingTouch;
     }
     else if (backButton == CCGamePadButtonStatus.Released || aButton == CCGamePadButtonStatus.Released || bButton == CCGamePadButtonStatus.Released ||
         xButton == CCGamePadButtonStatus.Released || yButton == CCGamePadButtonStatus.Released || leftShoulder == CCGamePadButtonStatus.Released ||
         rightShoulder == CCGamePadButtonStatus.Released)
     {
         if (m_eState == CCMenuState.TrackingTouch)
         {
             // Now we are selecting the menu item
             CCMenuItem item = FocusedItem;
             if (item != null && m_pSelectedItem == item)
             {
                 // Activate this item
                 item.Unselected();
                 item.Activate();
                 m_eState = CCMenuState.Waiting;
                 m_pSelectedItem = null;
             }
         }
     }
 }

        public void Initialize(Microsoft.SqlServer.Dts.Pipeline.Wrapper.IDTSComponentMetaData100 dtsComponentMetadata, IServiceProvider serviceProvider)
        {
            this.serviceProvider = serviceProvider;
              this.metaData = dtsComponentMetadata;

              this.connectionService = (IDtsConnectionService)serviceProvider.GetService(typeof(IDtsConnectionService));
        }

 public override bool Shoot(Player player, ref Microsoft.Xna.Framework.Vector2 position, ref float speedX, ref float speedY, ref int type, ref int damage, ref float knockBack)
 {
     Vector2 direction = new Vector2(speedX, speedY);
     direction.Normalize();
     position += direction * item.width;
     return true;
 }

        public void MiseÀJour(Microsoft.Xna.Framework.GameTime p_gameTime)
        {
            KeyboardState kbs = Keyboard.GetState();

            if (kbs.IsKeyDown(m_touche))
            {
                m_toucheEnfoncé = true;
                m_gestionnaireÉtat.ChangetÉtat(new ClÉtatHistoire(m_gestionnaireÉtat));
            }

            m_msDepuisMÀJ += p_gameTime.ElapsedGameTime.TotalMilliseconds;

            if (m_msDepuisMÀJ >= m_msEntreMÀJ)
            {
                if (++m_indice > m_messageCommencement.Length)
                    m_indice = 0;

                if (m_toucheEnfoncé)
                    m_couleurTexte = (m_couleurTexte == COULEUR_TEXTE_FLASH) ? COULEUR_TEXTE_NORMAL : COULEUR_TEXTE_FLASH;

                m_msDepuisMÀJ -= m_msEntreMÀJ;
            }

            m_texteÀAfficher = m_messageCommencement.Substring(0, (m_toucheEnfoncé) ? m_messageCommencement.Length : m_indice);
        }

        /// <summary>
        /// Checks the gesture.
        /// </summary>
        /// <param name="skeleton">The skeleton.</param>
        /// <returns>GesturePartResult based on if the gesture part has been completed</returns>
        public GesturePartResult CheckGesture(Microsoft.Kinect.Skeleton skeleton)
        {
            // //left hand in front of left Shoulder
            if (skeleton.Joints[JointType.HandLeft].Position.Z < skeleton.Joints[JointType.ElbowLeft].Position.Z && skeleton.Joints[JointType.HandRight].Position.Y < skeleton.Joints[JointType.HipCenter].Position.Y)
            {
                // Debug.WriteLine("GesturePart 1 - left hand in front of left Shoulder - PASS");
                // /left hand below shoulder height but above hip height
                if (skeleton.Joints[JointType.HandLeft].Position.Y < skeleton.Joints[JointType.Head].Position.Y && skeleton.Joints[JointType.HandLeft].Position.Y > skeleton.Joints[JointType.HipCenter].Position.Y)
                {
                    // Debug.WriteLine("GesturePart 1 - left hand below shoulder height but above hip height - PASS");
                    // //left hand left of left Shoulder
                    if (skeleton.Joints[JointType.HandLeft].Position.X < skeleton.Joints[JointType.ShoulderRight].Position.X && skeleton.Joints[JointType.HandLeft].Position.X > skeleton.Joints[JointType.ShoulderLeft].Position.X)
                    {
                        // Debug.WriteLine("GesturePart 1 - left hand left of left Shoulder - PASS");
                        return GesturePartResult.Suceed;
                    }

                    // Debug.WriteLine("GesturePart 1 - left hand left of left Shoulder - UNDETERMINED");
                    return GesturePartResult.Pausing;
                }

                // Debug.WriteLine("GesturePart 1 - left hand below shoulder height but above hip height - FAIL");
                return GesturePartResult.Fail;
            }

            // Debug.WriteLine("GesturePart 1 - left hand in front of left Shoulder - FAIL");
            return GesturePartResult.Fail;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="skel"></param>
        /// <returns></returns>
        protected override double AddToAverage(Microsoft.Kinect.Skeleton skel)
        {
            SkeletonPoint hand = JointToPos(skel, handType);
            SkeletonPoint torso = JointToPos(skel, JointType.Spine);

            return SkelPointMath.XZDistance(hand, torso);
        }

 public static String InterpretKey(Microsoft.Xna.Framework.Input.Keys key)
 {
     if (m_CameraControls.ContainsKey(key))
         return m_CameraControls[key];
     else
         return Enum.GetName(key.GetType(), key);
 }

        public override void LoadContent(Microsoft.Xna.Framework.Content.ContentManager content)
        {
            //do not remove this
            base.LoadBasicContent(content);

            logo = content.Load<Texture2D>("logo");
        }

 public void Packets(Microsoft.StylusInput.RealTimeStylus sender, Microsoft.StylusInput.PluginData.PacketsData data)
 {
     for (int i = 0; i < data.Count; i += data.PacketPropertyCount)
     {
         Interpret(data, i);
     }
 }

        /// <summary>
        /// Updates a task, or creates it if not existing
        /// </summary>
        /// <param name="aName">Task Name</param>
        /// <param name="aTask">Action to run</param>
        /// <param name="aDescription">Plain text</param>
        /// <param name="aUserName">Domain/User</param>
        /// <param name="aPassword">Secure password</param>
        /// <param name="aTrigger">Trigger to use</param>
        /// <param name="aArgument">Arguments to Action</param>
        public static void CreateOrUpdateTask(string aName, string aTask, string aDescription, string aUserName, 
            System.Security.SecureString aPassword,
            Microsoft.Win32.TaskScheduler.Trigger aTrigger, string aArgument)
        {
            // Get the service on the local machine
            using (Microsoft.Win32.TaskScheduler.TaskService ts = new Microsoft.Win32.TaskScheduler.TaskService())
            {
                // Create a new task definition and assign properties
                Microsoft.Win32.TaskScheduler.TaskDefinition td = ts.NewTask();
                td.RegistrationInfo.Description = aDescription;
                td.RegistrationInfo.Author = "XervBackup Scheduler";

                // Create a trigger that will fire the task
                td.Triggers.Add(aTrigger);
                td.Settings.WakeToRun = true;

                // Create an action that will launch the task whenever the trigger fires
                td.Actions.Add(new Microsoft.Win32.TaskScheduler.ExecAction(aTask, aArgument, null));
                if (ts.HighestSupportedVersion > new Version(1, 2))
                {
                    td.Principal.LogonType = Microsoft.Win32.TaskScheduler.TaskLogonType.Password;
                    td.Principal.RunLevel = Microsoft.Win32.TaskScheduler.TaskRunLevel.LUA;
                }

                // Register the task in the root folder
                string contents = null;
                if (aPassword != null)
                {
                    IntPtr ptr = System.Runtime.InteropServices.Marshal.SecureStringToBSTR(aPassword);
                    contents = System.Runtime.InteropServices.Marshal.PtrToStringAuto(ptr);
                }
                ts.RootFolder.RegisterTaskDefinition(aName, td, Microsoft.Win32.TaskScheduler.TaskCreation.CreateOrUpdate,
                    aUserName, contents, Microsoft.Win32.TaskScheduler.TaskLogonType.Password, null);
            }
        }

        internal static void SetReferences(Transform transform, BizTalkArtifacts artifacts, Microsoft.BizTalk.ExplorerOM.Transform omTransform)
        {
            transform.Application = artifacts.Applications[omTransform.Application.Id()];
            transform.ParentAssembly = artifacts.Assemblies[omTransform.BtsAssembly.Id()];

            //As it's possible to exclude application we don't always have all schemas. Only add source schema if we have.
            if (artifacts.Schemas.ContainsKey(omTransform.SourceSchema.Id()))
            {
                transform.SourceSchema = artifacts.Schemas[omTransform.SourceSchema.Id()]; ;
            }

            //As it's possible to exclude application we don't always have all schemas. Only add target schema if we have.
            if (artifacts.Schemas.ContainsKey(omTransform.TargetSchema.Id()))
            {
                transform.TargetSchema = artifacts.Schemas[omTransform.TargetSchema.Id()];
            }

            transform.ReceivePorts.AddRange(
                artifacts.ReceivePorts.Where(rp => rp.Value.InboundTransforms.Select(t => t.Id).Contains(transform.Id)).Select(
                    rp => rp.Value));

            transform.SendPorts.AddRange(
            artifacts.SendPorts.Where(rp => rp.Value.OutboundTransforms.Select(t => t.Id).Contains(transform.Id)).Select(
                rp => rp.Value));
        }

 public override bool PreDraw(Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch, Color drawColor)
 {
     Texture2D texture = Main.npcTexture[npc.type];
     Vector2 origin = new Vector2(texture.Width * 0.5f, texture.Height * 0.5f);
     Main.spriteBatch.Draw(texture, npc.Center - Main.screenPosition, new Rectangle?(), drawColor, npc.rotation, origin, npc.scale, SpriteEffects.None, 0);
     return false;
 }

        public override void Draw(Microsoft.Xna.Framework.GameTime gameTime)
        {
            service.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Black);
            spriteBatch.Begin();
            spriteBatch.Draw(background, new Rectangle(0, 0, 800, 400), Color.White);

            if (hel_op == Heli_c.Relistic)
            {
                spriteBatch.Draw(rectangle, new Rectangle(130, 150, 150, 150), Color.White);
            }
            else
            {
            }
            if (hel_op == Heli_c.Semi)
            {
                spriteBatch.Draw(rectangle, new Rectangle(340, 150, 150, 150), Color.White);
            }
            else
            {
            }
            if (hel_op == Heli_c.Cartoon)
            {
                spriteBatch.Draw(rectangle, new Rectangle(520, 150, 150, 150), Color.White);
            }
            else
            {
            }

            spriteBatch.DrawString(spritefont, "Return to Main", new Vector2(200, 300), Color.White);
            spriteBatch.End();
        }