// Update is called once per frame
void Update()
{
Cursor.lockState = CursorLockMode.Locked;
Cursor.visible = false;
#region Update Controller State
prevState_p1 = state_p1;
state_p1 = GamePad.GetState(pad_PlayerOne);
#endregion
if( Input.GetKeyDown(KeyCode.Space) ||
Input.GetKeyDown(KeyCode.Escape) ||
state_p1.Buttons.A == ButtonState.Pressed ||
state_p1.Buttons.Start == ButtonState.Pressed ||
state_p1.Buttons.Back == ButtonState.Pressed)
{
f_LevelTimer = f_LevelTimer_Max + 1f;
}
UpdateLerpTimer();
// Lerp from the previous graphic's alpha value to its new alpha
if(go_Graphic != null)
{
Color clr_Curr = go_Graphic.GetComponent<Image>().color;
clr_Curr.a = f_LerpPerc;
go_Graphic.GetComponent<Image>().color = clr_Curr;
}
}
// Update is called once per frame
void Update()
{
currentState = GamePad.GetState(pIndex);
if(currentState.ThumbSticks.Right.X < 0)
{
pTran.Translate(Vector3.left*Time.deltaTime*9, Space.World);
//pTran.rotation = Quaternion.Lerp(pTran.rotation, rotLeft, Time.deltaTime*50);
}
else if(currentState.ThumbSticks.Right.X > 0)
{
pTran.Translate(Vector3.right*Time.deltaTime*9, Space.World);
//pTran.rotation = Quaternion.Lerp(pTran.rotation, rotRight, Time.deltaTime*50);
}
if(currentState.ThumbSticks.Right.Y < 0)
{
pTran.Translate(Vector3.down*Time.deltaTime*9, Space.World);
//pTran.rotation = Quaternion.Lerp(pTran.rotation, rotLeft, Time.deltaTime*50);
}
else if(currentState.ThumbSticks.Right.Y > 0)
{
pTran.Translate(Vector3.up*Time.deltaTime*9, Space.World);
//pTran.rotation = Quaternion.Lerp(pTran.rotation, rotRight, Time.deltaTime*50);
}
}
// Update is called once per frame
protected virtual void Update()
{
// if we haven't gotten the correct player number yet
if (!gotNumber)
{
playerIndex = (PlayerIndex)GetComponentInParent<PlayerController>().playerNumber;
gotNumber = true;
}
prevState = state;
state = GamePad.GetState(playerIndex);
// short out if input's disabled
if (!inputEnabled)
return;
// if the right bumper is being pressed
if (prevState.Buttons.RightShoulder == ButtonState.Released && state.Buttons.RightShoulder == ButtonState.Pressed)
{
// and we have enough resources
if (plCont.currCharge >= reqCharge)
{
// do whatever our special is
Fire();
}
}
}
public override SF4InputState Convert()
{
SF4InputState outputState = new SF4InputState();
gamePadState = GamePad.GetState(playerIndex);
//Options
outputState.Options.Back = gamePadState.Buttons.Back == ButtonState.Pressed;
outputState.Options.Start = gamePadState.Buttons.Start == ButtonState.Pressed;
//Punches
outputState.Punches.Light = gamePadState.Buttons.X == ButtonState.Pressed;
outputState.Punches.Medium = gamePadState.Buttons.Y == ButtonState.Pressed;
outputState.Punches.Hard = gamePadState.Buttons.RightShoulder == ButtonState.Pressed;
//Kicks
outputState.Kicks.Light = gamePadState.Buttons.A == ButtonState.Pressed;
outputState.Kicks.Medium = gamePadState.Buttons.B == ButtonState.Pressed;
outputState.Kicks.Hard = gamePadState.Triggers.Right > 0.25f;
//Determine if Dpad has any input
outputState.Directions.Right = (gamePadState.DPad.Right == ButtonState.Pressed || gamePadState.ThumbSticks.Left.X > 0.25f);
outputState.Directions.Left = (gamePadState.DPad.Left == ButtonState.Pressed || -gamePadState.ThumbSticks.Left.X > 0.25f);
outputState.Directions.Up = (gamePadState.DPad.Up == ButtonState.Pressed || gamePadState.ThumbSticks.Left.Y > 0.25f);
outputState.Directions.Down = (gamePadState.DPad.Down == ButtonState.Pressed || -gamePadState.ThumbSticks.Left.Y > 0.25f);
return outputState;
}
void FixedUpdate()
{
state = GamePad.GetState(playerIndexNum);
Vector3 pos = poi.position;
if(state.Buttons.Y == ButtonState.Pressed)
pos -= poi.forward * -distance;
else
pos -= poi.forward * distance;
pos += poi.up * height;
Vector3 rot = poi.localEulerAngles;
Vector3 pos2 = (1 - u) * transform.position + u * pos;
//Vector3 rot2 = (1 - v) * transform.localEulerAngles + v * rot;
//rot2.y = poi.transform.localEulerAngles.y;
if (shake) {
pos2.x += Random.value * shakeIntensity * Random .Range(-1, 1);
pos2.y += Random.value * shakeIntensity * Random .Range(-1, 1);
pos2.z += Random.value * shakeIntensity * Random .Range(-1, 1);
}
transform.position = pos2;
transform.rotation = Quaternion.Slerp(camTarget.rotation, transform.rotation, 2f * Time.fixedDeltaTime);
//transform.localEulerAngles = rot2;
}
private void CheckGamePad()
{
if (!playerIndexSet && !prevState.IsConnected)
{
for (int i = 0; i < 4; ++i)
{
PlayerIndex testPlayerIndex = (PlayerIndex)i;
GamePadState testState = GamePad.GetState(testPlayerIndex, GamePadDeadZone.None);
if (testState.IsConnected)
{
Debug.Log(string.Format("GamePad found {0}", testPlayerIndex));
playerIndex = testPlayerIndex;
playerIndexSet = true;
// Set vibration according to triggers
GamePad.SetVibration(playerIndex, state.Triggers.Left, state.Triggers.Right);
}
}
}
prevState = state;
state = GamePad.GetState(playerIndex);
}
// TODO: Maybe reduce it to only the inputs actually used in the game?
private void MapPlayerInput(InputMapper inputMapper, GamePadState state, GamePadState previousState)
{
foreach (int axisInt in InputMapperAsset.GetMappedXboxAxis())
{
MapXboxAxis(axisInt, inputMapper, state);
}
foreach (int buttonInt in InputMapperAsset.GetMappedXboxButtons())
{
MapXboxButton(buttonInt, inputMapper, state, previousState);
}
// TODO: Put the following code into another class, so we can have 2 distinct XboxManager and KeyboardManager classes
// We map only the keyboard keys that are going to be used in the game
foreach (int key in InputMapperAsset.GetMappedKeyboardKeys())
{
inputMapper.SetRawButtonState(100 + key, Input.GetKey((KeyCode)key), Input.GetKey((KeyCode)key) && !Input.GetKeyDown((KeyCode)key));
}
foreach (int key in InputMapperAsset.GetMappedKeyboardKeysAxis())
{
float value = Input.GetKey((KeyCode)key) ? 1f : 0f;
inputMapper.SetRawAxisValue(100 + key, value);
}
}
// constructor
public PlayerRumble(int index)
{
switch (index)
{
case 1:
this.index = PlayerIndex.One;
break;
case 2:
this.index = PlayerIndex.Two;
break;
case 3:
this.index = PlayerIndex.Three;
break;
case 4:
this.index = PlayerIndex.Four;
break;
default:
Debug.Log(string.Format("ERROR! {0}'s gamepad index has not been assigned!", index));
this.index = PlayerIndex.One;
break;
}
this.state = GamePad.GetState(this.index);
this.prevState = GamePad.GetState(this.index);
if (this.state.IsConnected)
{
Debug.Log(string.Format("GamePad found P{0}", (int)this.index));
LoggingManager.AddText(this + " was added.");
this.StartRumbleCountdown();
}
}
// Update is called once per frame
void Update()
{
prevState = state;
state = GamePad.GetState(playerIndex);
if (bEnabled)
{
if (Cooldown <= 0)
{
if (state.IsConnected)
{
//print(state.IsConnected);
// Get the state //
state = GamePad.GetState(playerIndex);
// Check Player 1's controller for input //
CheckControllers();
}
}
else
{
Cooldown -= 0.1f;
}
CheckControllers();
}
}
// Update is called once per frame
void Update () {
#region Update Controller State
// update controller state
prevState = state;
state = GamePad.GetState(playerIndex);
// Find a PlayerIndex, for a single player game
// Will find the first controller that is connected ans use it
if (!playerIndexSet || !prevState.IsConnected)
{
for (int i = 0; i < 4; ++i)
{
PlayerIndex testPlayerIndex = (PlayerIndex)i;
GamePadState testState = GamePad.GetState(testPlayerIndex);
if (testState.IsConnected)
{
//Debug.Log(string.Format("GamePad found {0}", testPlayerIndex));
playerIndex = testPlayerIndex;
playerIndexSet = true;
}
}
}
#endregion
// OVR RESET
if (state.Buttons.Back == ButtonState.Pressed)
{
OVRManager.display.RecenterPose(); // OVR Reset function for 0.4.3
}
}
bool StateChanged (GamePadState s1, GamePadState s2)
{
bool changed = false;
changed |= s1.Buttons.A != s2.Buttons.A;
changed |= s1.Buttons.B != s2.Buttons.B;
changed |= s1.Buttons.X != s2.Buttons.X;
changed |= s1.Buttons.Y != s2.Buttons.Y;
changed |= s1.Buttons.Start != s2.Buttons.Start;
changed |= s1.Buttons.Back != s2.Buttons.Back;
changed |= s1.Buttons.LeftShoulder != s2.Buttons.LeftShoulder;
changed |= s1.Buttons.RightShoulder != s2.Buttons.RightShoulder;
changed |= s1.Buttons.LeftStick != s2.Buttons.LeftStick;
changed |= s1.Buttons.RightStick != s2.Buttons.RightStick;
changed |= s1.DPad.Up != s2.DPad.Up;
changed |= s1.DPad.Down != s2.DPad.Down;
changed |= s1.DPad.Left != s2.DPad.Left;
changed |= s1.DPad.Right != s2.DPad.Right;
changed |= Mathf.Abs (s1.Triggers.Left - s2.Triggers.Left) / Time.deltaTime > thresholdVelocity;
changed |= Mathf.Abs (s1.Triggers.Right - s2.Triggers.Right) / Time.deltaTime > thresholdVelocity;
changed |= Mathf.Abs (s1.ThumbSticks.Left.X - s2.ThumbSticks.Left.X) / Time.deltaTime > thresholdVelocity;
changed |= Mathf.Abs (s1.ThumbSticks.Left.Y - s2.ThumbSticks.Left.Y) / Time.deltaTime > thresholdVelocity;
changed |= Mathf.Abs (s1.ThumbSticks.Right.X - s2.ThumbSticks.Right.X) / Time.deltaTime > thresholdVelocity;
changed |= Mathf.Abs (s1.ThumbSticks.Right.Y - s2.ThumbSticks.Right.Y) / Time.deltaTime > thresholdVelocity;
return changed;
}
// Update is called once per frame
void Update()
{
prevState = state;
state = GamePad.GetState(playerIndex);
if (InputEnabled) {
// axis crontrols for horizontal movement
if (Mathf.Abs(state.ThumbSticks.Left.X) > .5f || Mathf.Abs(state.ThumbSticks.Left.Y) > .5f){
CurrentRot = Quaternion.Euler(new Vector3(0 ,0 ,Mathf.Atan2(-state.ThumbSticks.Left.X, state.ThumbSticks.Left.Y)* Mathf.Rad2Deg));
StickPosSnap.x = state.ThumbSticks.Left.X;
StickPosSnap.y = state.ThumbSticks.Left.Y;
}
transform.rotation = CurrentRot;
// player thrust control
if (state.Triggers.Right > .05f){
RB.AddForce(new Vector2(StickPosSnap.x * Speed * state.Triggers.Right, StickPosSnap.y * Speed * state.Triggers.Right));
if (ThrusterSprite.activeSelf == false){
ThrusterSprite.SetActive(true);
}
}else {
if (ThrusterSprite.activeSelf == true){
ThrusterSprite.SetActive(false);
}
}
// menu control
if (state.Buttons.Start == ButtonState.Pressed && prevState.Buttons.Start == ButtonState.Released && Time.timeScale == 1) {
//InputEnabled = false;
//Time.timeScale = 0;
}
}
}
override protected void Update()
{
GPState = GamePad.GetState(PlayerIndex.One);
m_TargetVelocity = (Vector3.forward * GPState.ThumbSticks.Left.Y +
Vector3.right * GPState.ThumbSticks.Left.X).normalized * Time.deltaTime;
m_TargetVelocity = m_SpeedIsCapped ? m_TargetVelocity * m_ReducedSpeed : m_TargetVelocity * m_Speed;
m_Velocity = Vector3.Lerp(m_Velocity, m_TargetVelocity, m_DampingFactor);
BoundZVelocity();
if (m_Velocity != Vector3.zero)
{
m_Animator.SetBool("Walking", true);
m_Animator.SetFloat("WalkingMultiplier", m_SpeedIsCapped ? m_ReducedSpeed / m_Speed : 1f);
}
else
{
m_Animator.SetBool("Walking", false);
}
UpdatePose();
float X = m_Velocity.x;
float Y = m_Velocity.z;
float deltaAngle = (X / m_DistanceToCenter) * Mathf.Rad2Deg;
m_Angle += deltaAngle;
m_DistanceToCenter -= Y;
BoundDistanceToCenter();
base.Update();
}
public static InputDirection.Direction GetDirection(XBOX_DIRECTION direction, GamePadState pad)
{
InputDirection.Direction d = new InputDirection.Direction(0, 0);
if (!pad.IsConnected)
{
return d;
}
switch (direction)
{
case XBOX_DIRECTION.Pad:
if (pad.DPad.Down == ButtonState.Pressed)
d.y--;
if (pad.DPad.Up == ButtonState.Pressed)
d.y++;
if (pad.DPad.Right == ButtonState.Pressed)
d.x++;
if (pad.DPad.Left == ButtonState.Pressed)
d.x--;
break;
case XBOX_DIRECTION.StickLeft:
d.x = pad.ThumbSticks.Left.X;
d.y = pad.ThumbSticks.Left.Y;
break;
case XBOX_DIRECTION.StickRight:
d.x = pad.ThumbSticks.Right.X;
d.y = pad.ThumbSticks.Right.Y;
break;
}
return d;
}
// Update is called once per frame
void Update ()
{
Timer += Time.deltaTime;
if (Timer >= SwapTime && CanTimer)
{
Timer = 0;
NextCanvas += 1;
ChangeSlide(NextCanvas);
}
prevState = state;
state = GamePad.GetState(playerIndex);
if (Cooldown <= 0 && prevState.IsConnected)
{
state = GamePad.GetState(playerIndex);
CheckControllers();
}
else
{
Cooldown -= Time.deltaTime;
}
}
public override void Update ()
{
prevState = state;
state = GamePad.GetState ((PlayerIndex)deviceId);
if( StateChanged(prevState,state))
lastInputTime = Time.time;
}
// Use this for initialization
void Start()
{
game_started = false;
state = GamePad.GetState(playerIndex);
prevState = state;
SoundManager.instance.PlayMusic("Hidden Agenda");
SoundManager.instance.PlaySingle ("Georoomintro");
}
// Update is called once per frame
void Update()
{
gamepadState = GamePad.GetState (PlayerIndex.One/*playerIndex*/);
aileron = gamepadState.ThumbSticks.Right.X;
elevator = gamepadState.ThumbSticks.Right.Y;
rudder = gamepadState.ThumbSticks.Left.X;
throttle = gamepadState.ThumbSticks.Left.Y;
//print ("Joystick: " + aileron + " " + elevator + " " + rudder+" "+throttle);
}
// Update is called once per frame
void Update()
{
if (!FindController())
{
return;
}
prevState = state;
state = GamePad.GetState(playerIndex);
}
// Update is called once per frame
void Update()
{
prevState = state;
state = GamePad.GetState(playerIndex);
if (state.Buttons.A == ButtonState.Pressed && prevState.Buttons.A == ButtonState.Released)
{
if (character.TriggerAction("Down"))
god.ProcessPlayerInput(playerIndex, ActionName.Down);
return;
}
if (state.Buttons.B == ButtonState.Pressed && prevState.Buttons.B == ButtonState.Released)
{
if (character.TriggerAction("Right"))
god.ProcessPlayerInput(playerIndex, ActionName.Right);
return;
}
if (state.Buttons.X == ButtonState.Pressed && prevState.Buttons.X == ButtonState.Released)
{
if (character.TriggerAction("Left"))
god.ProcessPlayerInput(playerIndex, ActionName.Left);
return;
}
if (state.Buttons.Y == ButtonState.Pressed && prevState.Buttons.Y == ButtonState.Released)
{
if (character.TriggerAction("Up"))
god.ProcessPlayerInput(playerIndex, ActionName.Up);
return;
}
if (state.Triggers.Left > 0.8 || state.Triggers.Right > 0.8)
{
character.Stab();
return;
}
if (!character.isInAnimation())
{
// read inputs
float h = state.ThumbSticks.Left.X;
float v = state.ThumbSticks.Left.Y;
// calculate camera relative direction to move:
var m_CamForward = Vector3.Scale(m_Cam.up, new Vector3(1, 0, 1)).normalized;
var m_Move = speed * inversion * v * m_CamForward + speed * inversion * h * m_Cam.right;
// pass all parameters to the character control script
character.Move(m_Move, true);
character.GetComponent<Rigidbody>().velocity = m_Move;
}
}
void FixedUpdate()
{
if (movementEnabled) {
movement = Vector3.zero;
if((moveTester != transform.position)&& (isMoveTesterAssigned)){
animation.CrossFade ("walk");
}
else{
animation.Play("idle", PlayMode.StopAll);
}
state = GamePad.GetState(playerNumber);
movement.x = state.ThumbSticks.Left.X;
movement.z = state.ThumbSticks.Left.Y;
transform.position += movement * Time.deltaTime * playerSpeed;
moveTester = transform.position;
isMoveTesterAssigned = true;
targetDir = Mathf.Atan(state.ThumbSticks.Left.Y / state.ThumbSticks.Left.X);
targetDir *= Mathf.Rad2Deg;
//Determine quadrant
if (state.ThumbSticks.Left.Y >= 0 && state.ThumbSticks.Left.X >= 0)
quadrant = 1;
else if (state.ThumbSticks.Left.Y >= 0 && state.ThumbSticks.Left.X < 0)
quadrant = 2;
else if (state.ThumbSticks.Left.Y < 0 && state.ThumbSticks.Left.X < 0)
quadrant = 3;
else if (state.ThumbSticks.Left.Y < 0 && state.ThumbSticks.Left.X >= 0)
quadrant = 4;
//Convert to 0-360 degrees
switch (quadrant) {
case 2:
targetDir += 180;
break;
case 3:
targetDir += 180;
break;
case 4:
targetDir += 360;
break;
default:
break;
}
currentDir = transform.eulerAngles;
currentDir.x = 0;
currentDir.y = -targetDir+90;
currentDir.z = 0;
if (!float.IsNaN(currentDir.y))
transform.eulerAngles = currentDir;
}
}
// Update is called once per frame
void Update()
{
gamePadState = GamePad.GetState(playerIndex);
Respawn();
isHoldingJump = gamePadState.Buttons.A == ButtonState.Pressed;
Movement();
unShock();
playerOrb.Use(gamePadState);
playerVote.CallVote(gamePadState);
}
public void CallVote(GamePadState state)
{
if (votesLeft > 0)
{
if (state.Buttons.B == ButtonState.Pressed)
{
FindObjectOfType<Vote>().voteNow();
votesLeft--;
}
}
}
void Update()
{
state = GamePad.GetState(PlayerIndex.One);
if (state.Triggers.Right > 0.2f && state.Triggers.Left > 0.2f) // move downwards
transform.Translate(Vector3.down * speed * state.Triggers.Right * Time.deltaTime);
else if (state.Triggers.Right > 0.2f) // move right
transform.Translate(Vector3.right * speed * state.Triggers.Right * Time.deltaTime);
else if (state.Triggers.Left > 0.2f) // move left
transform.Translate(Vector3.left * speed * state.Triggers.Left * Time.deltaTime);
}
private static float InputGetAxisState(ref GamePadState state, GmpdAxis gAxis) {
switch (gAxis) {
case (GmpdAxis.LStickX): return state.ThumbSticks.Left.X; break;
case (GmpdAxis.LStickY): return state.ThumbSticks.Left.Y; break;
case (GmpdAxis.RStickX): return state.ThumbSticks.Right.X; break;
case (GmpdAxis.RStickY): return state.ThumbSticks.Right.Y; break;
case (GmpdAxis.LTrigger): return state.Triggers.Left; break;
case (GmpdAxis.RTrigger): return state.Triggers.Right; break;
}
return 0;
}
private void UpdateAxisStates(ref InputForm inptForm, GamePadState gmpdState, GmpdAxis[] axsCodes) {
inptForm.m_axis = new float[axsCodes.Length];
// Get axises
for (int j = 0; j < axsCodes.Length; j++) {
if(IsDPad(axsCodes[j])) {
inptForm.m_axis[j] = InputGetDPadAxisState(gmpdState.DPad, axsCodes[j]);
} else {
inptForm.m_axis[j] = InputGetAxisState(ref gmpdState, axsCodes[j]);
}
}
}
public static bool ActionReleased(int playerIndex, GamePadState prevState, GamePadState state)
{
//if player index is divisible by 2 I'm left hand side of the controller
if (playerIndex % 2 == 0)
{
//if button has been pressed return true else false
return (prevState.Buttons.LeftShoulder == ButtonState.Pressed && state.Buttons.LeftShoulder == ButtonState.Released);
}
else
{
return (prevState.Buttons.RightShoulder == ButtonState.Pressed && state.Buttons.RightShoulder == ButtonState.Released);
}
}
public void Use(GamePadState gamePadState)
{
if (gamePadState.Buttons.X == ButtonState.Pressed)
{
if (useableObject != null)
{
if (useableObject.Use(this))
{
useableObject = null;
}
}
}
}
private void UpdateButtonStates(ref InputForm inptForm, GamePadState gmpdState, GmpdButton[] bttnCodes) {
// Get buttons
for (int i = 0; i < bttnCodes.Length; i++) {
if (IsDPad(bttnCodes[i])) {
if (InputGetDPadButtonState(gmpdState.DPad, bttnCodes[i]))
inptForm.m_button |= (GenericButtonID)((int)1 << i);
} else {
if (InputGetButtonState(gmpdState.Buttons, bttnCodes[i]))
inptForm.m_button |= (GenericButtonID)((int)1 << i);
}
}
}
/// <summary>
/// Process every command that is not movement
/// </summary>
/// <param name="state">GamePadState</param>
protected void processActions(GamePadState state)
{
if (state.Buttons.A == ButtonState.Pressed)
OnTakeoff();
if (state.Buttons.A == ButtonState.Pressed)
OnLand();
if (state.Buttons.B == ButtonState.Pressed)
OnEmergency();
if (state.Buttons.Y == ButtonState.Pressed)
OnFlatTrim();
}
// Update is called once per frame
void Update()
{
XInputDotNetPure.GamePadState pad1 = GamePad.GetState(PlayerIndex.One);
XInputDotNetPure.GamePadState pad2 = GamePad.GetState(PlayerIndex.Two);
XInputDotNetPure.GamePadState pad3 = GamePad.GetState(PlayerIndex.Three);
XInputDotNetPure.GamePadState pad4 = GamePad.GetState(PlayerIndex.Four);
// スタートが押されたら遷移
if ((pad1.Buttons.Start == ButtonState.Pressed) ||
(pad2.Buttons.Start == ButtonState.Pressed) ||
(pad3.Buttons.Start == ButtonState.Pressed) ||
(pad4.Buttons.Start == ButtonState.Pressed) ||
(Input.GetKeyDown(KeyCode.A)))
{
Fade.ChangeScene("Title");
}
}
/// <summary>
/// キーの入力待ち状態
/// </summary>
private void _WaitKey()
{
XInputDotNetPure.GamePadState pad1 = GamePad.GetState(PlayerIndex.One);
XInputDotNetPure.GamePadState pad2 = GamePad.GetState(PlayerIndex.Two);
XInputDotNetPure.GamePadState pad3 = GamePad.GetState(PlayerIndex.Three);
XInputDotNetPure.GamePadState pad4 = GamePad.GetState(PlayerIndex.Four);
m_intervalTime += Time.deltaTime;
if (Input.GetKeyDown(KeyCode.A))
{
Fade.ChangeScene("Ending");
}
if ((pad1.Buttons.Start == ButtonState.Pressed) ||
(pad2.Buttons.Start == ButtonState.Pressed) ||
(pad3.Buttons.Start == ButtonState.Pressed) ||
(pad4.Buttons.Start == ButtonState.Pressed) ||
(m_intervalTime >= 3.0f))
{
Fade.ChangeScene("Ending");
}
}
// Update is called once per frame
void Update()
{
XInputDotNetPure.GamePadState pad1 = GamePad.GetState(PlayerIndex.One);
XInputDotNetPure.GamePadState pad2 = GamePad.GetState(PlayerIndex.Two);
XInputDotNetPure.GamePadState pad3 = GamePad.GetState(PlayerIndex.Three);
XInputDotNetPure.GamePadState pad4 = GamePad.GetState(PlayerIndex.Four);
// 時間経過開始
if (!flg)
{
m_timeCountScript.StartTime();
flg = true;
}
// スタートが押されたか
//if (MultiInput.GetButtonDown("Pause", MultiInput.JoypadNumber.Pad1) || Input.GetKeyDown(KeyCode.Z))
if ((pad1.Buttons.Start == ButtonState.Pressed) || Input.GetKeyDown(KeyCode.Z))
{
GameObject.Find("Ready1").GetComponent <Ready>().DispReady();
m_readyFlag[0] = true;
if (!se026_startFlag[0])
{
BGMManager.instance.PlaySE("se026_PlayerPrepareFinish");
se026_startFlag[0] = true;
}
}
if ((pad2.Buttons.Start == ButtonState.Pressed) || Input.GetKeyDown(KeyCode.X))
{
GameObject.Find("Ready2").GetComponent <Ready>().DispReady();
m_readyFlag[1] = true;
if (!se026_startFlag[1])
{
BGMManager.instance.PlaySE("se026_PlayerPrepareFinish");
se026_startFlag[1] = true;
}
}
if ((pad3.Buttons.Start == ButtonState.Pressed) || Input.GetKeyDown(KeyCode.C))
{
GameObject.Find("Ready3").GetComponent <Ready>().DispReady();
m_readyFlag[2] = true;
if (!se026_startFlag[2])
{
BGMManager.instance.PlaySE("se026_PlayerPrepareFinish");
se026_startFlag[2] = true;
}
}
if ((pad4.Buttons.Start == ButtonState.Pressed) || Input.GetKeyDown(KeyCode.V))
{
GameObject.Find("Ready4").GetComponent <Ready>().DispReady();
m_readyFlag[3] = true;
if (!se026_startFlag[3])
{
BGMManager.instance.PlaySE("se026_PlayerPrepareFinish");
se026_startFlag[3] = true;
}
}
// 全員レディしたら もしくは 残り時間が0になったら
if ((m_readyFlag[0] && m_readyFlag[1] && m_readyFlag[2] && m_readyFlag[3]) || (m_timeCountScript.GetTime() <= 0.0f))
{
Fade.ChangeScene("Play");
}
}
// Update is called once per frame
void Update()
{
XInputDotNetPure.GamePadState pad1 = GamePad.GetState(PlayerIndex.One);
XInputDotNetPure.GamePadState pad2 = GamePad.GetState(PlayerIndex.Two);
XInputDotNetPure.GamePadState pad3 = GamePad.GetState(PlayerIndex.Three);
XInputDotNetPure.GamePadState pad4 = GamePad.GetState(PlayerIndex.Four);
switch (m_titlestate)
{
case TitleState.Start: //タイトル開始時
m_titlestate = TitleState.Ribbon;
BGMManager.instance.StopBGM(0.0f);
break;
case TitleState.Ribbon: //リボンを投げる
m_ribbon.ThrowRibbon();
// 投げるSE鳴らすse001_ThrowJustRibbon
if (!se001_startFlag)
{
BGMManager.instance.PlaySE("se001_ThrowJustRibbon");
se001_startFlag = true;
}
if (m_ribbon.ThrowFinishFlag) //リボンが所定の位置に着いたら遷移を移動させる
{
m_ribbon.ResetBezierRibbon();
m_titlePlayerAnimator.SetBool("Running", true);
m_girl.RotationGirl();
m_titlestate = TitleState.TrailTitleLogo;
}
break;
case TitleState.TrailTitleLogo: //リボンを引きずる・女性を移動させる・タイトルロゴを引きずる
//所定の位置に着いたら遷移を移動させる
if (m_ribbon.TrailFinishFlag && m_titlelogo.TrailtitleLogoFinishFlag)
{
//m_invisibleribbon.ActiveRibbon(false);
m_ribbon.gameObject.SetActive(false);
m_titlestate = TitleState.BoundTitleLogo;
}
else
{
m_ribbon.TrailRibbon();
m_girl.TrailGirl();
m_titlelogo.TrailTitleLogo();
}
break;
case TitleState.BoundTitleLogo: //ロゴをバウンドさせる
m_titlelogo.BoundTitleLogo();
if (m_titlelogo.TitleLogoBoundFinishFlag &&
m_titlelogo.TitleLogoTime() >= 5.0f) //入力で次の遷移に
{
m_titleui.Activate(true);
m_titlestate = TitleState.DisplaytitleLogo;
}
break;
case TitleState.DisplaytitleLogo: //UIを表示。
m_titleui.ScaleTitleUI();
// BGM鳴らす
if (!bgm000_startFlag)
{
BGMManager.instance.PlayBGM("bgm000_Title", 0.1f);
bgm000_startFlag = true;
}
if (Input.GetKeyDown(KeyCode.A) ||
(pad1.Buttons.Start == ButtonState.Pressed) ||
(pad2.Buttons.Start == ButtonState.Pressed) ||
(pad3.Buttons.Start == ButtonState.Pressed) ||
(pad1.Buttons.Start == ButtonState.Pressed)) //入力で次の遷移に。
{
m_titlestate = TitleState.Finish;
m_titleui.Activate(false);
Fade.ChangeScene("Opening");
BGMManager.instance.StopBGM(0.8f);
// 遷移SE鳴らす
if (!se017_startFlag)
{
BGMManager.instance.PlaySE("se017_DecideButton");
se017_startFlag = true;
}
}
break;
case TitleState.Finish: //終了。ここで他の遷移に移動する
Debug.Log("終了");
// BGMManager.instance.StopBGM(0.0f);
// SceneManager.LoadScene("Select");
break;
}
}
public void Update()
{
old_ = new_;
new_ = GamePad.GetState(playerIndex_, deadZone_);
}
public void XInputGamePadInputRoll()
{
var State = XInputDotNetPure.GamePad.GetState(PlayerIndex.One);
foreach (PropertyInfo buttonProperty in AvailableXButtonProperties)
{
XInputDotNetPure.ButtonState CurrentButtonState = (XInputDotNetPure.ButtonState)buttonProperty.GetValue(State.Buttons);
XInputDotNetPure.ButtonState OldButtonState = (XInputDotNetPure.ButtonState)buttonProperty.GetValue(State.Buttons);
if (!Object.ReferenceEquals(XOldState, null))
{
OldButtonState = (XInputDotNetPure.ButtonState)buttonProperty.GetValue(XOldState.Buttons);
}
if (CurrentButtonState == XInputDotNetPure.ButtonState.Pressed &&
(Object.ReferenceEquals(XOldState, null) || OldButtonState == XInputDotNetPure.ButtonState.Released))
{
CallButtonMapping(buttonProperty.Name, true);
System.Diagnostics.Debug.WriteLine($"{buttonProperty.Name} Pressed");
}
if (CurrentButtonState == XInputDotNetPure.ButtonState.Released &&
(!Object.ReferenceEquals(XOldState, null) && OldButtonState == XInputDotNetPure.ButtonState.Pressed))
{
CallButtonMapping(buttonProperty.Name, false);
System.Diagnostics.Debug.WriteLine($"{buttonProperty.Name} Released");
}
}
PropertyInfo[] AvailableXTriggerProperties = typeof(XInputDotNetPure.GamePadTriggers).GetProperties().ToArray();
foreach (PropertyInfo buttonProperty in AvailableXTriggerProperties)
{
float CurrentTriggerState = (float)buttonProperty.GetValue(State.Triggers);
float OldTriggerState = (float)buttonProperty.GetValue(State.Triggers);
if (!Object.ReferenceEquals(XOldState, null))
{
OldTriggerState = (float)buttonProperty.GetValue(XOldState.Triggers);
}
if (CurrentTriggerState == 1 &&
(Object.ReferenceEquals(XOldState, null) || OldTriggerState == 0))
{
CallButtonMapping(buttonProperty.Name, true);
System.Diagnostics.Debug.WriteLine($"{buttonProperty.Name} Trigger Pressed");
}
if (CurrentTriggerState == 0 &&
(!Object.ReferenceEquals(XOldState, null) && OldTriggerState == 1))
{
CallButtonMapping(buttonProperty.Name, false);
System.Diagnostics.Debug.WriteLine($"{buttonProperty.Name} Trigger Released");
}
}
var oldUp = Convert.ToBoolean(XOldState.DPad.Up);
var oldDown = Convert.ToBoolean(XOldState.DPad.Down);
var oldLeft = Convert.ToBoolean(XOldState.DPad.Left);
var oldRight = Convert.ToBoolean(XOldState.DPad.Right);
var newUp = Convert.ToBoolean(State.DPad.Up);
var newDown = Convert.ToBoolean(State.DPad.Down);
var newLeft = Convert.ToBoolean(State.DPad.Left);
var newRight = Convert.ToBoolean(State.DPad.Right);
var oldLeftX = Math.Round(XOldState.ThumbSticks.Left.X);
var oldLeftY = Math.Round(XOldState.ThumbSticks.Left.Y);
var newLeftX = Math.Round(State.ThumbSticks.Left.X);
var newLeftY = Math.Round(State.ThumbSticks.Left.Y);
if (oldLeftX == 0 && newLeftX == 1 || oldRight == true && newRight == false)
{
System.Diagnostics.Debug.WriteLine("Right Pushed");
CallButtonMapping("IsRight", true);
}
if (oldLeftX == 1 && newLeftX == 0 || oldRight == false && newRight == true)
{
System.Diagnostics.Debug.WriteLine("Right Released");
CallButtonMapping("IsRight", false);
}
if (oldLeftX == 0 && newLeftX == -1 || oldLeft == true && newLeft == false)
{
System.Diagnostics.Debug.WriteLine("Left Pushed");
CallButtonMapping("IsLeft", true);
}
if (oldLeftX == -1 && newLeftX == 0 || oldLeft == false && newLeft == true)
{
System.Diagnostics.Debug.WriteLine("Left Released");
CallButtonMapping("IsLeft", false);
}
if (oldLeftY == 0 && newLeftY == 1 || oldUp == true && newUp == false)
{
System.Diagnostics.Debug.WriteLine("Up Pushed");
CallButtonMapping("IsUp", true);
}
if (oldLeftY == 1 && newLeftY == 0 || oldUp == false && newUp == true)
{
System.Diagnostics.Debug.WriteLine("Up Released");
CallButtonMapping("IsUp", false);
}
if (oldLeftY == 0 && newLeftY == -1 || oldDown == true && newDown == false)
{
System.Diagnostics.Debug.WriteLine("Down Pushed");
CallButtonMapping("IsDown", true);
}
if (oldLeftY == -1 && newLeftY == 0 || oldDown == false && newDown == true)
{
System.Diagnostics.Debug.WriteLine("Down Released");
CallButtonMapping("IsDown", false);
}
XOldState = State;
}
// Update is called once per frame
void Update()
{
XInputDotNetPure.GamePadState pad1 = GamePad.GetState(PlayerIndex.One);
XInputDotNetPure.GamePadState pad2 = GamePad.GetState(PlayerIndex.Two);
XInputDotNetPure.GamePadState pad3 = GamePad.GetState(PlayerIndex.Three);
XInputDotNetPure.GamePadState pad4 = GamePad.GetState(PlayerIndex.Four);
// BGM鳴らす
if (!bgm004_startFlag)
{
//BGMManager.instance.PlayBGM("bgm004_GameSelect", 1.0f);
bgm004_startFlag = true;
}
/*
* for (int i = 0; i < ConstPlayerMax; i++)
* {
*
* if(MultiInput.GetButtonDown("Pause", m_joypadNumber[i]))
* {
* m_readyFlag[i] = true;
* readyText[i].text = "OK!";
* }
* }
*/
//if (Input.GetKeyDown(KeyCode.Z) || MultiInput.GetButtonDown("Pause",MultiInput.JoypadNumber.Pad1))
if ((pad1.Buttons.Start == ButtonState.Pressed) || Input.GetKeyDown(KeyCode.Z))
{
m_readyFlag[0] = true;
readyText[0].text = "OK!";
GameObject.Find("PlayerCharacter1").GetComponent <Animator>().SetBool("isGlad", true);
}
if ((pad2.Buttons.Start == ButtonState.Pressed) || Input.GetKeyDown(KeyCode.X))
{
m_readyFlag[1] = true;
readyText[1].text = "OK!";
GameObject.Find("PlayerCharacter2").GetComponent <Animator>().SetBool("isGlad", true);
}
if ((pad3.Buttons.Start == ButtonState.Pressed) || Input.GetKeyDown(KeyCode.C))
{
m_readyFlag[2] = true;
readyText[2].text = "OK!";
GameObject.Find("PlayerCharacter3").GetComponent <Animator>().SetBool("isGlad", true);
}
if ((pad4.Buttons.Start == ButtonState.Pressed) || Input.GetKeyDown(KeyCode.V))
{
m_readyFlag[3] = true;
readyText[3].text = "OK!";
GameObject.Find("PlayerCharacter4").GetComponent <Animator>().SetBool("isGlad", true);
}
// 全員分
for (int i = 0; i < ConstPlayerMax; i++)
{
// レディーが押されていたら
if (m_readyFlag[i])
{
// SE鳴らす
if (!se026_startFlag[i])
{
BGMManager.instance.PlaySE("se026_PlayerPrepareFinish");
se026_startFlag[i] = true;
}
// だんだん大きくする
readyText[i].transform.localScale += new Vector3(0.2f, 0.2f, 0.2f);
if (readyText[i].transform.localScale.x > 1.0f)
{
readyText[i].transform.localScale = new Vector3(1.0f, 1.0f, 1.0f);
}
}
}
// シーン遷移
if (m_readyFlag[0] && m_readyFlag[1] && m_readyFlag[2] && m_readyFlag[3])
{
// 文字を点滅させる
//GameObject.Find("InfoText").GetComponent<InfoText>().FlashText();
GameObject.Find("InfoText").GetComponent <FlashText>().DecideText();
// 時間経過
m_time += Time.deltaTime;
// 1秒たったら遷移
if (m_time > 1.0f)
{
BGMManager.instance.StopBGM(0.0f);
Fade.ChangeScene("Tutorial");
}
}
}
void _UpdateInputXInput()
{
XInputDotNetPure.GamePadState gamePadState = XInputDotNetPure.GamePad.GetState(m_playerIndex);
float horizontal = gamePadState.ThumbSticks.Left.X;
float vertical = gamePadState.ThumbSticks.Left.Y;
float horizontal2 = gamePadState.ThumbSticks.Right.X;
float vertical2 = gamePadState.ThumbSticks.Right.Y;
m_controlledPlayerCharacter.InputStick(horizontal, vertical);
bool isPushCancelKey = gamePadState.Buttons.LeftShoulder == ButtonState.Pressed;
bool isPushDashKey = gamePadState.Buttons.RightShoulder == ButtonState.Pressed;
m_controlledPlayerCharacter.InputDash(isPushDashKey);
bool isVertical2Down = m_prevFrameVertical2 - vertical2 > 0.0f;
//if(vertical2 <= 1.0f)
//{
//}
//GamePad.SetVibration(PlayerIndex.One, 0.0f, 0.0f);
if (vertical2 <= -0.0f && isVertical2Down)
{
m_controlledPlayerCharacter.InputCharge();
//GamePad.SetVibration(PlayerIndex.One, 1.0f, 1.0f);
}
else if (vertical2 >= 0.0f)
{
m_controlledPlayerCharacter.InputThrow();
}
m_controlledPlayerCharacter.InputCancel(isPushCancelKey);
m_prevFrameVertical2 = vertical2;
// pull
if (_CheckStickHalfRotation(horizontal2, vertical2, ref m_pullHalfRotationInputCheck))
{
m_pullHalfRotationCount++;
if (m_pullHalfRotationCount >= m_controllerData.pullHalfRotation)
{
m_pullHalfRotationCount = 0;
m_controlledPlayerCharacter.InputPull();
}
}
// breake
if (_CheckStickHalfRotation(horizontal, vertical, ref m_releaseHalfRotationInputCheck))
{
m_releaseHalfRotationInputCount++;
if (m_releaseHalfRotationInputCount >= m_controllerData.releaseHalfRotation)
{
m_releaseHalfRotationInputCount = 0;
m_releaseHalfRotationInputCount2 = 0;
//m_controlledPlayerCharacter.InputRelease();
m_controlledPlayerCharacter.InputRebound();
}
}
if (_CheckStickHalfRotation(horizontal2, vertical2, ref m_releaseHalfRotationInputCheck2))
{
m_releaseHalfRotationInputCount2++;
if (m_releaseHalfRotationInputCount2 >= m_controllerData.releaseHalfRotation)
{
m_releaseHalfRotationInputCount = 0;
m_releaseHalfRotationInputCount2 = 0;
//m_controlledPlayerCharacter.InputRelease();
m_controlledPlayerCharacter.InputRebound();
}
}
}
