private int clockspeed = 25; // 25 millisecond window for clock on joystick polling.
public ControllerEngine()
{
this.ActiveDevice = 0;
oldgstate = GamePad.GetState(this.ActiveDevice);
oldjstate = Joystick.GetState(this.ActiveDevice);
createNewTimer();
}
public MainWindow()
{
InitializeComponent();
createNewTimer();
oldgstate = GamePad.GetState(activeGamepad);
oldjstate = Joystick.GetState(activeJoystick);
}
public static void Update(GameTime dt)
{
JoyPrev = JoyState;
JoyState = GamePad.GetState(PlayerIndex.One);
KeyPrev = KeyState;
KeyState = Keyboard.GetState(PlayerIndex.One);
}
public DemoPlayerInputManager()
{
m_gamePads = new GamePadState[MAX_GAMEPADS_COUNT];
for (int i = 0; i < m_gamePads.Length; ++i)
{
m_gamePads[i] = new GamePadState(false);
}
m_keyboard = new KeyBoardState(null); // dummy param
}
public void UpdateState()
{
this.caps = GamePad.GetCapabilities(this.deviceIndex);
this.state = GamePad.GetState(this.deviceIndex);
// If it's not a well-known gamepad, check the corresponding joystick whether there are any axes or buttons
if (!this.caps.IsMapped)
{
JoystickCapabilities joystickCaps = Joystick.GetCapabilities(this.deviceIndex);
this.hasAxesOrButtons = joystickCaps.AxisCount > 0 || joystickCaps.ButtonCount > 0 || joystickCaps.HatCount > 0;
}
}
private static GamePadState PlatformGetState(int index, GamePadDeadZone deadZoneMode)
{
GamePadState state;
if (index == 0 && Back)
{
// Consume state
Back = false;
state = new GamePadState(new GamePadThumbSticks(), new GamePadTriggers(), new GamePadButtons(Buttons.Back), new GamePadDPad());
}
else
state = new GamePadState();
return state;
}
public GamePadState GetState(int index)
{
XInputState xstate;
XInputErrorCode error = xinput.GetState((XInputUserIndex)index, out xstate);
GamePadState state = new GamePadState();
if (error == XInputErrorCode.Success)
{
state.SetConnected(true);
state.SetAxis(GamePadAxes.LeftX, xstate.GamePad.ThumbLX);
state.SetAxis(GamePadAxes.LeftY, xstate.GamePad.ThumbLY);
state.SetAxis(GamePadAxes.RightX, xstate.GamePad.ThumbRX);
state.SetAxis(GamePadAxes.RightY, xstate.GamePad.ThumbRY);
state.SetTriggers(xstate.GamePad.LeftTrigger, xstate.GamePad.RightTrigger);
state.SetButton(TranslateButtons(xstate.GamePad.Buttons), true);
}
return state;
}
public static void Initialize()
{
JoyPrev = JoyState = GamePad.GetState(PlayerIndex.One);
KeyPrev = KeyState = Keyboard.GetState(PlayerIndex.One);
}
public void Update(GameTime gameTime, KeyboardState teclado, KeyboardState tecladoAnterior, GamePadState _controle, GamePadState _controleanterior)
{
if (!playing_musica)
{
MediaPlayer.Play(musica);
playing_musica = true;
}
jogador1.Update(gameTime, teclado, tecladoAnterior, _controle, _controleanterior);
inimigo1.Update(gameTime);
}
private bool Release(GamePadButtons k, GamePadState _state) => !Press(k, _state);
public void updateCam()
{
if (songStarted && t > 2)
{
var height = terrainRenderer.GetAltitude(camera.Transform.Position);
if (0.5f + height > camera.Transform.Position.Y)
{
// camera crashes
noisyToggle = true;
waveOut.Pause();
MediaPlayer.Play(staticNoise);
Time.timers.Add(new EventTimer(cameraRestore, 2));
}
else if (2 + height > camera.Transform.Position.Y)
{
// graze
}
}
else
if (camera.Transform.LocalPosition.Y < 22.5f)
{
cameraCurrectVelocity.Y += 0.025f;
}
// Input
if ((int)ControllingPlayer < 5)
{
GamePadState state = GamePad.GetState(ControllingPlayer);
if (state.IsButtonDown(Buttons.Back))
{
ExitGameplay();
}
curLeftRight += Time.ElapsedGameTime * leftRightSpeed * -state.ThumbSticks.Left.X;
curUpDown += Time.ElapsedGameTime * upDownSpeed * -state.ThumbSticks.Left.Y;
}
else
{
if (InputManager.IsKeyPressed(Keys.Escape))
{
ExitGameplay();
}
if (InputManager.IsKeyDown(Keys.A))
{
curLeftRight += Time.ElapsedGameTime * leftRightSpeed;
}
if (InputManager.IsKeyDown(Keys.D))
{
curLeftRight -= Time.ElapsedGameTime * leftRightSpeed;
}
if (InputManager.IsKeyDown(Keys.W))
{
curUpDown -= Time.ElapsedGameTime * upDownSpeed;
}
if (InputManager.IsKeyDown(Keys.S))
{
curUpDown += Time.ElapsedGameTime * upDownSpeed;
}
}
cameraCurrectVelocity.X += curLeftRight;
cameraCurrectVelocity.Y += curUpDown;
cameraCurrectVelocity.Y = MathHelper.Clamp(cameraCurrectVelocity.Y, -0.12f, 0.12f);
cameraCurrectVelocity.X = MathHelper.Clamp(cameraCurrectVelocity.X, -0.2f, 0.2f);
cameraCurrectVelocity.Z = (camForwardSpeed) * Time.ElapsedGameTime + cameraCurrectVelocity.Y / 5;
camera.Transform.lookAt(camera.Transform.LocalPosition + cameraCurrectVelocity);
camera.Transform.LocalPosition += cameraCurrectVelocity;
camera.Transform.Rotate(camera.Transform.Forward, 2 * cameraCurrectVelocity.X);
curLeftRight /= 1.2f;
curUpDown /= 1.2f;
}
public override GamePadState GetState()
{
var gamePadState = new GamePadState();
State xinputState;
if (instance.GetState(out xinputState))
{
gamePadState.IsConnected = true;
gamePadState.Buttons = (GamePadButton)xinputState.Gamepad.Buttons;
gamePadState.LeftTrigger = xinputState.Gamepad.LeftTrigger / 255.0f;
gamePadState.RightTrigger = xinputState.Gamepad.RightTrigger / 255.0f;
gamePadState.LeftThumb.X = ClampDeadZone(xinputState.Gamepad.LeftThumbX / 32768.0f, Gamepad.LeftThumbDeadZone / 32768.0f);
gamePadState.LeftThumb.Y = ClampDeadZone(xinputState.Gamepad.LeftThumbY / 32768.0f, Gamepad.LeftThumbDeadZone / 32768.0f);
gamePadState.RightThumb.X = ClampDeadZone(xinputState.Gamepad.RightThumbX / 32768.0f, Gamepad.RightThumbDeadZone / 32768.0f);
gamePadState.RightThumb.Y = ClampDeadZone(xinputState.Gamepad.RightThumbY / 32768.0f, Gamepad.RightThumbDeadZone / 32768.0f);
}
return gamePadState;
}
public override GamePadState GetState()
{
var gamePadState = new GamePadState();
if (SDL.SDL_GameControllerGetAttached(instance) == SDL.SDL_bool.SDL_TRUE)
{
const float LeftThumbDeadZone = 7849.0f/32768.0f;
const float RightThumbDeadZone = 8689.0f/32768.0f;
gamePadState.IsConnected = true;
// Iterate through all buttons
GamePadButton state = GamePadButton.None;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_A) == 1)
state |= GamePadButton.A;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_B) == 1)
state |= GamePadButton.B;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_BACK) == 1)
state |= GamePadButton.Back;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_DPAD_DOWN) == 1)
state |= GamePadButton.PadDown;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_DPAD_UP) == 1)
state |= GamePadButton.PadUp;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_DPAD_LEFT) == 1)
state |= GamePadButton.PadLeft;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_DPAD_RIGHT) == 1)
state |= GamePadButton.PadRight;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_X) == 1)
state |= GamePadButton.X;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_Y) == 1)
state |= GamePadButton.Y;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSHOULDER) == 1)
state |= GamePadButton.LeftShoulder;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_RIGHTSHOULDER) == 1)
state |= GamePadButton.RightShoulder;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSTICK) == 1)
state |= GamePadButton.LeftThumb;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_RIGHTSTICK) == 1)
state |= GamePadButton.RightThumb;
if (SDL.SDL_GameControllerGetButton(instance, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_START) == 1)
state |= GamePadButton.Start;
gamePadState.Buttons = state;
var leftThumbX = SDL.SDL_GameControllerGetAxis(instance, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_LEFTX)/32768.0f;
var leftThumbY = SDL.SDL_GameControllerGetAxis(instance, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_LEFTY)/32768.0f;
gamePadState.LeftThumb.X = ClampDeadZone(leftThumbX, LeftThumbDeadZone);
gamePadState.LeftThumb.Y = ClampDeadZone(leftThumbY, LeftThumbDeadZone);
var rightThumbX = SDL.SDL_GameControllerGetAxis(instance, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_RIGHTX)/32768.0f;
var rightThumbY = SDL.SDL_GameControllerGetAxis(instance, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_RIGHTY)/32768.0f;
gamePadState.RightThumb.X = ClampDeadZone(rightThumbX, RightThumbDeadZone);
gamePadState.RightThumb.Y = ClampDeadZone(rightThumbY, RightThumbDeadZone);
gamePadState.LeftTrigger = SDL.SDL_GameControllerGetAxis(instance, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_TRIGGERLEFT)/32768.0f;
gamePadState.RightTrigger = SDL.SDL_GameControllerGetAxis(instance, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_TRIGGERRIGHT)/32768.0f;
}
return gamePadState;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
public virtual void SendGamePadState(PlayerIndex playerIndex, GamePadState state, GameTime gameTime)
{
UpdateGamePad(playerIndex, state, gameTime);
}
void Update()
{
//インプット関連
if (!playerInputSet_ || !prevState_.IsConnected)
{
playerIndex_ = (PlayerIndex)0;
playerInputSet_ = true;
}
prevState_ = padState_;
padState_ = GamePad.GetState(playerIndex_);
//インプット関連
if (prevState_.Buttons.B == ButtonState.Released && padState_.Buttons.B == ButtonState.Pressed ||
prevState_.Buttons.A == ButtonState.Released && padState_.Buttons.A == ButtonState.Pressed ||
prevState_.Buttons.X == ButtonState.Released && padState_.Buttons.X == ButtonState.Pressed ||
prevState_.Buttons.Y == ButtonState.Released && padState_.Buttons.Y == ButtonState.Pressed)
{
SoundManager.GetInstance.PlaySE("input_SE3");
if (!noiseParticle.skipFrag)
{
noiseParticle.skipFrag = true; return;
}
sceneChangeFlag = true;
}
if (sceneChangeFlag)
{
CameraPos = transform.position;
switch (cameraMoveType)
{
case CameraMoveType.Rotate:
var aim = SurveillanceCamera.transform.position - CameraPos;
// var look = Vector3.RotateTowards(transform.forward, aim, 0.5f * Time.deltaTime, 0f);
//transform.rotation = Quaternion.LookRotation(look);
transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(aim), time);
time += Time.deltaTime;
if (time >= 1)
{
cameraMoveType = CameraMoveType.Move;
}
//Debug.Log("カメラ回転中：" + (transform.position - look) + "見たい数：" + CameraRota);
break;
case CameraMoveType.Move:
transform.position = SurveillanceCamera.transform.position;
var target = Player.transform.position - CameraPos;
var look_ = Quaternion.LookRotation(target);
transform.localRotation = look_;
time += Time.deltaTime * 0.5f;
if (time >= 1.5)
{
cameraMoveType = CameraMoveType.Up;
}
break;
case CameraMoveType.Up:
crtNoise.CRTFlag = true;
cameraMoveType = CameraMoveType.None;
break;
case CameraMoveType.None:
break;
}
}
}
internal GamePadData(PlayerIndex playerIndex)
{
_playerIndex = playerIndex;
_previousState = new GamePadState();
_currentState = Microsoft.Xna.Framework.Input.GamePad.GetState(_playerIndex);
}
public void Update(GamePadState gamePadState, KeyboardState keyboardState)
{
Update(gamePadState);
Update(keyboardState);
}
public void Update(GamePadState gamePadState)
{
currentGamePadState = gamePadState;
lastGamePadState = gamePadState;
}
public override void Update(GameTime gameTime)
{
gamepadstate = GamePad.GetState(PlayerIndex.One);
levelOneButton.Update(gameTime);
levelTwoButton.Update(gameTime);
levelThreeButton.Update(gameTime);
levelFourButton.Update(gameTime);
levelFiveButton.Update(gameTime);
/*
* if (levelOneButton.masterButtonEffect == true || (gamepadstate.IsButtonDown(Buttons.A)) || (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.A)))
* {
*
* displayLoading = true;
* MediaPlayer.Stop();
* DataContractSerializer ds = new DataContractSerializer(typeof(OpeningTitleScreen));
* FileStream fs = new FileStream("StrongTitleScreen.xml", FileMode.Open);
* XmlDictionaryReader reader =
* XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
* ScreenManager.Instance.currentTitleScreen = (OpeningTitleScreen)ds.ReadObject(reader);
* fs.Close();
* ScreenManager.Instance.AddScreen(ScreenManager.Instance.currentTitleScreen);
* }*/
if (levelTwoButton.masterButtonEffect == true || (gamepadstate.IsButtonDown(Buttons.B)) || (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.B)))
{
// this is for the hands gaame. uncomment this for hands game effects
/*
* displayLoading = true;
* MediaPlayer.Stop();
* DataContractSerializer ds = new DataContractSerializer(typeof(OpeningTitleScreen));
* FileStream fs = new FileStream("HandsTitleScreen.xml", FileMode.Open);
* XmlDictionaryReader reader =
* XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
* ScreenManager.Instance.currentTitleScreen = (OpeningTitleScreen)ds.ReadObject(reader);
* fs.Close();
* ScreenManager.Instance.AddScreen(ScreenManager.Instance.currentTitleScreen);
*/
//this is for the wakanda con version of the game
displayLoading = true;
MediaPlayer.Stop();
DataContractSerializer ds = new DataContractSerializer(typeof(OpeningTitleScreen));
FileStream fs = new FileStream("WakandaTitleScreen.xml", FileMode.Open);
XmlDictionaryReader reader =
XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
ScreenManager.Instance.currentTitleScreen = (OpeningTitleScreen)ds.ReadObject(reader);
fs.Close();
ScreenManager.Instance.AddScreen(ScreenManager.Instance.currentTitleScreen);
}
/*
* if (levelThreeButton.masterButtonEffect == true || (gamepadstate.IsButtonDown(Buttons.X)) || (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.X)))
* {
* displayLoading = true;
* MediaPlayer.Stop();
* DataContractSerializer ds = new DataContractSerializer(typeof(OpeningTitleScreen));
* FileStream fs = new FileStream("RopeTitleScreen.xml", FileMode.Open);
* XmlDictionaryReader reader =
* XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
* ScreenManager.Instance.currentTitleScreen = (OpeningTitleScreen)ds.ReadObject(reader);
* fs.Close();
* ScreenManager.Instance.AddScreen(ScreenManager.Instance.currentTitleScreen);
* }
*/
/*
* if (levelFourButton.masterButtonEffect == true || (gamepadstate.IsButtonDown(Buttons.Y)) || (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Y)))
* {
* displayLoading = true;
* MediaPlayer.Stop();
* DataContractSerializer ds = new DataContractSerializer(typeof(OpeningTitleScreen));
* FileStream fs = new FileStream("LevelTwoTitleScreen.xml", FileMode.Open);
* XmlDictionaryReader reader =
* XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
* ScreenManager.Instance.currentTitleScreen = (OpeningTitleScreen)ds.ReadObject(reader);
* fs.Close();
* ScreenManager.Instance.AddScreen(ScreenManager.Instance.currentTitleScreen);
* }
*
* if (levelFiveButton.masterButtonEffect == true || (gamepadstate.IsButtonDown(Buttons.Start)) || (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Enter)))
* {
* displayLoading = true;
* MediaPlayer.Stop();
* DataContractSerializer ds = new DataContractSerializer(typeof(OpeningTitleScreen));
* FileStream fs = new FileStream("DeceptionLevelTwoTitleScreen.xml", FileMode.Open);
* XmlDictionaryReader reader =
* XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
* ScreenManager.Instance.currentTitleScreen = (OpeningTitleScreen)ds.ReadObject(reader);
* fs.Close();
* ScreenManager.Instance.AddScreen(ScreenManager.Instance.currentTitleScreen);
* }
*/
}
/// <summary>
/// reads controller inputs
/// </summary>
void Update()
{
//grab the current state
currentState = GamePad.GetState(playerIndex);
//if start button was just pressed.
if (currentState.Buttons.Start == ButtonState.Pressed && previousState.Buttons.Start == ButtonState.Released ||
currentState.Buttons.A == ButtonState.Pressed && previousState.Buttons.A == ButtonState.Released)
{
//call activate button.
Debug.Log("Start Button Pressed.");
ActivateButton();
}
#region OldUpdate1
/*
* //check to see if the player pushed the A button
* if (currentState.Buttons.A == ButtonState.Pressed)
* {
* //set current player as active.
* int activateCheck = StaticSpawnController.GetSetPlayers();
* StaticSpawnController.ActivatePlayer(playerIndex, true);
*
* //if is player 1 and not active or is player 2 and not active
* if ((playerIndex == PlayerIndex.One && activateCheck != 1 && activateCheck != 3) ||
* (playerIndex == PlayerIndex.Two && activateCheck != 2 && activateCheck != 3))
* {
* //set the toSelect button so start button presses can now be used
* toSelect = StartGameButton;
* //set start hi
* StartHighlight.enabled = true;
* }
* }
* //*/
#endregion
//NOTE: Doesn't work with some XInput emulated device drivers like the popular PS3 Controller one
//destroy the player instance if the controller disconnects
if (currentState.IsConnected == false)
{
#region OldUpdate2
/*
*
* //if player controller disconnects at the lobby, remove them from the active script.
* StaticSpawnController.ActivatePlayer(playerIndex, false);
* if (StaticSpawnController.GetSetPlayers() == 0)
* {
* toSelect = null;
* StartHighlight.enabled = false;
* }
* //text.enabled = true;
* //*/
#endregion
return;
}
else
{
#region OldUpdate3
/*
* //call action selection
* ActionSelection();
* //*/
/*
* //remove the player call if the player pushed the Back button
* if (currentState.Buttons.Back == ButtonState.Pressed)
* {
* //check for players
* int removeCheck = StaticSpawnController.GetSetPlayers();
* //if appropriate player is activated when they hit the back button,
* if ((playerIndex == PlayerIndex.One && removeCheck != 0 && removeCheck != 2) ||
* (playerIndex == PlayerIndex.Two && removeCheck != 0 && removeCheck != 1))
* {
* //set that player to false
* StaticSpawnController.ActivatePlayer(playerIndex, false);
* //text.enabled = true;
* //set screen to null the toSelect button and highlighters if there
* //are no active players
* if (StaticSpawnController.GetSetPlayers() == 0)
* {
* toSelect = null;
* StartHighlight.enabled = false;
* }
* return;
* }
*
* }
* //*/
#endregion
//update packet numbers
if (currentState.PacketNumber > lastPacketNumber)
{
lastPacketNumber = currentState.PacketNumber;
lastPacketTime = Time.time;
}
else
{
//NOTE: Doesn't work with some XInput emulated device drivers like the popular PS3 Controller one
if (Time.time - lastPacketTime > 10)
{
//controller has been idle for 10 seconds
}
}
}
//Set the previous state to the current state and run the set Highlighter.
previousState = currentState;
SetHighlighter();
}
public override void Update(float dt, KeyboardState keyboardInput, MouseState mouseInput, GamePadState gamePadInput, Engine Engine, GameplayType gamePlayType)
{
//For access from Other Referenced Classes
this.Engine = Engine;
//Turn Off Mouse if Right Button is Down
if (mouseInput.RightButton == ButtonState.Pressed || gamePlayType == GameplayType.level)
{
Engine.Game.IsMouseVisible = false;
Yaw += (Engine.GraphicsDevice.Viewport.Width / 2 - mouseInput.X) * dt * .12f;
Pitch += (Engine.GraphicsDevice.Viewport.Height / 2 - mouseInput.Y) * dt * .12f;
}
else if (gamePlayType == GameplayType.Sandbox)
{
Engine.Game.IsMouseVisible = true;
}
#endif
WorldMatrix = Matrix.CreateFromAxisAngle(Vector3.Right, Pitch) * Matrix.CreateFromAxisAngle(Vector3.Up, Yaw);
if (isChaseCameraMode)
{
Vector3 offset;
if (transformOffset)
{
offset = Matrix3X3.Transform(offsetFromChaseTarget, entityToChase.BufferedStates.InterpolatedStates.OrientationMatrix);
}
else
{
offset = offsetFromChaseTarget;
}
Vector3 lookAt = entityToChase.BufferedStates.InterpolatedStates.Position + offset;
Vector3 backwards = WorldMatrix.Backward;
//Find the earliest ray hit that isn't the chase target to position the camera appropriately.
RayCastResult result;
if (entityToChase.Space.RayCast(new Ray(lookAt, backwards), distanceToTarget, rayCastFilter, out result))
{
Position = lookAt + (result.HitData.T) * backwards; //Put the camera just before any hit spot.
}
else
{
Position = lookAt + (distanceToTarget) * backwards;
}
}
else if (UseMovementControls)
{
//Only move around if the camera has control over its own position.
float distance = Speed * dt;
#if !WINDOWS
MoveForward(gamePadInput.ThumbSticks.Left.Y * distance);
MoveRight(gamePadInput.ThumbSticks.Left.X * distance);
if (gamePadInput.IsButtonDown(Buttons.LeftStick))
{
MoveUp(distance);
}
if (gamePadInput.IsButtonDown(Buttons.RightStick))
{
MoveUp(-distance);
}
#endif
if (keyboardInput.IsKeyDown(Keys.W))
{
MoveForward(distance);
}
if (keyboardInput.IsKeyDown(Keys.S))
{
MoveForward(-distance);
}
if (keyboardInput.IsKeyDown(Keys.A))
{
MoveRight(-distance);
}
if (keyboardInput.IsKeyDown(Keys.D))
{
MoveRight(distance);
}
if (keyboardInput.IsKeyDown(Keys.Q))
{
MoveUp(distance);
}
if (keyboardInput.IsKeyDown(Keys.Z))
{
MoveUp(-distance);
}
}
WorldMatrix = WorldMatrix * Matrix.CreateTranslation(Position);
View = Matrix.Invert(WorldMatrix);
base.Update(dt, keyboardInput, mouseInput, gamePadInput, Engine, gamePlayType);
}
internal void Update()
{
PreviousState = State;
State = OpenTK.Input.GamePad.GetState(DeviceID);
Capabilities = OpenTK.Input.GamePad.GetCapabilities(DeviceID);
}
public void checkControllerInput()
{
if (_gcapi_Write == null)
return;
bool boolOverride = false;
if (frmMain.boolIDE)
boolOverride = true;
if ((_gcapi_IsConnected() == 1) || (boolOverride == true))
{
//Update gamepad status
_controls = GamePad.GetState(PlayerIndex.One);
if (_XboxCount == 0) { _XboxCount = Enum.GetNames(typeof(xbox)).Length; }
byte[] output = new byte[_XboxCount];
if (_controls.DPad.Left) { output[(int)xbox.left] = Convert.ToByte(100); }
if (_controls.DPad.Right) { output[(int)xbox.right] = Convert.ToByte(100); }
if (_controls.DPad.Up) { output[(int)xbox.up] = Convert.ToByte(100); }
if (_controls.DPad.Down) { output[(int)xbox.down] = Convert.ToByte(100); }
if (_controls.Buttons.A) { output[(int)xbox.a] = Convert.ToByte(100); }
if (_controls.Buttons.B) { output[(int)xbox.b] = Convert.ToByte(100); }
if (_controls.Buttons.X) { output[(int)xbox.x] = Convert.ToByte(100); }
if (_controls.Buttons.Y) { output[(int)xbox.y] = Convert.ToByte(100); }
if (_controls.Buttons.Start) { output[(int)xbox.start] = Convert.ToByte(100); }
if (_controls.Buttons.Guide) { output[(int)xbox.home] = Convert.ToByte(100); }
if (_controls.Buttons.Back)
{
if (system.boolBlockMenuButton == false)
{
_MenuWait++;
if (system.boolMenu == false)
if (_MenuWait >= _MenuShow + 20)
openMenu();
}
//Remap back buton to touchpad
if (system.boolPS4ControllerMode)
output[(int)xbox.touch] = Convert.ToByte(100);
else
output[(int)xbox.back] = Convert.ToByte(100);
}
if (_controls.Buttons.LeftShoulder) { output[(int)xbox.leftShoulder] = Convert.ToByte(100); }
if (_controls.Buttons.RightShoulder) { output[(int)xbox.rightShoulder] = Convert.ToByte(100); }
if (_controls.Buttons.LeftStick) { output[(int)xbox.leftStick] = Convert.ToByte(100); }
if (_controls.Buttons.RightStick) { output[(int)xbox.rightStick] = Convert.ToByte(100); }
if (_controls.Triggers.Left > 0) { output[(int)xbox.leftTrigger] = Convert.ToByte(_controls.Triggers.Left * 100); }
if (_controls.Triggers.Right > 0) { output[(int)xbox.rightTrigger] = Convert.ToByte(_controls.Triggers.Right * 100); }
double dblLX = _controls.ThumbSticks.Left.X * 100;
double dblLY = _controls.ThumbSticks.Left.Y * 100;
double dblRX = _controls.ThumbSticks.Right.X * 100;
double dblRY = _controls.ThumbSticks.Right.Y * 100;
if (system.boolNormalizeControls == true)
{
normalGamepad(ref dblLX, ref dblLY);
normalGamepad(ref dblRX, ref dblRY);
}
else
{
dblLY = -dblLY;
dblRY = -dblRY;
}
if (dblLX != 0) { output[(int)xbox.leftX] = (byte)Convert.ToSByte((int)(dblLX)); }
if (dblLY != 0) { output[(int)xbox.leftY] = (byte)Convert.ToSByte((int)(dblLY)); }
if (dblRX != 0) { output[(int)xbox.rightX] = (byte)Convert.ToSByte((int)(dblRX)); }
if (dblRY != 0) { output[(int)xbox.rightY] = (byte)Convert.ToSByte((int)(dblRY)); }
if (CMHomeCount > 0)
{
output[(int)xbox.home] = Convert.ToByte(100);
CMHomeCount--;
}
if (Ps4Touchpad == true)
output[(int)xbox.touch] = Convert.ToByte(100);
if (_boolLoadShortcuts)
output = checkKeys(output);
int intTarget = -1;
if (system.boolPS4ControllerMode == false) { intTarget = (int)xbox.back; } else { intTarget = (int)xbox.touch; }
/*
//Back button. Wait until released as its also the menu button
if (intTarget > -1)
{
if (system.boolBlockMenuButton)
{
if (output[intTarget] == 100)
{
_boolHoldBack = true;
output[intTarget] = Convert.ToByte(0);
_MenuWait++;
if (!system.boolMenu)
{
if (_MenuWait >= _MenuShow)
{
_boolHoldBack = false;
openMenu();
}
}
}
else
{
if (_boolHoldBack == true)
{
_boolHoldBack = false;
output[intTarget] = Convert.ToByte(100);
_MenuWait = 0;
}
else
_MenuWait = 0;
}
}
}
*/
if (keyboardInterface != null && keyboardInterface.output != null)
{
for (int intCount = 0; intCount < _XboxCount; intCount++)
{
if (keyboardInterface.output[intCount] != 0)
output[intCount] = keyboardInterface.output[intCount];
}
}
//Block gamepad rumble
//gcapi_WriteEX(uint8_t *outpacket, uint8_t size)
/*
[0xFF,0x01 : 2 byte, Packet Signature]
[Update LED Command (0,1) : 1 byte]
[LED 1 Status : 1 byte]
[LED 2 Status : 1 byte]
[LED 3 Status : 1 byte]
[LED 4 Status : 1 byte]
[Reset LEDs Command (0,1) : 1 byte]
[Update Rumble Command (0,1) : 1 byte]
[Rumble 1 Value : 1 byte]
[Rumble 2 Value : 1 byte]
[Rumble 3 Value : 1 byte]
[Rumble 4 Value : 1 byte]
[Reset Rumble Command (0,1) : 1 byte]
[Block Rumble Command (0,1) : 1 byte]
[Turn Off Controller Command (0,1) : 1 byte]
[Button States : 36 bytes - same format as gcapi_Write]
_gcapi_WriteEx(output);
*/
_gcapi_Write(output);
if (system.boolUseRumble == true)
{
if (_devId == DevPID.TitanOne)
{
GCAPI_REPORT_TITANONE report = new GCAPI_REPORT_TITANONE();
if (_gcapi_Read_TO(ref report) != IntPtr.Zero)
GamePad.SetState(PlayerIndex.One, report.rumble[0], report.rumble[1]);
}
else
{
GCAPI_REPORT_CONTROLLERMAX report = new GCAPI_REPORT_CONTROLLERMAX();
if (_gcapi_Read_CM(ref report) != IntPtr.Zero)
GamePad.SetState(PlayerIndex.One, report.rumble[0], report.rumble[1]);
}
}
}
else
{
//If device just disconnected open up notice to tell user
if (_boolNoticeTODisconnected == false)
{
system.debug("titanOne.log", "[NOTE] " + _strTODevice + " is disconnected");
_boolNoticeTODisconnected = true;
}
//Keep alive for opening the menu
_controls = GamePad.GetState(PlayerIndex.One);
if (_controls.Buttons.Back)
{
if (system.boolBlockMenuButton == false)
{
_MenuWait++;
if (!system.boolMenu)
{
if (_MenuWait >= _MenuShow + 20)
frmMain.openMenu();
}
}
}
}
}
public abstract void Update(GameTime gameTime, GamePadState pad, GamePadState oldpad);
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
private ButtonState GetVectorState(GamePadButton button, GamePadState state)
{
//ButtonState ret = ButtonState.Released;
//bool down = false;
//float t = ClickThreshold;
//switch (button)
//{
// case GamePadButton.LeftStickLeft: down = state.ThumbSticks.Left.X < -t; break;
// case GamePadButton.LeftStickRight: down = state.ThumbSticks.Left.X > t; break;
// case GamePadButton.LeftStickUp: down = state.ThumbSticks.Left.Y > t; break;
// case GamePadButton.LeftStickDown: down = state.ThumbSticks.Left.Y < -t; break;
// case GamePadButton.RightStickLeft: down = state.ThumbSticks.Right.X < -t; break;
// case GamePadButton.RightStickRight: down = state.ThumbSticks.Right.X > t; break;
// case GamePadButton.RightStickUp: down = state.ThumbSticks.Right.Y > t; break;
// case GamePadButton.RightStickDown: down = state.ThumbSticks.Right.Y < -t; break;
// case GamePadButton.LeftTrigger: down = state.Triggers.Left > t; break;
// case GamePadButton.RightTrigger: down = state.Triggers.Right > t; break;
//}
//ret = down ? ButtonState.Pressed : ButtonState.Released;
//return ret;
return new ButtonState();
}
void ProcessGamePad(CCWindow window, GamePadState gps, PlayerIndex player)
{
var dispatcher = window.EventDispatcher;
var lastState = new GamePadState();
if (!priorGamePadState.ContainsKey(player) && gps.IsConnected)
{
gamePadConnection.IsConnected = true;
gamePadConnection.Player = (CCPlayerIndex)player;
dispatcher.DispatchEvent(gamePadConnection);
}
if (priorGamePadState.ContainsKey(player))
{
lastState = priorGamePadState[player];
// Notify listeners when the gamepad is connected/disconnected.
if ((lastState.IsConnected != gps.IsConnected))
{
gamePadConnection.IsConnected = false;
gamePadConnection.Player = (CCPlayerIndex)player;
dispatcher.DispatchEvent(gamePadConnection);
}
// TODO: Check button pressed/released status for button tap events.
}
if (gps.IsConnected)
{
var caps = GamePad.GetCapabilities(player);
if (caps.HasBackButton ||
caps.HasStartButton ||
caps.HasBigButton ||
caps.HasAButton ||
caps.HasBButton ||
caps.HasXButton ||
caps.HasYButton ||
caps.HasLeftShoulderButton ||
caps.HasRightShoulderButton)
{
var back = CCGamePadButtonStatus.NotApplicable;
var start = CCGamePadButtonStatus.NotApplicable;
var system = CCGamePadButtonStatus.NotApplicable;
var a = CCGamePadButtonStatus.NotApplicable;
var b = CCGamePadButtonStatus.NotApplicable;
var x = CCGamePadButtonStatus.NotApplicable;
var y = CCGamePadButtonStatus.NotApplicable;
var leftShoulder = CCGamePadButtonStatus.NotApplicable;
var rightShoulder = CCGamePadButtonStatus.NotApplicable;
if (caps.HasBackButton)
{
back = (gps.Buttons.Back == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasStartButton)
{
start = (gps.Buttons.Start == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasBigButton)
{
system = (gps.Buttons.BigButton == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasAButton)
{
a = (gps.Buttons.A == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasBButton)
{
b = (gps.Buttons.B == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasXButton)
{
x = (gps.Buttons.X == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasYButton)
{
y = (gps.Buttons.Y == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasLeftShoulderButton)
{
leftShoulder = (gps.Buttons.LeftShoulder == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasRightShoulderButton)
{
rightShoulder = (gps.Buttons.RightShoulder == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
gamePadButton.Back = back;
gamePadButton.Start = start;
gamePadButton.System = system;
gamePadButton.A = a;
gamePadButton.B = b;
gamePadButton.X = x;
gamePadButton.Y = y;
gamePadButton.LeftShoulder = leftShoulder;
gamePadButton.RightShoulder = rightShoulder;
gamePadButton.Player = (CCPlayerIndex)player;
dispatcher.DispatchEvent(gamePadButton);
}
// Process the game sticks
if ((caps.HasLeftXThumbStick ||
caps.HasLeftYThumbStick ||
caps.HasRightXThumbStick ||
caps.HasRightYThumbStick ||
caps.HasLeftStickButton ||
caps.HasRightStickButton))
{
CCPoint vecLeft;
if (caps.HasLeftXThumbStick || caps.HasLeftYThumbStick)
{
vecLeft = new CCPoint(gps.ThumbSticks.Left);
vecLeft.Normalize();
}
else
{
vecLeft = CCPoint.Zero;
}
CCPoint vecRight;
if (caps.HasRightXThumbStick || caps.HasRightYThumbStick)
{
vecRight = new CCPoint(gps.ThumbSticks.Right);
vecRight.Normalize();
}
else
{
vecRight = CCPoint.Zero;
}
var left = new CCGameStickStatus();
left.Direction = vecLeft;
left.Magnitude = ((caps.HasLeftXThumbStick || caps.HasLeftYThumbStick) ? gps.ThumbSticks.Left.Length() : 0f);
left.IsDown = ((caps.HasLeftStickButton) ? gps.IsButtonDown(Buttons.LeftStick) : false);
var right = new CCGameStickStatus();
right.Direction = vecRight;
right.Magnitude = ((caps.HasRightXThumbStick || caps.HasRightYThumbStick) ? gps.ThumbSticks.Right.Length() : 0f);
right.IsDown = ((caps.HasLeftStickButton) ? gps.IsButtonDown(Buttons.RightStick) : false);
gamePadStick.Left = left;
gamePadStick.Right = right;
gamePadStick.Player = (CCPlayerIndex)player;
dispatcher.DispatchEvent(gamePadStick);
}
// Process the game triggers
if (caps.HasLeftTrigger || caps.HasRightTrigger)
{
//GamePadTriggerUpdate (caps.HasLeftTrigger ? gps.Triggers.Left : 0f, caps.HasRightTrigger ? gps.Triggers.Right : 0f, player);
gamePadTrigger.Left = caps.HasLeftTrigger ? gps.Triggers.Left : 0f;
gamePadTrigger.Right = caps.HasRightTrigger ? gps.Triggers.Right : 0f;
gamePadTrigger.Player = (CCPlayerIndex)player;
dispatcher.DispatchEvent(gamePadTrigger);
}
// Process the D-Pad
if (caps.HasDPadDownButton ||
caps.HasDPadUpButton ||
caps.HasDPadLeftButton ||
caps.HasDPadRightButton)
{
var leftButton = CCGamePadButtonStatus.NotApplicable;
var rightButton = CCGamePadButtonStatus.NotApplicable;
var upButton = CCGamePadButtonStatus.NotApplicable;
var downButton = CCGamePadButtonStatus.NotApplicable;
if (caps.HasDPadDownButton)
{
downButton = (gps.DPad.Down == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasDPadUpButton)
{
upButton = (gps.DPad.Up == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasDPadLeftButton)
{
leftButton = (gps.DPad.Left == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
if (caps.HasDPadRightButton)
{
rightButton = (gps.DPad.Right == ButtonState.Pressed ? CCGamePadButtonStatus.Pressed : CCGamePadButtonStatus.Released);
}
gamePadDPad.Down = downButton;
gamePadDPad.Up = upButton;
gamePadDPad.Left = leftButton;
gamePadDPad.Right = rightButton;
gamePadDPad.Player = (CCPlayerIndex)player;
dispatcher.DispatchEvent(gamePadDPad);
}
}
priorGamePadState[player] = gps;
}
private void HandleGamePad()
{
if (!IsActiveScreen) return;
bool succeeded = false;
GamePadState gamePadState = new GamePadState();
try
{
gamePadState = GamePad.GetState(0);
succeeded = true;
}
catch (Exception) { }
if (succeeded)
{
Manager.Player.MoveInput += gamePadState.ThumbSticks.Left;
Manager.Player.HeadInput += gamePadState.ThumbSticks.Right;
if (gamePadState.Buttons.X == ButtonState.Pressed && !pressedGamepadInteract)
Manager.Player.InteractInput = true;
pressedGamepadInteract = gamePadState.Buttons.X == ButtonState.Pressed;
if (gamePadState.Buttons.A == ButtonState.Pressed && !pressedGamepadApply)
Manager.Player.ApplyInput = true;
pressedGamepadApply = gamePadState.Buttons.A == ButtonState.Pressed;
if (gamePadState.Buttons.Y == ButtonState.Pressed && !pressedGamepadJump)
Manager.Player.JumpInput = true;
pressedGamepadJump = gamePadState.Buttons.Y == ButtonState.Pressed;
if (gamePadState.Buttons.LeftStick == ButtonState.Pressed && !pressedGamepadFlymode)
Manager.Player.FlymodeInput = true;
pressedGamepadFlymode = gamePadState.Buttons.LeftStick == ButtonState.Pressed;
if (gamePadState.Buttons.LeftShoulder == ButtonState.Pressed && !pressedGamepadSlotLeft)
Manager.Player.SlotLeftInput = true;
pressedGamepadSlotLeft = gamePadState.Buttons.LeftShoulder == ButtonState.Pressed;
if (gamePadState.Buttons.RightShoulder == ButtonState.Pressed && !pressedGamepadSlotRight)
Manager.Player.SlotRightInput = true;
pressedGamepadSlotRight = gamePadState.Buttons.RightShoulder == ButtonState.Pressed;
if (gamePadState.Buttons.Back == ButtonState.Pressed && !pressedGamepadInventory)
Manager.NavigateToScreen(new InventoryScreen(Manager));
pressedGamepadInventory = gamePadState.Buttons.Back == ButtonState.Pressed;
}
}
private void checkGamePads(Object sender, EventArgs e)
{
ActionEventArgs args = new ActionEventArgs(this.ActiveDevice);
if (!args.GamePadState.Equals(oldgstate))
{
//call event
OnGamePadAction(args);
oldgstate = args.GamePadState;
}
if (!args.JoystickState.Equals(oldjstate))
{
//call event
OnJoystickAction(args);
oldjstate = args.JoystickState;
}
}
public override GamePadState GetState()
{
var gamePadState = new GamePadState();
// Get the current joystick state
try
{
if (instance == null)
{
if (directInput.IsDeviceAttached(key.Guid))
{
instance = new Joystick(directInput, key.Guid);
}
else
{
return gamePadState;
}
}
// Acquire the joystick
instance.Acquire();
// Make sure that the latest state is up to date
instance.Poll();
// Get the state
instance.GetCurrentState(ref joystickState);
}
catch (SharpDX.SharpDXException)
{
// If there was an exception, dispose the native instance
try
{
if (instance != null)
{
instance.Dispose();
instance = null;
}
// Return a GamePadState that specify that it is not connected
return gamePadState;
}
catch (Exception)
{
}
}
//Console.WriteLine(joystickState);
gamePadState.IsConnected = true;
gamePadState.Buttons = GamePadButton.None;
if (joystickState.Buttons[0])
{
gamePadState.Buttons |= GamePadButton.X;
}
if (joystickState.Buttons[1])
{
gamePadState.Buttons |= GamePadButton.A;
}
if (joystickState.Buttons[2])
{
gamePadState.Buttons |= GamePadButton.B;
}
if (joystickState.Buttons[3])
{
gamePadState.Buttons |= GamePadButton.Y;
}
if (joystickState.Buttons[4])
{
gamePadState.Buttons |= GamePadButton.LeftShoulder;
}
if (joystickState.Buttons[5])
{
gamePadState.Buttons |= GamePadButton.RightShoulder;
}
if (joystickState.Buttons[6])
{
gamePadState.LeftTrigger = 1.0f;
}
if (joystickState.Buttons[7])
{
gamePadState.RightTrigger = 1.0f;
}
if (joystickState.Buttons[8])
{
gamePadState.Buttons |= GamePadButton.Back;
}
if (joystickState.Buttons[9])
{
gamePadState.Buttons |= GamePadButton.Start;
}
if (joystickState.Buttons[10])
{
gamePadState.Buttons |= GamePadButton.LeftThumb;
}
if (joystickState.Buttons[11])
{
gamePadState.Buttons |= GamePadButton.RightThumb;
}
int dPadRawValue = joystickState.PointOfViewControllers[0];
if (dPadRawValue >= 0)
{
int dPadValue = dPadRawValue / 4500;
switch (dPadValue)
{
case 0:
gamePadState.Buttons |= GamePadButton.PadUp;
break;
case 1:
gamePadState.Buttons |= GamePadButton.PadUp;
gamePadState.Buttons |= GamePadButton.PadRight;
break;
case 2:
gamePadState.Buttons |= GamePadButton.PadRight;
break;
case 3:
gamePadState.Buttons |= GamePadButton.PadRight;
gamePadState.Buttons |= GamePadButton.PadDown;
break;
case 4:
gamePadState.Buttons |= GamePadButton.PadDown;
break;
case 5:
gamePadState.Buttons |= GamePadButton.PadDown;
gamePadState.Buttons |= GamePadButton.PadLeft;
break;
case 6:
gamePadState.Buttons |= GamePadButton.PadLeft;
break;
case 7:
gamePadState.Buttons |= GamePadButton.PadLeft;
gamePadState.Buttons |= GamePadButton.PadUp;
break;
}
}
// Left Thumb
gamePadState.LeftThumb = new Vector2(2.0f * (joystickState.X / 65535.0f - 0.5f), -2.0f * (joystickState.Y / 65535.0f - 0.5f));
gamePadState.LeftThumb.X = ClampDeadZone(gamePadState.LeftThumb.X, GamePadAxisDeadZone);
gamePadState.LeftThumb.Y = ClampDeadZone(gamePadState.LeftThumb.Y, GamePadAxisDeadZone);
// Right Thumb
gamePadState.RightThumb = new Vector2(2.0f * (joystickState.Z / 65535.0f - 0.5f), -2.0f * (joystickState.RotationZ / 65535.0f - 0.5f));
gamePadState.RightThumb.X = ClampDeadZone(gamePadState.RightThumb.X, GamePadAxisDeadZone);
gamePadState.RightThumb.Y = ClampDeadZone(gamePadState.RightThumb.Y, GamePadAxisDeadZone);
return gamePadState;
}
private void FixedUpdate()
{
state = GamePad.GetState(playerIndex);
//if (!TPC.GetComponent<ThirdPersonCamera>().stationaryMode)
//{
// roll = state.ThumbSticks.Left.X;
// pitch = state.ThumbSticks.Left.Y;
//}
//else
//{
// roll = state.ThumbSticks.Right.X;
// pitch = state.ThumbSticks.Right.Y;
// roll = roll * staticRotMultiplier;
// pitch = pitch * staticRotMultiplier;
//}
if (!state.IsConnected)
{
roll = Input.GetAxis("Horizontal");
pitch = Input.GetAxis("Vertical");
}
else
{
roll = state.ThumbSticks.Left.X;
pitch = state.ThumbSticks.Left.Y;
}
if (TPC.GetComponent <ThirdPersonCamera>().stationaryMode)
{
roll = roll * staticRotMultiplier;
pitch = pitch * staticRotMultiplier;
}
this.GetComponent <Rigidbody>().AddTorque(transform.forward * -1 * roll * rollSpeed * Time.fixedDeltaTime);
this.GetComponent <Rigidbody>().AddTorque(transform.right * pitch * pitchSpeed * Time.fixedDeltaTime);
//Yaw scheme
yaw = state.ThumbSticks.Right.X;
VYaw = state.ThumbSticks.Right.Y;
this.GetComponent <Rigidbody>().AddTorque(transform.up * yaw * yawSpeed * Time.fixedDeltaTime);
this.GetComponent <Rigidbody>().AddTorque(transform.right * -1.0f * VYaw * VYawSpeed * Time.fixedDeltaTime);
bool evasiveMode = false;
if (state.IsConnected)
{
if (state.Buttons.B == ButtonState.Pressed)
{
evasiveMode = true;
}
}
else
{
evasiveMode = Input.GetKey(KeyCode.RightShift);
}
//if(((Mathf.Abs(state.ThumbSticks.Right.X) > 0.1f) || (Mathf.Abs(state.ThumbSticks.Right.Y) > 0.1f))&&(TPC.GetComponent<ThirdPersonCamera>().stationaryMode == false))
if ((evasiveMode) && (TPC.GetComponent <ThirdPersonCamera>().stationaryMode == false))
{
TPC.GetComponent <ThirdPersonCamera>().stationaryMode = true;
TPC.GetComponent <ThirdPersonCamera>().statRotation = TPC.transform;
}
//else if (((Mathf.Abs(state.ThumbSticks.Right.X) < 0.1f) && (Mathf.Abs(state.ThumbSticks.Right.Y) < 0.1f)) && (TPC.GetComponent<ThirdPersonCamera>().stationaryMode == true))
else if ((!evasiveMode) && (TPC.GetComponent <ThirdPersonCamera>().stationaryMode == true))
{
TPC.GetComponent <ThirdPersonCamera>().stationaryMode = false;
}
bool accelerator = false;
if (!state.IsConnected)
{
accelerator = Input.GetKey(KeyCode.LeftShift);
}
else
{
if (state.Buttons.RightShoulder == ButtonState.Pressed)
{
accelerator = true;
}
}
if (accelerator)
{
float acc = 0;
acc = accel * Time.fixedDeltaTime;
if (TPC.GetComponent <ThirdPersonCamera>().stationaryMode)
{
acc = acc * staticAccMultiplier;
}
this.GetComponent <Rigidbody>().AddForce(transform.forward * acc);
}
else if (TPC.GetComponent <ThirdPersonCamera>().stationaryMode)
{
float acc = 0;
acc = accel * Time.fixedDeltaTime;
acc = acc * staticAccMultiplier;
this.GetComponent <Rigidbody>().AddForce(transform.forward * acc);
}
//Trail length based on speed
float t = this.gameObject.GetComponent <Rigidbody>().velocity.magnitude *trailMult;
LTip.time = t;
RTip.time = t;
if (afterburnerOn)
{
this.GetComponent <AudioSource>().pitch = 0.8f + (this.GetComponent <Rigidbody>().velocity.magnitude *0.1f);
}
}
public void Update(float dt, KeyboardState keyboardInput, MouseState mouseInput, GamePadState gamePadInput)
{
Yaw += (200 - mouseInput.X) * dt * .12f;
Pitch += (200 - mouseInput.Y) * dt * .12f;
#endif
WorldMatrix = Matrix.CreateFromAxisAngle(Vector3.Right, Pitch) * Matrix.CreateFromAxisAngle(Vector3.Up, Yaw);
if (isChaseCameraMode)
{
Vector3 offset;
if (transformOffset)
{
offset = MathConverter.Convert(BEPUphysics.MathExtensions.Matrix3X3.Transform(MathConverter.Convert(offsetFromChaseTarget), entityToChase.BufferedStates.InterpolatedStates.OrientationMatrix));
}
else
{
offset = offsetFromChaseTarget;
}
Vector3 lookAt = MathConverter.Convert(entityToChase.BufferedStates.InterpolatedStates.Position) + offset;
Vector3 backwards = WorldMatrix.Backward;
//Find the earliest ray hit that isn't the chase target to position the camera appropriately.
RayCastResult result;
if (entityToChase.Space.RayCast(MathConverter.Convert(new Ray(lookAt, backwards)), distanceToTarget, rayCastFilter, out result))
{
Position = lookAt + (result.HitData.T) * backwards; //Put the camera just before any hit spot.
}
else
{
Position = lookAt + (distanceToTarget) * backwards;
}
}
else if (UseMovementControls)
{
//Only move around if the camera has control over its own position.
float distance = Speed * dt;
#if !WINDOWS
MoveForward(gamePadInput.ThumbSticks.Left.Y * distance);
MoveRight(gamePadInput.ThumbSticks.Left.X * distance);
if (gamePadInput.IsButtonDown(Buttons.LeftStick))
{
MoveUp(distance);
}
if (gamePadInput.IsButtonDown(Buttons.RightStick))
{
MoveUp(-distance);
}
#endif
if (keyboardInput.IsKeyDown(Keys.E))
{
MoveForward(distance);
}
if (keyboardInput.IsKeyDown(Keys.D))
{
MoveForward(-distance);
}
if (keyboardInput.IsKeyDown(Keys.S))
{
MoveRight(-distance);
}
if (keyboardInput.IsKeyDown(Keys.F))
{
MoveRight(distance);
}
if (keyboardInput.IsKeyDown(Keys.A))
{
MoveUp(distance);
}
if (keyboardInput.IsKeyDown(Keys.Z))
{
MoveUp(-distance);
}
}
WorldMatrix = WorldMatrix * Matrix.CreateTranslation(Position);
ViewMatrix = Matrix.Invert(WorldMatrix);
}
// Update is called once per frame
void Update()
{
state = GamePad.GetState(playerIndex);
/*
* roll = state.ThumbSticks.Left.X;
* pitch = state.ThumbSticks.Left.Y;
*
* this.GetComponent<Rigidbody>().AddTorque(transform.forward * -1 * roll * rollSpeed * Time.deltaTime);
* this.GetComponent<Rigidbody>().AddTorque(transform.right * pitch * pitchSpeed * Time.deltaTime);
*/
bool gunTrigger = false;
if (state.IsConnected)
{
if (state.Buttons.LeftShoulder == ButtonState.Pressed)
{
gunTrigger = true;
}
}
else
{
gunTrigger = Input.GetKey(KeyCode.Space);
}
if (gunTrigger)
{
gunLight.SetActive(true);
if (gun1RefireTime <= 0)
{
if (leftGun)
{
gun1.GetComponent <gun>().fire();
leftGun = false;
}
else
{
gun2.GetComponent <gun>().fire();
leftGun = true;
}
gun1RefireTime = refireDelay;
}
else
{
gun1RefireTime -= Time.deltaTime;
}
//if (gun2RefireTime <= 0)
//{
// gun2.GetComponent<gun>().fire();
// gun2RefireTime = refireDelay;
//}
//else
//{
// gun2RefireTime -= Time.deltaTime;
//}
//gun1RefireTime -= Time.deltaTime;
//gun2RefireTime -= Time.deltaTime;
}
else
{
gunLight.SetActive(false);
gun1RefireTime = 0;
//gun2RefireTime = 0.5f * refireDelay;
}
bool accelerator = false;
if (state.IsConnected)
{
if (state.Buttons.RightShoulder == ButtonState.Pressed)
{
accelerator = true;
}
}
else
{
accelerator = Input.GetKey(KeyCode.LeftShift);
}
if ((accelerator || (TPC.GetComponent <ThirdPersonCamera>().stationaryMode)) && (!afterburnerOn))
{
afterburner.GetComponent <ParticleSystem>().enableEmission = true;
ABGlow.GetComponent <ParticleSystem>().enableEmission = true;
//afterburner.SetActive(true);
afterburnerOn = true;
this.GetComponent <AudioSource>().Play();
cam.GetComponent <shake>().shakeSources++;
burnerLight.SetActive(true);
}
if (((!accelerator) && (!TPC.GetComponent <ThirdPersonCamera>().stationaryMode)) && (afterburnerOn))
{
afterburner.GetComponent <ParticleSystem>().enableEmission = false;
ABGlow.GetComponent <ParticleSystem>().enableEmission = false;
//afterburner.SetActive(false);
afterburnerOn = false;
this.GetComponent <AudioSource>().Stop();
cam.GetComponent <shake>().shakeSources--;
burnerLight.SetActive(false);
if (cam.GetComponent <shake>().shakeSources < 0)
{
cam.GetComponent <shake>().shakeSources = 0;
}
}
if ((state.Buttons.A == ButtonState.Pressed) && ((missileTimer + missileCooldown) < Time.time))
{
GameObject missInst = Instantiate(missile);
if (leftMissile)
{
missInst.transform.position = missileLauncherL.transform.position;
missInst.transform.rotation = missileLauncherL.transform.rotation;
leftMissile = false;
}
else
{
missInst.transform.position = missileLauncherR.transform.position;
missInst.transform.rotation = missileLauncherR.transform.rotation;
leftMissile = true;
}
missInst.GetComponent <missileController>().owner = this.gameObject;
missInst.GetComponent <Rigidbody>().velocity = this.GetComponent <Rigidbody>().velocity;
missileTimer = Time.time;
}
//death
if (Input.GetKey(KeyCode.I))
{
die();
}
}
public void Update()
{
var buttonarray = new Buttons[14] {
Buttons.A, Buttons.B, Buttons.Y, Buttons.X, Buttons.DPadUp,
Buttons.DPadLeft, Buttons.DPadDown, Buttons.DPadRight, Buttons.Back, Buttons.Start, Buttons.LeftShoulder,
Buttons.RightShoulder, Buttons.LeftTrigger, Buttons.RightTrigger
};
var attackarray = new Buttons[] { Buttons.A };
var oncearray = new Buttons[] { Buttons.B, Buttons.Y, Buttons.X, Buttons.DPadUp,
Buttons.DPadLeft, Buttons.DPadDown, Buttons.DPadRight, Buttons.Back, Buttons.Start, Buttons.LeftShoulder,
Buttons.RightShoulder, Buttons.LeftTrigger, Buttons.RightTrigger };
previousState = currentState;
currentState = GamePad.GetState(Microsoft.Xna.Framework.PlayerIndex.One);
if (oncearray.Contains <Buttons>(lastButtonPressed))
{
ICommand command = new StopCommand(this.instance.Link);
command.Execute();
}
else if (attackarray.Contains <Buttons>(lastButtonPressed))
{
}
else if (buttonarray.Contains <Buttons>(lastButtonPressed) && (!currentState.IsButtonDown(lastButtonPressed)))
{
ICommand command = new StopCommand(this.instance.Link);
command.Execute();
}
foreach (Buttons button in buttonarray)
{
//if the keys in the keyArray are pressed, execute corresponding command
if (oncearray.Contains <Buttons>(button))
{
if (currentState.IsButtonDown(button) && !previousState.IsButtonDown(button))
{
gamepadMappings[button]?.Execute();
lastButtonPressed = button;
}
}
else if (attackarray.Contains <Buttons>(button))
{
if (currentState.IsButtonDown(button) && !previousState.IsButtonDown(button))
{
gamepadMappings[button]?.Execute();
lastButtonPressed = button;
}
}
else if (buttonarray.Contains <Buttons>(button))
{
if (currentState.IsButtonDown(button))
{
if ((lastButtonPressed == button) || ((lastButtonPressed != button) && currentState.IsButtonUp(lastButtonPressed)))
{
gamepadMappings[button]?.Execute();
lastButtonPressed = button;
}
}
}
}
}
public MenuResult Update(GameTime gameTime)
{
cooldown -= gameTime.ElapsedGameTime.Milliseconds;
if (cooldown < 0)
{
cooldown = 0;
}
if (state == SummaryMenuState.WAIT && animateTime > 1000)
{
SoundEffects.PlayClick();
result = MenuResult.GoToResults;
String nextText = null;
if (TutorialStage.controlLessonIndex == TutorialStage.introIndex)
{
optionList = new List <MenuOption>();
}
else
{
optionList = new List <MenuOption>();
optionList.Add(new MenuOption(MenuResult.GoToResults, "Continue"));
}
state = SummaryMenuState.READY;
nextText = TutorialStage.IntroText();
text = nextText;
cooldown = 250;
}
if (state == SummaryMenuState.NURSEIN || state == SummaryMenuState.NURSEOUT || state == SummaryMenuState.WAIT)
{
animateTime += gameTime.ElapsedGameTime.Milliseconds;
}
if (state == SummaryMenuState.NURSEIN && animateTime > 250)
{
state = SummaryMenuState.READY;
}
if (state == SummaryMenuState.NURSEOUT && animateTime > 250)
{
animateTime = 0;
state = SummaryMenuState.NURSEIN;
return(result);
}
if (state == SummaryMenuState.READY && cooldown == 0)
{
GamePadState gamePadState = GamePad.GetState(Game.playerIndex);
Vector2 leftStick = gamePadState.ThumbSticks.Left;
Vector2 rightStick = gamePadState.ThumbSticks.Right;
if (!(TutorialStage.phase != TutorialPhase.None && TutorialStage.introIndex - 1 == TutorialStage.controlLessonIndex))
{
if (Keyboard.GetState().IsKeyDown(Keys.Space) || gamePadState.IsButtonDown(Buttons.A) || gamePadState.IsButtonDown(Buttons.Start))
{
SoundEffects.PlayClick();
result = optionList[selectedOption].result;
String nextText = null;
if (TutorialStage.phase == TutorialPhase.Intro)
{
if (TutorialStage.controlLessonIndex == TutorialStage.introIndex)
{
optionList = new List <MenuOption>();
}
else
{
optionList = new List <MenuOption>();
optionList.Add(new MenuOption(MenuResult.GoToResults, "Continue"));
}
nextText = TutorialStage.IntroText();
}
else if (TutorialStage.phase == TutorialPhase.Pass)
{
nextText = TutorialStage.SuccessText();
if (TutorialStage.IsEndOfSection())
{
optionList = new List <MenuOption>();
optionList.Add(new MenuOption(MenuResult.GoToResults, "Continue"));
optionList.Add(new MenuOption(MenuResult.Replay, "Practice"));
}
}
else if (TutorialStage.phase == TutorialPhase.Fail)
{
nextText = TutorialStage.FailureText();
if (TutorialStage.IsEndOfSection())
{
optionList = new List <MenuOption>();
optionList.Add(new MenuOption(MenuResult.Replay, "Try Again"));
optionList.Add(new MenuOption(MenuResult.GoToMainMenu, "Main Menu"));
}
}
if (nextText != null)
{
text = nextText;
cooldown = 250;
}
else
{
if ((TutorialStage.phase == TutorialPhase.Pass && result != MenuResult.Replay) || TutorialStage.phase == TutorialPhase.Fail)
{
return(result);
}
animateTime = 0;
state = SummaryMenuState.NURSEOUT;
}
}
if (gamePadState.IsButtonDown(Buttons.DPadRight) || gamePadState.IsButtonDown(Buttons.DPadRight) || Keyboard.GetState().IsKeyDown(Keys.Right) || leftStick.X > Game.gameSettings.controlStickTrigger || rightStick.X > Game.gameSettings.controlStickTrigger)
{
SoundEffects.PlayClick();
selectedOption++;
if (selectedOption >= optionList.Count())
{
selectedOption = optionList.Count() - 1;
}
cooldown = 250;
}
if (gamePadState.IsButtonDown(Buttons.DPadLeft) || gamePadState.IsButtonDown(Buttons.DPadLeft) || Keyboard.GetState().IsKeyDown(Keys.Left) || leftStick.X < -Game.gameSettings.controlStickTrigger || rightStick.X < -Game.gameSettings.controlStickTrigger)
{
SoundEffects.PlayClick();
selectedOption--;
if (selectedOption < 0)
{
selectedOption = 0;
}
cooldown = 250;
}
}
else
{
if (TutorialStage.restrictions == ControlRestrictions.StickOnly && (gamePadState.IsButtonDown(Buttons.DPadUp) || Keyboard.GetState().IsKeyDown(Keys.Up) || gamePadState.ThumbSticks.Left.Y > Game.gameSettings.controlStickTrigger ||
gamePadState.IsButtonDown(Buttons.DPadDown) || Keyboard.GetState().IsKeyDown(Keys.Down) || gamePadState.ThumbSticks.Left.Y < -Game.gameSettings.controlStickTrigger ||
gamePadState.IsButtonDown(Buttons.DPadLeft) || Keyboard.GetState().IsKeyDown(Keys.Left) || gamePadState.ThumbSticks.Left.X > Game.gameSettings.controlStickTrigger ||
gamePadState.IsButtonDown(Buttons.DPadRight) || Keyboard.GetState().IsKeyDown(Keys.Left) || gamePadState.ThumbSticks.Left.X < -Game.gameSettings.controlStickTrigger))
{
state = SummaryMenuState.WAIT;
animateTime = 0;
}
if (TutorialStage.restrictions == ControlRestrictions.ShouldersOnly && (gamePadState.IsButtonDown(Buttons.LeftShoulder) || gamePadState.IsButtonDown(Buttons.RightShoulder) || Keyboard.GetState().IsKeyDown(Keys.A) || Keyboard.GetState().IsKeyDown(Keys.S)))
{
state = SummaryMenuState.WAIT;
animateTime = 0;
}
if (TutorialStage.restrictions == ControlRestrictions.TriggersOnly && (gamePadState.IsButtonDown(Buttons.LeftTrigger) || gamePadState.IsButtonDown(Buttons.RightTrigger) || Keyboard.GetState().IsKeyDown(Keys.Q) || Keyboard.GetState().IsKeyDown(Keys.W)))
{
state = SummaryMenuState.WAIT;
animateTime = 0;
}
}
}
return(MenuResult.None);
}
private void ProcessInput(float amountOfMovement)
{
Vector3 moveVector = new Vector3();
KeyboardState keys = Keyboard.GetState();
GamePadState buttons = GamePad.GetState(PlayerIndex.One);
//if (keys.IsKeyDown(Keys.D))
// moveVector.X += amountOfMovement;
//if (keys.IsKeyDown(Keys.A))
// moveVector.X -= amountOfMovement;
//if (keys.IsKeyDown(Keys.S))
// moveVector.Z += amountOfMovement;
//if (keys.IsKeyDown(Keys.W))
// moveVector.Z -= amountOfMovement;
//moveVector.Z += (buttons.DPad.Down == ButtonState.Pressed) ? amountOfMovement : 0.0f;
//moveVector.X -= (buttons.DPad.Left == ButtonState.Pressed) ? amountOfMovement : 0.0f;
//moveVector.Z -= (buttons.DPad.Up == ButtonState.Pressed) ? amountOfMovement : 0.0f;
//moveVector.X += (buttons.DPad.Right == ButtonState.Pressed) ? amountOfMovement : 0.0f;
angles.Y -= buttons.ThumbSticks.Right.X * amountOfMovement * 0.05f;
angles.X += buttons.ThumbSticks.Right.Y * amountOfMovement * 0.05f;
Matrix cameraRotation = Matrix.CreateRotationX(angles.X) * Matrix.CreateRotationY(angles.Y);
position += Vector3.Transform(moveVector, cameraRotation);
MouseState currentMouseState = Mouse.GetState();
if (currentMouseState.RightButton == ButtonState.Pressed && prevMouseState.RightButton == ButtonState.Released)
{
Mouse.SetPosition(widthOver2, heightOver2);
}
else if (currentMouseState.RightButton == ButtonState.Pressed)
{
if (currentMouseState.X != widthOver2)
{
angles.Y -= amountOfMovement / 80.0f * (currentMouseState.X - widthOver2);
}
if (currentMouseState.Y != heightOver2)
{
angles.X -= amountOfMovement / 80.0f * (currentMouseState.Y - heightOver2);
}
Mouse.SetPosition(widthOver2, heightOver2);
}
prevMouseState = currentMouseState;
if (angles.X > 1.4)
{
angles.X = 1.4f;
}
if (angles.X < -1.4)
{
angles.X = -1.4f;
}
if (angles.Y > Math.PI)
{
angles.Y -= 2 * (float)Math.PI;
}
if (angles.Y < -Math.PI)
{
angles.Y += 2 * (float)Math.PI;
}
}
public ButtonCollection(ref GamePadState padState)
{
this._count = 0;
this._pressed = (Buttons)0;
if (padState.IsButtonDown(Buttons.A))
{
this._pressed |= Buttons.A;
this._count++;
}
if (padState.IsButtonDown(Buttons.B))
{
this._pressed |= Buttons.B;
this._count++;
}
if (padState.IsButtonDown(Buttons.X))
{
this._pressed |= Buttons.X;
this._count++;
}
if (padState.IsButtonDown(Buttons.Y))
{
this._pressed |= Buttons.Y;
this._count++;
}
if (padState.IsButtonDown(Buttons.Start))
{
this._pressed |= Buttons.Start;
this._count++;
}
if (padState.IsButtonDown(Buttons.Back))
{
this._pressed |= Buttons.Back;
this._count++;
}
if (padState.IsButtonDown(Buttons.RightTrigger))
{
this._pressed |= Buttons.RightTrigger;
this._count++;
}
if (padState.IsButtonDown(Buttons.LeftTrigger))
{
this._pressed |= Buttons.LeftTrigger;
this._count++;
}
if (padState.IsButtonDown(Buttons.RightShoulder))
{
this._pressed |= Buttons.RightShoulder;
this._count++;
}
if (padState.IsButtonDown(Buttons.LeftShoulder))
{
this._pressed |= Buttons.LeftShoulder;
this._count++;
}
if (padState.IsButtonDown(Buttons.DPadUp))
{
this._pressed |= Buttons.DPadUp;
this._count++;
}
if (padState.IsButtonDown(Buttons.DPadRight))
{
this._pressed |= Buttons.DPadRight;
this._count++;
}
if (padState.IsButtonDown(Buttons.DPadDown))
{
this._pressed |= Buttons.DPadDown;
this._count++;
}
if (padState.IsButtonDown(Buttons.DPadLeft))
{
this._pressed |= Buttons.DPadLeft;
this._count++;
}
if (padState.IsButtonDown(Buttons.LeftThumbstickUp))
{
this._pressed |= Buttons.LeftThumbstickUp;
this._count++;
}
if (padState.IsButtonDown(Buttons.LeftThumbstickRight))
{
this._pressed |= Buttons.LeftThumbstickRight;
this._count++;
}
if (padState.IsButtonDown(Buttons.LeftThumbstickDown))
{
this._pressed |= Buttons.LeftThumbstickDown;
this._count++;
}
if (padState.IsButtonDown(Buttons.LeftThumbstickLeft))
{
this._pressed |= Buttons.LeftThumbstickLeft;
this._count++;
}
}
//Added November 28,2013
#region Controller Input
public void getControllerInput(GamePadState gamePadState)
{
reset();
if (gamePadState.IsButtonUp(Buttons.DPadLeft))
{
m_WasMoveLeftButtonDown = false;
}
else if (gamePadState.IsButtonUp(Buttons.DPadRight))
{
m_WasMoveRightButtonDown = false;
}
if (gamePadState.IsButtonUp(Buttons.RightThumbstickLeft))
{
m_WasMoveCrossLeftButtonDown = false;
}
else if (gamePadState.IsButtonUp(Buttons.RightThumbstickRight))
{
m_WasMoveCrossRightButtonDown = false;
}
if (gamePadState.IsButtonUp(Buttons.RightThumbstickUp))
{
m_WasMoveCrossUpButtonDown = false;
}
else if (gamePadState.IsButtonUp(Buttons.RightThumbstickDown))
{
m_WasMoveCrossDownButtonDown = false;
}
if (gamePadState.IsButtonUp(Buttons.A))
{
m_WasJumpButtonDown = false;
}
if (gamePadState.IsButtonUp(Buttons.RightStick))
{
m_WasRainbowButtonDown = false;
}
if (gamePadState.IsButtonUp(Buttons.RightTrigger))
{
m_WasAttackButtonDown = false;
}
if (gamePadState.IsButtonDown(Buttons.DPadLeft) || gamePadState.IsButtonDown(Buttons.LeftThumbstickLeft))
{
m_WasMoveLeftButtonDown = true;
}
else if (gamePadState.IsButtonDown(Buttons.DPadRight) || gamePadState.IsButtonDown(Buttons.LeftThumbstickRight))
{
m_WasMoveRightButtonDown = true;
}
if (gamePadState.IsButtonDown(Buttons.RightThumbstickLeft))
{
m_WasMoveCrossLeftButtonDown = true;
}
else if (gamePadState.IsButtonDown(Buttons.RightThumbstickRight))
{
m_WasMoveCrossRightButtonDown = true;
}
if (gamePadState.IsButtonDown(Buttons.RightThumbstickUp))
{
m_WasMoveCrossUpButtonDown = true;
}
else if (gamePadState.IsButtonDown(Buttons.RightThumbstickDown))
{
m_WasMoveCrossDownButtonDown = true;
}
if (gamePadState.IsButtonDown(Buttons.A))
{
m_WasJumpButtonDown = true;
}
if (gamePadState.IsButtonDown(Buttons.RightStick))
{
m_WasRainbowButtonDown = true;
}
if (gamePadState.IsButtonDown(Buttons.RightTrigger))
{
m_WasAttackButtonDown = true;
}
}
public ButtonCollection(ref GamePadState padState, ref GamePadState oldPadState)
{
this._count = 0;
this._pressed = (Buttons)0;
if (padState.IsButtonDown(Buttons.A) && !oldPadState.IsButtonDown(Buttons.A))
{
this._pressed |= Buttons.A;
this._count++;
}
if (padState.IsButtonDown(Buttons.B) && !oldPadState.IsButtonDown(Buttons.B))
{
this._pressed |= Buttons.B;
this._count++;
}
if (padState.IsButtonDown(Buttons.X) && !oldPadState.IsButtonDown(Buttons.X))
{
this._pressed |= Buttons.X;
this._count++;
}
if (padState.IsButtonDown(Buttons.Y) && !oldPadState.IsButtonDown(Buttons.Y))
{
this._pressed |= Buttons.Y;
this._count++;
}
if (padState.IsButtonDown(Buttons.Start) && !oldPadState.IsButtonDown(Buttons.Start))
{
this._pressed |= Buttons.Start;
this._count++;
}
if (padState.IsButtonDown(Buttons.Back) && !oldPadState.IsButtonDown(Buttons.Back))
{
this._pressed |= Buttons.Back;
this._count++;
}
if (padState.IsButtonDown(Buttons.RightTrigger) && !oldPadState.IsButtonDown(Buttons.RightTrigger))
{
this._pressed |= Buttons.RightTrigger;
this._count++;
}
if (padState.IsButtonDown(Buttons.LeftTrigger) && !oldPadState.IsButtonDown(Buttons.LeftTrigger))
{
this._pressed |= Buttons.LeftTrigger;
this._count++;
}
if (padState.IsButtonDown(Buttons.RightShoulder) && !oldPadState.IsButtonDown(Buttons.RightShoulder))
{
this._pressed |= Buttons.RightShoulder;
this._count++;
}
if (padState.IsButtonDown(Buttons.LeftShoulder) && !oldPadState.IsButtonDown(Buttons.LeftShoulder))
{
this._pressed |= Buttons.LeftShoulder;
this._count++;
}
if (padState.IsButtonDown(Buttons.DPadUp) && !oldPadState.IsButtonDown(Buttons.DPadUp))
{
this._pressed |= Buttons.DPadUp;
this._count++;
}
if (padState.IsButtonDown(Buttons.DPadRight) && !oldPadState.IsButtonDown(Buttons.DPadRight))
{
this._pressed |= Buttons.DPadRight;
this._count++;
}
if (padState.IsButtonDown(Buttons.DPadDown) && !oldPadState.IsButtonDown(Buttons.DPadDown))
{
this._pressed |= Buttons.DPadDown;
this._count++;
}
if (padState.IsButtonDown(Buttons.DPadLeft) && !oldPadState.IsButtonDown(Buttons.DPadLeft))
{
this._pressed |= Buttons.DPadLeft;
this._count++;
}
if ((double)padState.ThumbSticks.Left.Y > 0.2 && (double)oldPadState.ThumbSticks.Left.Y <= 0.2 && Utility.thumbstickIsInDirection(0, padState))
{
this._pressed |= Buttons.LeftThumbstickUp;
this._count++;
}
if ((double)padState.ThumbSticks.Left.X > 0.2 && (double)oldPadState.ThumbSticks.Left.X <= 0.2 && Utility.thumbstickIsInDirection(1, padState))
{
this._pressed |= Buttons.LeftThumbstickRight;
this._count++;
}
if ((double)padState.ThumbSticks.Left.Y < -0.2 && (double)oldPadState.ThumbSticks.Left.Y >= -0.2 && Utility.thumbstickIsInDirection(2, padState))
{
this._pressed |= Buttons.LeftThumbstickDown;
this._count++;
}
if ((double)padState.ThumbSticks.Left.X < -0.2 && (double)oldPadState.ThumbSticks.Left.X >= -0.2 && Utility.thumbstickIsInDirection(3, padState))
{
this._pressed |= Buttons.LeftThumbstickLeft;
this._count++;
}
}
public GamePadState GetState(int index)
{
JoystickState joy = Joystick.GetState(index);
GamePadState pad = new GamePadState();
if (joy.IsConnected)
{
pad.SetConnected(true);
pad.SetPacketNumber(joy.PacketNumber);
GamePadConfiguration configuration = GetConfiguration(Joystick.GetGuid(index));
foreach (GamePadConfigurationItem map in configuration)
{
switch (map.Source.Type)
{
case ConfigurationType.Axis:
{
// JoystickAxis -> Buttons/GamePadAxes mapping
JoystickAxis source_axis = map.Source.Axis;
GamePadAxes target_axis = map.Target.Axis;
short value = joy.GetAxisRaw(source_axis);
switch (map.Target.Type)
{
case ConfigurationType.Axis:
pad.SetAxis(target_axis, value);
break;
case ConfigurationType.Button:
throw new NotImplementedException();
break;
}
}
break;
case ConfigurationType.Button:
{
// JoystickButton -> Buttons/GamePadAxes mapping
JoystickButton source_button = map.Source.Button;
Buttons target_button = map.Target.Button;
bool pressed = joy.GetButton(source_button) == ButtonState.Pressed;
switch (map.Target.Type)
{
case ConfigurationType.Axis:
throw new NotImplementedException();
break;
case ConfigurationType.Button:
pad.SetButton(target_button, pressed);
break;
}
}
break;
}
}
}
return pad;
}
protected void UpdateInput()
{
KeyboardState currentKeyState = Keyboard.GetState();
GamePadState currentGamePadState = GamePad.GetState(PlayerIndex.One);
bool engineon = false;
if (currentGamePadState.IsConnected)
{
//rotate the model using the left thumbstick, and scale it down
modelYaw -= currentGamePadState.ThumbSticks.Left.X * 0.10f;
//create some velocity if the right trigger is down
Vector3 modelVelocityAdd = Vector3.Zero;
//findout what direction we should be thrusting using rotation
modelVelocityAdd.X = -(float)Math.Sin(modelYaw);
modelVelocityAdd.Z = -(float)(Math.Cos(modelYaw) * Math.Cos(modelPitch));
modelVelocityAdd.Y = (float)(Math.Cos(modelYaw) * Math.Sin(modelPitch));
//Now scale our direction by how hard the trigger is down
modelVelocityAdd *= currentGamePadState.Triggers.Right;
if (currentGamePadState.Triggers.Right != 0f)
{
engineon = true;
}
//finally, add this vector to our velocity
//modelVelocity += modelVelocityAdd;
GamePad.SetVibration(PlayerIndex.One, currentGamePadState.Triggers.Right, currentGamePadState.Triggers.Right);
//In case you get lost, press A to warp back to center
if (currentGamePadState.Buttons.A == ButtonState.Pressed)
{
//modelPosition = startPosition;
//modelVelocity = Vector3.Zero;
modelYaw = 0.0f;
}
}
if (currentKeyState.IsKeyDown(Keys.A))
{
BEPUutilities.Vector3 rot = physicsObject.WorldTransform.Up;
physicsObject.ApplyAngularImpulse(ref rot);
}
if (currentKeyState.IsKeyDown(Keys.D))
{
BEPUutilities.Vector3 rot = physicsObject.WorldTransform.Down;
physicsObject.ApplyAngularImpulse(ref rot);
}
if (currentKeyState.IsKeyDown(Keys.S))
{
BEPUutilities.Vector3 rot = physicsObject.WorldTransform.Right;
physicsObject.ApplyAngularImpulse(ref rot);
}
if (currentKeyState.IsKeyDown(Keys.X))
{
BEPUutilities.Vector3 rot = physicsObject.WorldTransform.Left;
physicsObject.ApplyAngularImpulse(ref rot);
}
if (currentKeyState.IsKeyDown(Keys.Q))
{
BEPUutilities.Vector3 rot = physicsObject.WorldTransform.Backward;
physicsObject.ApplyAngularImpulse(ref rot);
}
if (currentKeyState.IsKeyDown(Keys.E))
{
BEPUutilities.Vector3 rot = physicsObject.WorldTransform.Forward;
physicsObject.ApplyAngularImpulse(ref rot);
}
if (currentKeyState.IsKeyDown(Keys.W))
{
physicsObject.ApplyImpulse(physicsObject.Position, physicsObject.WorldTransform.Forward);
engineon = true;
}
if (currentKeyState.IsKeyDown(Keys.P))
{
//modelPosition = Vector3.Zero;
// modelVelocity = Vector3.Zero;
soundHyperSpaceActivation.Play();
}
if (engineon)
{
if (soundEngineInstance.State == SoundState.Stopped)
{
soundEngineInstance.Volume = 0.75f;
soundEngineInstance.IsLooped = true;
soundEngineInstance.Play();
}
else
{
soundEngineInstance.Resume();
}
}
else
{
soundEngineInstance.Pause();
}
}
public void UpdateState()
{
this.caps = GamePad.GetCapabilities(this.deviceIndex);
this.state = GamePad.GetState(this.deviceIndex);
}
void UpdateTitle(GameTime gameTime)
{
elapsedMilliseconds -= gameTime.ElapsedGameTime.Milliseconds;
if (toMenu)
{
//Runs once every time the game returns to the menu (not on every loop), use this for single functions
printString.Do(this, new Vector2(65, 180), "start game", 0.1f, 35, fontSheetSprite, fontSheetTexture);
printString.Do(this, new Vector2(65, 230), "options", 0.1f, 35, fontSheetSprite, fontSheetTexture);
printString.Do(this, new Vector2(58, 280), "bonus content", 0.1f, 35, fontSheetSprite, fontSheetTexture);
printString.Do(this, new Vector2(65, 330), "exit", 0.1f, 35, fontSheetSprite, fontSheetTexture);
printString.Do(this, new Vector2(0, 0), "Hello", 0.1f, 35, fontSheetSprite, fontSheetTexture);
toMenu = false;
}
currentKeyState = Keyboard.GetState();
if (oldKeyState == null)
{
oldKeyState = currentKeyState;
}
currentPadState = GamePad.GetState(PlayerIndex.One);
if (oldPadState == null)
{
oldPadState = currentPadState;
}
if ((currentKeyState.IsKeyDown(Keys.Down))) // For navigating the Main Menu && (oldKeyState.IsKeyUp(Keys.Down)
{
if (pointIndex < 3)
{
pointIndex++;
}
else
{
pointIndex = 0;
}
}
if ((currentKeyState.IsKeyDown(Keys.S)) && (oldKeyState.IsKeyUp(Keys.S))) // Alternate button navigation (WASD) ((Subject to change when options are up))
{
if (pointIndex < 3)
{
pointIndex++;
}
else
{
pointIndex = 0;
}
}
if ((currentKeyState.IsKeyDown(Keys.Up)) && (oldKeyState.IsKeyUp(Keys.Up))) // For navigating the Main Menu
{
if (pointIndex > 0)
{
pointIndex--;
}
else
{
pointIndex = 3;
}
}
if ((currentKeyState.IsKeyDown(Keys.W)) && (oldKeyState.IsKeyUp(Keys.W))) // Alternate button navigation (WASD) ((Subject to change when options are up))
{
if (pointIndex > 0)
{
pointIndex--;
}
else
{
pointIndex = 3;
}
}
if (pointIndex == 0)
{
CurrentPoint = PointingAt.PLAY;
pointerSprite.UpperLeft = new Vector2(10, 170);
}
if (pointIndex == 1)
{
CurrentPoint = PointingAt.OPTIONS;
pointerSprite.UpperLeft = new Vector2(10, 220);
}
if (pointIndex == 2)
{
CurrentPoint = PointingAt.BONUS;
pointerSprite.UpperLeft = new Vector2(10, 270);
}
if (pointIndex == 3)
{
CurrentPoint = PointingAt.EXIT;
pointerSprite.UpperLeft = new Vector2(10, 320);
}
if ((currentKeyState.IsKeyDown(Keys.Enter)) && (oldKeyState.IsKeyUp(Keys.Enter)))
{
if (CurrentPoint == PointingAt.PLAY)
{
}
if (CurrentPoint == PointingAt.OPTIONS)
{
}
if (CurrentPoint == PointingAt.BONUS)
{
}
if (CurrentPoint == PointingAt.EXIT)
{
Exit();
}
}
oldKeyState = currentKeyState;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
private void BuildGamePadEvent(GamePadState state, GamePadButton button, ref GamePadEventArgs e)
{
e.State = state;
e.Button = button;
//e.Vectors.LeftStick = new Vector2(state.ThumbSticks.Left.X, state.ThumbSticks.Left.Y);
//e.Vectors.RightStick = new Vector2(state.ThumbSticks.Right.X, state.ThumbSticks.Right.Y);
//e.Vectors.LeftTrigger = state.Triggers.Left;
//e.Vectors.RightTrigger = state.Triggers.Right;
}
/// <summary>
/// Makes sure the sprite is updated properly.
/// </summary>
/// <param name="gameTime"></param>
public void Update(GameTime gameTime)
{
//updating the game input data
previousGamePadState = gamePadState;
gamePadState = GamePad.GetState(0);
previousKeyboardState = keyboardState;
keyboardState = Keyboard.GetState();
float t = (float)gameTime.ElapsedGameTime.TotalSeconds;
Vector2 acceleration = new Vector2(0, 0);
//User input
if (!dead)
{
//Gamepad input
position += gamePadState.ThumbSticks.Left * new Vector2(1, 1);
if (gamePadState.ThumbSticks.Left.X < 0)
{
flipped = true;
}
if (gamePadState.ThumbSticks.Left.X > 0)
{
flipped = false;
}
//Keyboard input
if (keyboardState.IsKeyDown(Keys.W))
{
//position += new Vector2(0, -2);
acceleration.Y += -1.1f;
}
if (keyboardState.IsKeyDown(Keys.S))
{
//position += new Vector2(0, 2);
acceleration.Y += 1.1f;
}
if (keyboardState.IsKeyDown(Keys.D))
{
//position += new Vector2(2, 0);
acceleration.X += 1.1f;
flipped = false;
}
if (keyboardState.IsKeyDown(Keys.A))
{
//position += new Vector2(-2, 0);
acceleration.X += -1.1f;
flipped = true;
}
if (keyboardState.IsKeyDown(Keys.W) && previousKeyboardState.IsKeyUp(Keys.W))
{
movement.Play();
}
if (keyboardState.IsKeyDown(Keys.S) && previousKeyboardState.IsKeyUp(Keys.S))
{
movement.Play();
}
if (keyboardState.IsKeyDown(Keys.D) && previousKeyboardState.IsKeyUp(Keys.D))
{
movement.Play();
}
if (keyboardState.IsKeyDown(Keys.A) && previousKeyboardState.IsKeyUp(Keys.A))
{
movement.Play();
}
velocity += acceleration * t * 150;
position += velocity * t;
velocity *= 0.97f;
if (Math.Abs(velocity.X) <= 2.1)
{
velocity.X = 0;
}
if (Math.Abs(velocity.Y) <= 2.1)
{
velocity.Y = 0;
}
//Attacking input
if (keyboardState.IsKeyDown(Keys.Up) && previousKeyboardState.IsKeyUp(Keys.Up))
{
attack = Attack.Up;
swordSwing.Play();
}
else if (keyboardState.IsKeyDown(Keys.Right) && previousKeyboardState.IsKeyUp(Keys.Right))
{
attack = Attack.Right;
flipped = false;
swordSwing.Play();
}
else if (keyboardState.IsKeyDown(Keys.Down) && previousKeyboardState.IsKeyUp(Keys.Down))
{
attack = Attack.Down;
swordSwing.Play();
}
else if (keyboardState.IsKeyDown(Keys.Left) && previousKeyboardState.IsKeyUp(Keys.Left))
{
attack = Attack.Left;
flipped = true;
swordSwing.Play();
}
else //if(keyboardState.IsKeyUp(Keys.Up) && keyboardState.IsKeyUp(Keys.Right) && keyboardState.IsKeyUp(Keys.Down) && keyboardState.IsKeyUp(Keys.Left))
{
attack = Attack.None;
}
if (position.X < 25)
{
position = new Vector2(25, position.Y);
}
if (position.Y < 25)
{
position = new Vector2(position.X, 25);
}
if (position.X > _worldLength - 100)
{
position = new Vector2(_worldLength - 100, position.Y);
}
if (position.Y > 480)
{
position = new Vector2(position.X, 480);
}
}
//collision
bounds.X = position.X - 10;
bounds.Y = position.Y - 12;
swordBoundUp.X = position.X + 3;
swordBoundUp.Y = position.Y - 48;
swordBoundRight.X = position.X + 16;
swordBoundRight.Y = position.Y - 2;
swordBoundDown.X = position.X;
swordBoundDown.Y = position.Y + 16;
swordBoundLeft.X = position.X - 48;
swordBoundLeft.Y = position.Y - 15;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
private void UpdateGamePad(PlayerIndex playerIndex, GamePadState state, GameTime gameTime)
{
GamePadEventArgs e = new GamePadEventArgs(playerIndex);
//if (state.ThumbSticks.Left != gamePadState.ThumbSticks.Left ||
// state.ThumbSticks.Right != gamePadState.ThumbSticks.Right ||
// state.Triggers.Left != gamePadState.Triggers.Left ||
// state.Triggers.Right != gamePadState.Triggers.Right)
//{
// BuildGamePadEvent(state, GamePadButton.None, ref e);
// if (GamePadMove != null) GamePadMove.Invoke(this, e);
//}
foreach (InputGamePadButton btn in gamePadButtons)
{
ButtonState bs; ;
if (btn.Button == GamePadButton.None) continue;
//else if (btn.Button == GamePadButton.A) bs = state.Buttons.A;
//else if (btn.Button == GamePadButton.B) bs = state.Buttons.B;
//else if (btn.Button == GamePadButton.Back) bs = state.Buttons.Back;
//else if (btn.Button == GamePadButton.Down) bs = state.DPad.Down;
//else if (btn.Button == GamePadButton.Left) bs = state.DPad.Left;
//else if (btn.Button == GamePadButton.Right) bs = state.DPad.Right;
//else if (btn.Button == GamePadButton.Start) bs = state.Buttons.Start;
//else if (btn.Button == GamePadButton.Up) bs = state.DPad.Up;
//else if (btn.Button == GamePadButton.X) bs = state.Buttons.X;
//else if (btn.Button == GamePadButton.Y) bs = state.Buttons.Y;
//else if (btn.Button == GamePadButton.BigButton) bs = state.Buttons.BigButton;
//else if (btn.Button == GamePadButton.LeftShoulder) bs = state.Buttons.LeftShoulder;
//else if (btn.Button == GamePadButton.RightShoulder) bs = state.Buttons.RightShoulder;
//else if (btn.Button == GamePadButton.LeftStick) bs = state.Buttons.LeftStick;
//else if (btn.Button == GamePadButton.RightStick) bs = state.Buttons.RightStick;
else bs = GetVectorState(btn.Button, state);
bool pressed = bs.Pressed;
if (pressed)
{
double ms = gameTime.ElapsedGameTime.TotalMilliseconds;
if (pressed) btn.Countdown -= ms;
}
if ((pressed) && (!btn.Pressed))
{
btn.Pressed = true;
BuildGamePadEvent(state, btn.Button, ref e);
if (GamePadDown != null) GamePadDown.Invoke(this, e);
if (GamePadPress != null) GamePadPress.Invoke(this, e);
}
else if ((!pressed) && (btn.Pressed))
{
btn.Pressed = false;
btn.Countdown = RepeatDelay;
BuildGamePadEvent(state, btn.Button, ref e);
if (GamePadUp != null) GamePadUp.Invoke(this, e);
}
else if (btn.Pressed && btn.Countdown < 0)
{
e.Button = btn.Button;
btn.Countdown = RepeatRate;
BuildGamePadEvent(state, btn.Button, ref e);
if (GamePadPress != null) GamePadPress.Invoke(this, e);
}
}
gamePadState = state;
}
public ISpriteGamePadState HandleInput(Sprite player, GamePadCapabilities cap, GamePadState state)
{
if (!IsFiring(state))
{
return(new HoldingState());
}
if (_shootDelay <= 0)
{
state = GamePad.GetState(PlayerIndex.One, GamePadDeadZone.Circular);
float rotation = state.ThumbSticks.Right.Angle();
GetNextBullet(rotation, player);
// TODO: Ammunition check
//if (GetNextBullet(rotation, player) == null)
//{
// // switch to pistol
//}
_shootDelay = ActiveWeapon.ShootDelay;
}
return(null);
}
/// <summary>
/// Updates the specified game pad index.
/// </summary>
/// <param name="gamePadIndex">Index of the game pad.</param>
public override void Update(int gamePadIndex)
{
if (XenkoInputDevice.NativeInputManager.HasGamePad)
{
state = XenkoInputDevice.NativeInputManager.GetGamePad(0);
}
}
private void ProcessInput()
{
float deltaTime = (float)Game.UpdateTime.Elapsed.TotalSeconds;
translation = Vector3.Zero;
yaw = 0f;
pitch = 0f;
// Keyboard and Gamepad based movement
{
// Our base speed is: one unit per second:
// deltaTime contains the duration of the previous frame, let's say that in this update
// or frame it is equal to 1/60, that means that the previous update ran 1/60 of a second ago
// and the next will, in most cases, run in around 1/60 of a second from now. Knowing that,
// we can move 1/60 of a unit on this frame so that in around 60 frames(1 second)
// we will have travelled one whole unit in a second.
// If you don't use deltaTime your speed will be dependant on the amount of frames rendered
// on screen which often are inconsistent, meaning that if the player has performance issues,
// this entity will move around slower.
float speed = 1f * deltaTime;
Vector3 dir = Vector3.Zero;
if (Gamepad && Input.HasGamePad)
{
GamePadState padState = Input.DefaultGamePad.State;
// LeftThumb can be positive or negative on both axis (pushed to the right or to the left)
dir.Z += padState.LeftThumb.Y;
dir.X += padState.LeftThumb.X;
// Triggers are always positive, in this case using one to increase and the other to decrease
dir.Y -= padState.LeftTrigger;
dir.Y += padState.RightTrigger;
// Increase speed when pressing A, LeftShoulder or RightShoulder
// Here:does the enum flag 'Buttons' has one of the flag ('A','LeftShoulder' or 'RightShoulder') set
if ((padState.Buttons & (GamePadButton.A | GamePadButton.LeftShoulder | GamePadButton.RightShoulder)) != 0)
{
speed *= SpeedFactor;
}
}
if (Input.HasKeyboard)
{
// Move with keyboard
// Forward/Backward
if (Input.IsKeyDown(Keys.W) || Input.IsKeyDown(Keys.Up))
{
dir.Z += 1;
}
if (Input.IsKeyDown(Keys.S) || Input.IsKeyDown(Keys.Down))
{
dir.Z -= 1;
}
// Left/Right
if (Input.IsKeyDown(Keys.A) || Input.IsKeyDown(Keys.Left))
{
dir.X -= 1;
}
if (Input.IsKeyDown(Keys.D) || Input.IsKeyDown(Keys.Right))
{
dir.X += 1;
}
// Down/Up
if (Input.IsKeyDown(Keys.Q))
{
dir.Y -= 1;
}
if (Input.IsKeyDown(Keys.E))
{
dir.Y += 1;
}
// Increase speed when pressing shift
if (Input.IsKeyDown(Keys.LeftShift) || Input.IsKeyDown(Keys.RightShift))
{
speed *= SpeedFactor;
}
// If the player pushes down two or more buttons, the direction and ultimately the base speed
// will be greater than one (vector(1, 1) is farther away from zero than vector(0, 1)),
// normalizing the vector ensures that whichever direction the player chooses, that direction
// will always be at most one unit in length.
// We're keeping dir as is if isn't longer than one to retain sub unit movement:
// a stick not entirely pushed forward should make the entity move slower.
if (dir.Length() > 1f)
{
dir = Vector3.Normalize(dir);
}
}
// Finally, push all of that to the translation variable which will be used within UpdateTransform()
translation += dir * KeyboardMovementSpeed * speed;
}
// Keyboard and Gamepad based Rotation
{
// See Keyboard & Gamepad translation's deltaTime usage
float speed = 1f * deltaTime;
Vector2 rotation = Vector2.Zero;
if (Gamepad && Input.HasGamePad)
{
GamePadState padState = Input.DefaultGamePad.State;
rotation.X += padState.RightThumb.Y;
rotation.Y += -padState.RightThumb.X;
}
if (Input.HasKeyboard)
{
if (Input.IsKeyDown(Keys.NumPad2))
{
rotation.X += 1;
}
if (Input.IsKeyDown(Keys.NumPad8))
{
rotation.X -= 1;
}
if (Input.IsKeyDown(Keys.NumPad4))
{
rotation.Y += 1;
}
if (Input.IsKeyDown(Keys.NumPad6))
{
rotation.Y -= 1;
}
// See Keyboard & Gamepad translation's Normalize() usage
if (rotation.Length() > 1f)
{
rotation = Vector2.Normalize(rotation);
}
}
// Modulate by speed
rotation *= KeyboardRotationSpeed * speed;
// Finally, push all of that to pitch & yaw which are going to be used within UpdateTransform()
pitch += rotation.X;
yaw += rotation.Y;
}
// Mouse movement and gestures
{
// This type of input should not use delta time at all, they already are frame-rate independent.
// Lets say that you are going to move your finger/mouse for one second over 40 units, it doesn't matter
// the amount of frames occuring within that time frame, each frame will receive the right amount of delta:
// a quarter of a second -> 10 units, half a second -> 20 units, one second -> your 40 units.
if (Input.HasMouse)
{
// Rotate with mouse
if (Input.IsMouseButtonDown(MouseButton.Right))
{
Input.LockMousePosition();
Game.IsMouseVisible = false;
yaw -= Input.MouseDelta.X * MouseRotationSpeed.X;
pitch -= Input.MouseDelta.Y * MouseRotationSpeed.Y;
}
else
{
Input.UnlockMousePosition();
Game.IsMouseVisible = true;
}
}
// Handle gestures
foreach (var gestureEvent in Input.GestureEvents)
{
switch (gestureEvent.Type)
{
// Rotate by dragging
case GestureType.Drag:
var drag = (GestureEventDrag)gestureEvent;
var dragDistance = drag.DeltaTranslation;
yaw = -dragDistance.X * TouchRotationSpeed.X;
pitch = -dragDistance.Y * TouchRotationSpeed.Y;
break;
// Move along z-axis by scaling and in xy-plane by multi-touch dragging
case GestureType.Composite:
var composite = (GestureEventComposite)gestureEvent;
translation.X = -composite.DeltaTranslation.X * TouchMovementSpeed.X;
translation.Y = -composite.DeltaTranslation.Y * TouchMovementSpeed.Y;
translation.Z = (float)Math.Log(composite.DeltaScale + 1) * TouchMovementSpeed.Z;
break;
}
}
}
}
public GamePadState GetState(int index)
{
JoystickState joy = Joystick.GetState(index);
GamePadState pad = new GamePadState();
if (joy.IsConnected)
{
pad.SetConnected(true);
pad.SetPacketNumber(joy.PacketNumber);
GamePadConfiguration configuration = GetConfiguration(Joystick.GetGuid(index));
foreach (GamePadConfigurationItem map in configuration)
{
switch (map.Source.Type)
{
case ConfigurationType.Axis:
{
// JoystickAxis -> Buttons/GamePadAxes mapping
JoystickAxis source_axis = map.Source.Axis;
short value = joy.GetAxisRaw(source_axis);
switch (map.Target.Type)
{
case ConfigurationType.Axis:
pad.SetAxis(map.Target.Axis, value);
break;
case ConfigurationType.Button:
// Todo: if SDL2 GameController config is ever updated to
// distinguish between negative/positive axes, then remove
// Math.Abs below.
// Button is considered press when the axis is >= 0.5 from center
pad.SetButton(map.Target.Button, Math.Abs(value) >= short.MaxValue >> 1);
break;
}
}
break;
case ConfigurationType.Button:
{
// JoystickButton -> Buttons/GamePadAxes mapping
JoystickButton source_button = map.Source.Button;
bool pressed = joy.GetButton(source_button) == ButtonState.Pressed;
switch (map.Target.Type)
{
case ConfigurationType.Axis:
// Todo: if SDL2 GameController config is ever updated to
// distinguish between negative/positive axes, then update
// the following line to support both.
short value = pressed ?
short.MaxValue :
(map.Target.Axis & (GamePadAxes.LeftTrigger | GamePadAxes.RightTrigger)) != 0 ?
short.MinValue :
(short)0;
pad.SetAxis(map.Target.Axis, value);
break;
case ConfigurationType.Button:
pad.SetButton(map.Target.Button, pressed);
break;
}
}
break;
case ConfigurationType.Hat:
{
// JoystickHat -> Buttons/GamePadAxes mapping
JoystickHat source_hat = map.Source.Hat;
JoystickHatState state = joy.GetHat(source_hat);
bool pressed = false;
switch (map.Source.HatPosition)
{
case HatPosition.Down:
pressed = state.IsDown;
break;
case HatPosition.Up:
pressed = state.IsUp;
break;
case HatPosition.Left:
pressed = state.IsLeft;
break;
case HatPosition.Right:
pressed = state.IsRight;
break;
}
switch (map.Target.Type)
{
case ConfigurationType.Axis:
// Todo: if SDL2 GameController config is ever updated to
// distinguish between negative/positive axes, then update
// the following line to support both.
short value = pressed ?
short.MaxValue :
(map.Target.Axis & (GamePadAxes.LeftTrigger | GamePadAxes.RightTrigger)) != 0 ?
short.MinValue :
(short)0;
pad.SetAxis(map.Target.Axis, value);
break;
case ConfigurationType.Button:
pad.SetButton(map.Target.Button, pressed);
break;
}
}
break;
}
}
}
return pad;
}
protected override void Update(GameTime gameTime)
{
if (MediaPlayer.State == MediaState.Stopped)
{
MediaPlayer.Play(backgroundSong);
}
prevState = state;
state = GamePad.GetState(PlayerIndex.One);
state2 = GamePad.GetState(PlayerIndex.Two);
state3 = GamePad.GetState(PlayerIndex.Three);
state4 = GamePad.GetState(PlayerIndex.Four);
if (!state.IsConnected)
{
player1.Visible = false;
}
else if (!state2.IsConnected)
{
player2.Visible = false;
}
if (!state3.IsConnected)
{
player3.Visible = false;
}
if (!state4.IsConnected)
{
player4.Visible = false;
}
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape) || state.Buttons.Back == ButtonState.Pressed)
{
Exit();
}
// TODO: Add your update logic here
if (state.Buttons.Start == ButtonState.Pressed && prevState.Buttons.Start != ButtonState.Pressed)
{
paused = !paused;
}
if (!paused)
{
if (screen == ScreenState.Home)
{
if (state.Buttons.A == ButtonState.Pressed)
{
screen = ScreenState.Single;
}
else if (state.Buttons.B == ButtonState.Pressed)
{
screen = ScreenState.Multi;
}
}
else
{
player1.Update(GraphicsDevice.Viewport.Bounds, projectileSprite, gameTime, PlayerIndex.One);
if (screen == ScreenState.Single)
{
for (int i = 0; i < Denis.projectiles.Count; i++)
{
if (Denis.projectiles[i].Hitbox.Intersects(player1.Hitbox))
{
player1.Visible = false;
}
}
Denis.Update(GraphicsDevice.Viewport.Bounds, gameTime, player1.projectiles, projectileSprite, player1.Position, 10);
player1.Points = Denis.Points;
}
else if (screen == ScreenState.Multi)
{
player2.Update(GraphicsDevice.Viewport.Bounds, projectileSprite, gameTime, PlayerIndex.Two);
player3.Update(GraphicsDevice.Viewport.Bounds, projectileSprite, gameTime, PlayerIndex.Three);
for (int i = 0; i < player1.projectiles.Count; i++)
{
if (player1.projectiles[i].Hitbox.Intersects(player2.Hitbox))
{
player2.Visible = false;
}
else if (player1.projectiles[i].Hitbox.Intersects(player3.Hitbox))
{
player3.Visible = false;
}
else if (player1.projectiles[i].Hitbox.Intersects(player4.Hitbox))
{
player4.Visible = false;
}
}
for (int i = 0; i < player2.projectiles.Count; i++)
{
if (player2.projectiles[i].Hitbox.Intersects(player1.Hitbox))
{
player1.Visible = false;
}
else if (player2.projectiles[i].Hitbox.Intersects(player3.Hitbox))
{
player3.Visible = false;
}
else if (player2.projectiles[i].Hitbox.Intersects(player4.Hitbox))
{
player4.Visible = false;
}
}
for (int i = 0; i < player3.projectiles.Count; i++)
{
if (player3.projectiles[i].Hitbox.Intersects(player1.Hitbox))
{
player1.Visible = false;
}
else if (player3.projectiles[i].Hitbox.Intersects(player2.Hitbox))
{
player2.Visible = false;
}
if (player4.projectiles[i].Hitbox.Intersects(player4.Hitbox))
{
player4.Visible = false;
}
}
for (int i = 0; i < player4.projectiles.Count; i++)
{
if (player4.projectiles[i].Hitbox.Intersects(player1.Hitbox))
{
player1.Visible = false;
}
else if (player4.projectiles[i].Hitbox.Intersects(player2.Hitbox))
{
player3.Visible = false;
}
else if (player4.projectiles[i].Hitbox.Intersects(player3.Hitbox))
{
player4.Visible = false;
}
}
}
}
}
else
{
if (state.Buttons.Y == ButtonState.Pressed)
{
paused = false;
screen = ScreenState.Home;
}
}
if (screen == ScreenState.Single)
{
if ((state.Buttons.LeftShoulder == ButtonState.Pressed || state2.Buttons.LeftShoulder == ButtonState.Pressed) && !player1.Visible)
{
player1.Position = Vector2.Zero;
player1.Visible = true;
player1.Points = 0;
Denis.Points = 0;
}
}
else if (screen == ScreenState.Multi)
{
if ((state.Buttons.LeftShoulder == ButtonState.Pressed || state2.Buttons.LeftShoulder == ButtonState.Pressed || state3.Buttons.LeftShoulder == ButtonState.Pressed || state4.Buttons.LeftShoulder == ButtonState.Pressed) && (!player1.Visible || !player2.Visible || !player3.Visible || !player4.Visible) && screen == ScreenState.Multi)
{
player1.Position = Vector2.Zero;
player2.Position = new Vector2(GraphicsDevice.Viewport.Width - characterTexture.Width, GraphicsDevice.Viewport.Height - characterTexture.Height);
player3.Position = new Vector2(0, GraphicsDevice.Viewport.Height - characterTexture.Height);
player4.Position = new Vector2(GraphicsDevice.Viewport.Width - characterTexture.Width, 0);
player1.Visible = true;
player2.Visible = true;
player3.Visible = true;
player4.Visible = true;
}
}
base.Update(gameTime);
}
/// <summary>
/// Allows this instance to execute custom logic during its <c>Update</c>.
/// </summary>
/// <param name="gameTime">The game time.</param>
/// <remarks>
/// This method will not be executed if it are not <c>Active</c>.
/// </remarks>
protected override void Update(TimeSpan gameTime)
{
MyScene myscene = this.Scene as MyScene;
// Set Default
myscene.buttonA.IsVisible = false;
myscene.buttonB.IsVisible = false;
myscene.buttonX.IsVisible = false;
myscene.buttonY.IsVisible = false;
myscene.buttonBack.IsVisible = false;
myscene.buttonStart.IsVisible = false;
myscene.dpadUp.IsVisible = false;
myscene.dpadDown.IsVisible = false;
myscene.dpadLeft.IsVisible = false;
myscene.dpadRight.IsVisible = false;
myscene.rightJoystick.FindComponent<SpriteAtlas>().TextureName = "JoyStick";
myscene.leftJoystick.FindComponent<SpriteAtlas>().TextureName = "JoyStick";
myscene.leftShoulder.IsVisible = false;
myscene.rightShoulder.IsVisible = false;
myscene.leftTrigger.IsVisible = false;
myscene.rightTrigger.IsVisible = false;
var inputService = WaveServices.Input;
if (inputService.GamePadState.IsConnected)
{
// A
if (inputService.GamePadState.Buttons.A == ButtonState.Pressed)
{
myscene.buttonA.IsVisible = true;
}
// B
if (inputService.GamePadState.Buttons.B == ButtonState.Pressed)
{
myscene.buttonB.IsVisible = true;
}
// X
if (inputService.GamePadState.Buttons.X == ButtonState.Pressed)
{
myscene.buttonX.IsVisible = true;
}
// Y
if (inputService.GamePadState.Buttons.Y == ButtonState.Pressed)
{
myscene.buttonY.IsVisible = true;
}
// RightShoulder
if (inputService.GamePadState.Buttons.RightShoulder == ButtonState.Pressed)
{
myscene.rightShoulder.IsVisible = true;
}
// LeftShoulder
if (inputService.GamePadState.Buttons.LeftShoulder == ButtonState.Pressed)
{
myscene.leftShoulder.IsVisible = true;
}
// RightStick
if (inputService.GamePadState.Buttons.RightStick == ButtonState.Pressed)
{
myscene.rightJoystick.FindComponent<SpriteAtlas>().TextureName = "JoyStickPressed";
}
// LeftStick
if (inputService.GamePadState.Buttons.LeftStick == ButtonState.Pressed)
{
myscene.leftJoystick.FindComponent<SpriteAtlas>().TextureName = "JoyStickPressed";
}
// Start
if (inputService.GamePadState.Buttons.Start == ButtonState.Pressed)
{
myscene.buttonStart.IsVisible = true;
}
// Back
if (inputService.GamePadState.Buttons.Back == ButtonState.Pressed)
{
myscene.buttonBack.IsVisible = true;
}
// DPad Right
if (inputService.GamePadState.DPad.Right == ButtonState.Pressed)
{
myscene.dpadRight.IsVisible = true;
}
// DPad Left
if (inputService.GamePadState.DPad.Left == ButtonState.Pressed)
{
myscene.dpadLeft.IsVisible = true;
}
// DPad Up
if (inputService.GamePadState.DPad.Up == ButtonState.Pressed)
{
myscene.dpadUp.IsVisible = true;
}
// DPad Down
if (inputService.GamePadState.DPad.Down == ButtonState.Pressed)
{
myscene.dpadDown.IsVisible = true;
}
// Triggers
if (inputService.GamePadState.Triggers.Right > 0)
{
myscene.rightTrigger.IsVisible = true;
myscene.rightTriggerText.Text = "RightTrigger: " + inputService.GamePadState.Triggers.Right;
}
else
{
myscene.rightTriggerText.Text = "RightTrigger: 0";
}
if (inputService.GamePadState.Triggers.Left > 0)
{
myscene.leftTrigger.IsVisible = true;
myscene.leftTriggerText.Text = "LeftTrigger: " + inputService.GamePadState.Triggers.Left;
}
else
{
myscene.leftTriggerText.Text = "LeftTrigger: 0";
}
// Sticks
myscene.leftJoystick.FindComponent<Transform2D>().LocalX = inputService.GamePadState.ThumbStricks.Left.X * 10;
myscene.leftJoystick.FindComponent<Transform2D>().LocalY = -inputService.GamePadState.ThumbStricks.Left.Y * 10;
myscene.leftStickText.Text = "LeftStick: " + inputService.GamePadState.ThumbStricks.Left;
myscene.rightJoystick.FindComponent<Transform2D>().LocalX = inputService.GamePadState.ThumbStricks.Right.X * 10;
myscene.rightJoystick.FindComponent<Transform2D>().LocalY = -inputService.GamePadState.ThumbStricks.Right.Y * 10;
myscene.rightStickText.Text = "RightStick: " + inputService.GamePadState.ThumbStricks.Right;
beforeGamepadState = inputService.GamePadState;
}
}
/// <summary>
/// Updates the state of the camera.
/// </summary>
/// <param name="dt">Time since the last frame in seconds.</param>
/// <param name="keyboardInput">Input for this frame from the keyboard.</param>
/// <param name="oldMouseInput">Input from the previous frame from the mouse.</param>
/// <param name="mouseInput">Input for this frame from the mouse.</param>
/// <param name="gamePadInput">Input for this frame from the game pad.</param>
#if !WINDOWS
public void Update(float dt, KeyboardState keyboardInput, GamePadState gamePadInput)
{
yaw += gamePadInput.ThumbSticks.Right.X * -1.5f * dt;
pitch += gamePadInput.ThumbSticks.Right.Y * 1.5f * dt;
public static bool IsFiring(GamePadState state)
{
return(state.Buttons.RightShoulder == ButtonState.Pressed);
}
private void DrawState(ref GamePadState gamepadState)
{
var sendState = false;
// Left & Right Bumpers - Triggers
if (gamepadState.Buttons.LeftShoulder == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["LB"], new Vector2(100, 97));
}
if (gamepadState.Triggers.Left == 1)
{
sendState = true;
spriteBatch.Draw(Textures["LT"], new Vector2(160, 41));
}
if (gamepadState.Buttons.RightShoulder == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["RB"], new Vector2(514, 97));
}
if (gamepadState.Triggers.Right == 1)
{
sendState = true;
spriteBatch.Draw(Textures["RT"], new Vector2(535, 41));
}
// Key Buttons
if (gamepadState.Buttons.A == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["A"], new Vector2(547, 269));
}
if (gamepadState.Buttons.B == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["B"], new Vector2(606, 221));
}
if (gamepadState.Buttons.Y == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["Y"], new Vector2(553, 177));
}
if (gamepadState.Buttons.X == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["X"], new Vector2(497, 226));
}
// Sticks
if (gamepadState.Buttons.LeftStick == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["LeftStickClick"], new Vector2(119, 233));
}
if (gamepadState.Buttons.RightStick == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["LeftStickClick"], new Vector2(423, 335));
}
if (gamepadState.ThumbSticks.Left.X != 0 || gamepadState.ThumbSticks.Left.Y != 0)
{
sendState = true;
var xStart = 162;
var yStart = 270;
var point1 = new Vector2(xStart, yStart);
var point2 = GetStickDirection(ref gamepadState, xStart, yStart, true);
DrawLine(point1, point2);
}
if (gamepadState.ThumbSticks.Right.X != 0 || gamepadState.ThumbSticks.Right.Y != 0)
{
sendState = true;
var xStart = 467;
var yStart = 373;
var point1 = new Vector2(xStart, yStart);
var point2 = GetStickDirection(ref gamepadState, xStart, yStart, false);
DrawLine(point1, point2);
}
// D-Pad
if (gamepadState.DPad.Left == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["DPadLeft"], new Vector2(215, 336));
}
if (gamepadState.DPad.Down == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["DPadDown"], new Vector2(241, 369));
}
if (gamepadState.DPad.Right == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["DPadRight"], new Vector2(287, 340));
}
if (gamepadState.DPad.Up == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["DPadUp"], new Vector2(243, 315));
}
// Menus
if (gamepadState.Buttons.Start == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["Start"], new Vector2(428, 237));
}
if (gamepadState.Buttons.Back == ButtonState.Pressed)
{
sendState = true;
spriteBatch.Draw(Textures["Back"], new Vector2(279, 236));
}
if (sendState && SynchronousSocketClient.delayState.ElapsedMilliseconds > Program.config.ClientUpdateRate)
{
sendState = true;
SynchronousSocketClient.SendQueue.Enqueue(JsonConvert.SerializeObject(new
{
Buttons = gamepadState.Buttons,
Triggers = gamepadState.Triggers,
DPad = gamepadState.DPad,
leftstickX = gamepadState.ThumbSticks.Left.X,
leftstickY = gamepadState.ThumbSticks.Left.Y,
rightstickX = gamepadState.ThumbSticks.Right.X,
rightstickY = gamepadState.ThumbSticks.Right.Y
}));
SynchronousSocketClient.delayState.Restart();
}
}
