C# PlayerIndex类代码示例

        public Vector2 AmountFaceRightUp(PlayerIndex? controllingPlayer, out PlayerIndex playerIndex)
        {
            Vector2 amountFaceRightUp;
            bool w, a, s, d;
            w = a = s = d = false;
            if (controllingPlayer.HasValue && GamePad.GetState((PlayerIndex)controllingPlayer).IsConnected)
            {
                playerIndex = (PlayerIndex)controllingPlayer; //we have the player set if it's a controller.
                amountFaceRightUp = GamePad.GetState((PlayerIndex)controllingPlayer).ThumbSticks.Left;
            }
            else
            {
                w = IsKeyDown(Keys.W, controllingPlayer, out playerIndex);
                a = IsKeyDown(Keys.A, controllingPlayer, out playerIndex);
                s = IsKeyDown(Keys.S, controllingPlayer, out playerIndex);
                d = IsKeyDown(Keys.D, controllingPlayer, out playerIndex);

                float amountFaceRight = ((d) ? 1.0f : 0.0f) + (((a)) ? -1.0f : 0.0f);
                float amountFaceUp = ((w) ? 1.0f : 0.0f) + (((s)) ? -1.0f : 0.0f);

                amountFaceRightUp = new Vector2(amountFaceRight, amountFaceUp);
            }

            return amountFaceRightUp;
        }

 public Ship(PlayerIndex playerIndex, Texture2D txShipTexture,Texture2D txBulletTexture,WeaponTypes WeaponType)
 {
     this.player = playerIndex;
     this._weaponType = WeaponType;
     this.ShipTexture = txShipTexture;
     this._txBulletTexture = txBulletTexture;
 }

 internal PlayerInput(PlayerIndex playerIndex)
 {
     PlayerIndex = playerIndex;
     Index = (int)playerIndex;
     Keyboard = new Keyboard();
     Gamepad = new Gamepad(PlayerIndex);
 }

 public FlxGamepad(PlayerIndex IndexOfPlayer)
 {
     index = IndexOfPlayer;
     leftVibe = 0;
     rightVibe = 0;
     vibeDuration = 0;
 }

 public override void Start()
 {
     this.controllingPlayer = ((CharacterInformationComponent)Parent.GetComponent("CharacterInformationComponent")).PlayerIndex;
     this.movementComponent = (MoveComponent)Parent.GetComponent("MoveComponent");
     this.bepuPhysicsComponent = (BepuPhysicsComponent)Parent.GetComponent("BepuPhysicsComponent");
     this.health = (VitalityComponent)Parent.GetComponent("VitalityComponent");
 }

 public KeyboardHelper( Game game, PlayerIndex index )
     : base(game)
 {
     PressCount = new Dictionary<MeanOfKey, int>();
     Config = new Dictionary<Keys, MeanOfKey>();
     this.playerIndex = index;
 }

 public bool IsMenuSelected(PlayerIndex? controllingPlayer, out PlayerIndex playerIndex)
 {
     return IsNewKeyPress(Keys.Space, controllingPlayer, out playerIndex) ||
            IsNewKeyPress(Keys.Enter, controllingPlayer, out playerIndex) ||
            IsNewButtonPress(Buttons.A, controllingPlayer, out playerIndex) ||
            IsNewButtonPress(Buttons.Start, controllingPlayer, out playerIndex);
 }

 public GetInput(PlayerIndex index)
 {
     playerIndex = index;
     directionBoolArray = new bool[4] { upPressed, leftPressed, downPressed, rightPressed };
     oldKeyState = Keyboard.GetState();
     oldPadState = GamePad.GetState(playerIndex);
 }

        public bool Evaluate(InputState state, PlayerIndex? controllingPlayer, out PlayerIndex player)
        {
            ButtonPress buttonTest;
            KeyPress keyTest;

            if (newPressOnly)
            {
                buttonTest = state.IsNewButtonPress;
                keyTest = state.IsNewKeyPress;
            }
            else
            {
                buttonTest = state.IsButtonPressed;
                keyTest = state.IsKeyPressed;
            }

            foreach (Buttons button in buttons)
            {
                if (buttonTest(button, controllingPlayer, out player))
                    return true;
            }

            foreach (Keys key in keys)
            {
                if (keyTest(key, controllingPlayer, out player))
                    return true;
            }

            player = PlayerIndex.One;
            return false;
        }

 /// <summary>
 /// When the user cancels the main menu, ask if they want to exit the sample.
 /// </summary>
 protected override void OnCancel(PlayerIndex playerIndex)
 {
     const string message = "Are you sure you want to exit?";
     var confirmExitMessageBox = new MessageBoxScreen(message);
     confirmExitMessageBox.Accepted += ConfirmExitMessageBoxAccepted;
     ScreenManager.AddScreen(confirmExitMessageBox, playerIndex);
 }

        public PlayerKeyboard(IInputDevice inputDevice, PlayerIndex playerIndex)
        {
            if (inputDevice == null) throw new ArgumentNullException("inputDevice");

            InputDevice = inputDevice;
            PlayerIndex = playerIndex;
        }

        public InputManager(InputType type, PlayerIndex player)
        {
            this.inputType = type;
              this.playerIndex = player;

              // Populate Dictionary Entries
              inputToKeys = new Dictionary<Inputs, Keys>();
              inputToKeys.Add(Inputs.A, Keys.A);
              inputToKeys.Add(Inputs.B, Keys.S);
              inputToKeys.Add(Inputs.Back, Keys.Escape);
              inputToKeys.Add(Inputs.Up, Keys.Up);
              inputToKeys.Add(Inputs.Down, Keys.Down);
              inputToKeys.Add(Inputs.Left, Keys.Left);
              inputToKeys.Add(Inputs.Right, Keys.Right);
              inputToKeys.Add(Inputs.Start, Keys.Enter);
              inputToKeys.Add(Inputs.X, Keys.Z);
              inputToKeys.Add(Inputs.Y, Keys.X);

              inputToButtons = new Dictionary<Inputs, Buttons>();
              inputToButtons.Add(Inputs.A, Buttons.A);
              inputToButtons.Add(Inputs.B, Buttons.B);
              inputToButtons.Add(Inputs.Back, Buttons.Back);
              inputToButtons.Add(Inputs.Up, Buttons.DPadUp);
              inputToButtons.Add(Inputs.Down, Buttons.DPadDown);
              inputToButtons.Add(Inputs.Left, Buttons.DPadLeft);
              inputToButtons.Add(Inputs.Right, Buttons.DPadRight);
              inputToButtons.Add(Inputs.Start, Buttons.Start);
              inputToButtons.Add(Inputs.X, Buttons.X);
              inputToButtons.Add(Inputs.Y, Buttons.Y);

              inputToMouse = new Dictionary<Inputs, MouseButton>();
              inputToMouse.Add(Inputs.A, MouseButton.Left);
              inputToMouse.Add(Inputs.B, MouseButton.Right);
              inputToMouse.Add(Inputs.X, MouseButton.Middle);
        }

 public int this[PlayerIndex playerIndex]
 {
     get
     {
         return GetMatchScore(playerIndex);
     }
 }

        public EndScreen(PlayerIndex playerIndex, Color color)
        {
            Sprite bg = new Sprite();
            bg.LoadTexture(@"Assets/HeartBG");
            bg.Scale /= Controller.CurrentDrawCamera.zoom;
            this.AddChild(bg);

            heart = new Sprite();
            heart.LoadTexture(@"Assets/Heart");
            heart.Scale /= (Controller.CurrentDrawCamera.zoom * 1.1f);
            heart.Position.X += 110;
            this.AddChild(heart);

            slime = new Sprite();
            slime.LoadTexture(@"Assets/HeartSlime");
            slime.Scale /= (Controller.CurrentDrawCamera.zoom * 1.1f);
            slime.Position.X += 110;
            slime.Color = color;
            this.AddChild(slime);

            Label lbl = new Label("Player " + (float)(playerIndex + 1) + " has won!", Controller.FontController.GetFont("bigFont"));
            lbl.Position.X = ((Controller.ScreenSize.X / Controller.CurrentDrawCamera.zoom) / 2) - (lbl.Width / 2);
            AddChild(lbl);

            Label lblAdvance = new Label("Press A to apply CPR", Controller.FontController.GetFont("bigFont"));
            lblAdvance.Position.X = ((Controller.ScreenSize.X / Controller.CurrentDrawCamera.zoom) / 2) - (lblAdvance.Width / 2);
            lblAdvance.Position.Y = 550;
            AddChild(lblAdvance);

            ECGsound = Controller.Content.Load<SoundEffect>("sounds/ecg");
        }

        public UserControls(PlayerIndex playerIndex, float forceMag, float torqueMag, float forceShiftMag, float torqueShiftMag)
        {
            this.ForceMag = forceMag;
            this.TorqueMag = torqueMag;
            this.ForceShiftMag = forceShiftMag;
            this.TorqueShiftMag = torqueShiftMag;
            this.playerIndex = playerIndex;

            //default mappings
            KeyMappings[Keys.W] = UserControlKeys.MoveFoward;
            KeyMappings[Keys.S] = UserControlKeys.MoveBackward;
            KeyMappings[Keys.A] = UserControlKeys.MoveLeft;
            KeyMappings[Keys.D] = UserControlKeys.MoveRight;
            KeyMappings[Keys.Q] = UserControlKeys.TurnLeft;
            KeyMappings[Keys.Left] = UserControlKeys.TurnLeft;
            KeyMappings[Keys.E] = UserControlKeys.TurnRight;
            KeyMappings[Keys.Right] = UserControlKeys.TurnRight;
            KeyMappings[Keys.X] = UserControlKeys.MoveUp;
            KeyMappings[Keys.Z] = UserControlKeys.MoveDown;

            KeyMappings[Keys.Down] = UserControlKeys.LookUp;
            KeyMappings[Keys.Up] = UserControlKeys.LookDown;

            KeyMappings[Keys.T] = UserControlKeys.RollRight;
            KeyMappings[Keys.G] = UserControlKeys.RollLeft;

            KeyMappings[Keys.LeftShift] = UserControlKeys.Shifter;
            KeyMappings[Keys.RightShift] = UserControlKeys.Shifter;

            KeyMappings[Keys.LeftAlt] = UserControlKeys.PrimaryFire;
            KeyMappings[Keys.RightAlt] = UserControlKeys.SecondaryFire;
        }