public Analog(GamePadTrigger _trigger, double _threshold = 0.1, double _pressedthreshold = 0.5)
{
this._Trigger = _trigger;
this._Threshold = _threshold;
this._PressedThreshold = _pressedthreshold;
this._InputType = 1;
}
public GamePadTriggerInfo(GamePadController controller, GamePadTrigger trigger, float value, bool pressed, bool prevPressed)
{
this.controller = controller;
this.trigger = trigger;
this.value = value;
this.pressed = pressed;
this.prevPressed = prevPressed;
}
public static float GetTriggerPosition(int gamePadIndex, GamePadTrigger trigger, float deadZone = 0f)
{
if (deadZone < 0f || deadZone >= 1f)
{
throw new ArgumentOutOfRangeException("deadZone");
}
if (IsConnected(gamePadIndex))
{
return(ApplyDeadZone(m_states[gamePadIndex].Triggers[(int)trigger], deadZone));
}
return(0f);
}
/// <summary>
/// Creates a new GamePadTriggerBinding instance for the specified player's gamepad, bound to the specified trigger and with the provided minimum and maximum threshold values.
/// </summary>
/// <param name="player">Player whose gamepad will be bound.</param>
/// <param name="trigger">Trigger to bind.</param>
/// <param name="minimumThreshold">Minimum trigger value to match.</param>
/// <param name="maximumThreshold">Maximum trigger value to match.</param>
/// <remarks>Minimum and maximum threshold values must be in the range 0.0 .. 1.0, where increasing values indicate increasing pull on the trigger.</remarks>
/// <exception cref="System.ArgumentOutOfRangeException">Thrown if minimumThreshold is greater than maximumThreshold.</exception>
public GamePadTriggerMatcher(PlayerIndex player, GamePadTrigger trigger, float minimumThreshold, float maximumThreshold)
: base(player)
{
if (minimumThreshold > maximumThreshold)
{
throw new ArgumentOutOfRangeException("minimumThreshold");
}
Player = player;
Trigger = trigger;
MinimumThreshold = minimumThreshold;
MaximumThreshold = maximumThreshold;
}
public static float GetTrigger(this GamePadState gamePad, GamePadTrigger gamePadTrigger)
{
switch (gamePadTrigger)
{
case GamePadTrigger.Left:
return(gamePad.Triggers.Left);
case GamePadTrigger.Right:
return(gamePad.Triggers.Right);
default:
return(0.0f);
}
}
/// <summary>
/// Constructs an InputAction which tracks GamePad triggers.
/// </summary>
/// <param name="playerIndex">The index of the player using this input.</param>
/// <param name="buttonAction">What state the button should be in to activate.</param>
/// <param name="trigger">Which trigger to track.</param>
/// <param name="deadZoneType">The type of dead zone.</param>
/// <param name="deadZoneMin">The minimum Degree which will not be sensed.</param>
/// <param name="deadZoneMax">The maximum Degree which will not be sensed.</param>
public GamePadTriggerInputAction(
PlayerIndex playerIndex,
ButtonAction buttonAction,
GamePadTrigger trigger,
GamePadDeadZone deadZoneType,
float deadZoneMin,
float deadZoneMax)
: base(playerIndex, buttonAction)
{
mGamePadTrigger = trigger;
mGamePadDeadZone = deadZoneType;
mDeadZoneMax = deadZoneMax;
mDeadZoneMin = deadZoneMin;
}
public float GetPadTriggerPosition(GamePadTrigger trigger, float deadZone = 0f)
{
if (m_isCleared)
{
return(0f);
}
float num = 0f;
for (int i = 0; i < 4; i++)
{
if (((int)Devices & (8 << i)) != 0)
{
num += GamePad.GetTriggerPosition(i, trigger, deadZone);
}
}
return(MathUtils.Min(num, 1f));
}
public override float GetGamePadTrigger(GamePadTrigger trigger, GamePadController controller, bool rawValue)
{
if (controller == GamePadController.None || trigger == GamePadTrigger.None)
{
return(0f);
}
string triggerName = "";
int controllerIndex = (int)controller;
if (controller == GamePadController.Any)
{
controllerIndex = 0;
}
switch (trigger)
{
case GamePadTrigger.Left:
triggerName = "TriggersL_" + controllerIndex;
break;
case GamePadTrigger.Right:
triggerName = "TriggersR_" + controllerIndex;
break;
}
float triggerValue = 0f;
try
{
if (!rawValue)
{
triggerValue = UnityEngine.Input.GetAxis(triggerName);
}
else
{
triggerValue = UnityEngine.Input.GetAxisRaw(triggerName);
}
}
catch (System.Exception e)
{
Core.debug.Error(e.Message);
}
return(triggerValue);
}
public PlayerShip(Node parent, string name)
: base(parent, name)
{
Body.X = EntityGame.Viewport.Width / 2f;
Body.Y = EntityGame.Viewport.Height / 2f;
Physics.Drag = 0.97f;
Physics.AngularDrag = 0.9f;
Render = new ImageRender(this, "Render");
Render.SetTexture(GetRoot <State>().GetService <AssetCollector>().GetAsset <Texture2D>("ship"));
Render.Layer = .01f;
Render.Scale = new Vector2(.128f);
Render.LinkDependency(ImageRender.DEPENDENCY_BODY, Body);
Body.Bounds = Render.Bounds;
Body.Origin = new Vector2(Render.Texture.Width / 2f, Render.Texture.Height / 2f);
Gun = new SimpleGun(this, "SimpleGun");
Gun.LinkDependency(SimpleGun.DEPENDENCY_BODY, Body);
Gun.LinkDependency(SimpleGun.DEPENDENCY_PHYSICS, Physics);
Shape = new Circle(this, "Circle", Body.Width * .8f);
Shape.Offset = new Vector2(Body.Width / 2, Body.Height / 2);
Shape.Debug = true;
Shape.LinkDependency(Circle.DEPENDENCY_BODY, Body);
Collision.Group.AddMask(0);
Collision.Pair.AddMask(2);
Collision.CollideEvent += OnCollide;
Collision.Immovable = true;
Collision.LinkDependency(Collision.DEPENDENCY_SHAPE, Shape);
Shape.LinkDependency(Circle.DEPENDENCY_COLLISION, Collision);
//Control
UpButton = new DoubleInput(this, "UpButton", Keys.W, Buttons.DPadUp, PlayerIndex.One);
DownButton = new DoubleInput(this, "DownButton", Keys.S, Buttons.DPadDown, PlayerIndex.One);
LeftButton = new DoubleInput(this, "LeftButton", Keys.A, Buttons.DPadLeft, PlayerIndex.One);
RightButton = new DoubleInput(this, "RightButton", Keys.D, Buttons.DPadRight, PlayerIndex.One);
FireButton = new DoubleInput(this, "FireButton", Keys.Space, Buttons.A, PlayerIndex.One);
ThrustTrigger = new GamePadTrigger(this, "ThrustTrigger", Triggers.Right, PlayerIndex.One);
//GravityTrigger = new GamePadTrigger(this, "GravityTrigger", Triggers.Left, PlayerIndex.One);
LookAnalog = new GamePadAnalog(this, "LookAnalog", Sticks.Left, PlayerIndex.One);
}
public void AddGamePadTrigger(Identifier action, GamePadTrigger trigger, GamePadController controller = GamePadController.Any, PlayerId player = PlayerId.Player1)
{
var actionId = new InputActionId(action, player);
var gamePadTriggerInfo = new GamePadTriggerInfo(controller, trigger, 0f, false, false);
if (gamePadTriggerBindings.ContainsKey(actionId))
{
gamePadTriggerBindings[actionId].Add(gamePadTriggerInfo);
}
else
{
var newList = new List <GamePadTriggerInfo>()
{
gamePadTriggerInfo
};
gamePadTriggerBindings.Add(actionId, newList);
}
}
/// <summary>
/// Gets a trigger sprite frame from "Sprites\UI\controller.png"
/// </summary>
/// <param name="trigger">The trigger mapped to the sprite.</param>
public static Sprite GetIcon(GamePadTrigger trigger)
{
int iconPath;
switch (trigger)
{
case GamePadTrigger.Right:
iconPath = 71;
break;
case GamePadTrigger.Left:
iconPath = 70;
break;
default:
throw new ArgumentOutOfRangeException("trigger", trigger, null);
}
return(Resources.LoadAll <Sprite>(GamePadIconHelper.ControllerSpritePath)[iconPath]);
}
public GamePadTriggerInput(GamePadTrigger trigger, PlayerIndex playerIndex = PlayerIndex.One)
{
PlayerIndex = playerIndex;
Trigger = trigger;
}
/// <summary>
/// Release trigger stored in the polling handler. This occurs whenever a trigger is
/// literally released by a player.
/// </summary>
/// <param name="trigger"><see cref="GamePadTrigger"/> to release, holds trigger type and player index</param>
private void ReleaseTrigger(GamePadTrigger trigger)
{
this.triggers[(int)trigger.Player, (int)trigger.TriggerType] = 0.0f;
}
/// <summary>
/// Creates a new GamePadTriggerBinding instance for the specified player's gamepad, bound to the specified trigger and with the provided minimum and maximum threshold values.
/// </summary>
/// <param name="player">Player whose gamepad will be bound.</param>
/// <param name="trigger">Trigger to bind.</param>
/// <param name="minimumThreshold">Minimum trigger value to match.</param>
/// <param name="maximumThreshold">Maximum trigger value to match.</param>
/// <remarks>Minimum and maximum threshold values must be in the range 0.0 .. 1.0, where increasing values indicate increasing pull on the trigger.</remarks>
/// <exception cref="System.ArgumentOutOfRangeException">Thrown if minimumThreshold is greater than maximumThreshold.</exception>
public GamePadTriggerMatcher(PlayerIndex player, GamePadTrigger trigger, float minimumThreshold, float maximumThreshold)
: base(player)
{
if (minimumThreshold > maximumThreshold)
{
throw new ArgumentOutOfRangeException("minimumThreshold");
}
Player = player;
Trigger = trigger;
MinimumThreshold = minimumThreshold;
MaximumThreshold = maximumThreshold;
}
public abstract float GetGamePadTrigger(GamePadTrigger trigger, GamePadController controller = GamePadController.Any, bool rawValue = false);