public void ConstructorTakesOverAxisStates() {
var axes = new float[24];
var sliders = new float[8];
var buttons = new bool[128];
var povs = new int[4];
int axisIndex = 0;
foreach (ExtendedAxes axis in Enum.GetValues(typeof(ExtendedAxes))) {
Array.Clear(axes, 0, 24);
axes[axisIndex] = 12.34f;
ExtendedGamePadState state = new ExtendedGamePadState(
axis, axes,
0, sliders,
0, buttons,
0, povs
);
// Only the provided axis should be reported as available by the state
Assert.AreEqual(state.AvailableAxes, axis);
// Ensure only the provided axis has the value assigned
foreach (ExtendedAxes axis2 in Enum.GetValues(typeof(ExtendedAxes))) {
if (axis2 == axis) {
Assert.AreEqual(12.34f, state.GetAxis(axis2));
} else {
Assert.AreEqual(0.0f, state.GetAxis(axis2));
}
}
++axisIndex;
}
}
/// <summary>Initializes a new mocked game pad</summary>
public MockedGamePad()
{
this.states = new Queue<ExtendedGamePadState>();
this.current = new ExtendedGamePadState();
this.buttonStates = new bool[128];
this.axisStates = new float[24];
this.sliderStates = new float[8];
this.povStates = new int[4] { -1, -1, -1, -1 };
this.buttonCount = 11;
this.availableAxes =
ExtendedAxes.X | ExtendedAxes.Y |
ExtendedAxes.RotationX | ExtendedAxes.RotationY;
this.availableSliders =
ExtendedSliders.Slider1 | ExtendedSliders.Slider2;
this.povCount = 1;
}
public void TestExtendedGamePadStateConversion() {
requireAttachedJoystick();
var converter = new DirectInputConverter(this.joystick);
JoystickState joystickState = this.joystick.GetCurrentState();
var gamePadState = new ExtendedGamePadState(converter, ref joystickState);
}
/// <summary>Generates events for any changes to the button states</summary>
/// <param name="previous">Previous state of the game pad to compare against</param>
/// <param name="current">Current state of the game pad</param>
private void generateEvents(
ref ExtendedGamePadState previous, ref ExtendedGamePadState current
)
{
ulong previous1, previous2;
previous.InternalGetButtons(out previous1, out previous2);
ulong current1, current2;
current.InternalGetButtons(out current1, out current2);
// Determine which buttons have changed state since the last update
ulong changeMask1 = previous1 ^ current1;
ulong changeMask2 = previous2 ^ current2;
// Report any buttons that have been pressed
ulong pressed1 = current1 & changeMask1;
ulong pressed2 = current2 & changeMask2;
if ((pressed1 != 0) || (pressed2 != 0)) {
Buttons pressed = ExtendedGamePadState.ButtonsFromExtendedButtons(pressed1);
if (pressed != 0) {
OnButtonPressed(pressed);
}
OnExtendedButtonPressed(pressed1, pressed2);
}
// Report any buttons that have been released
ulong released1 = ~current1 & changeMask1;
ulong released2 = ~current2 & changeMask2;
if ((released1 != 0) || (released2 != 0)) {
Buttons released = ExtendedGamePadState.ButtonsFromExtendedButtons(released1);
if (released != 0) {
OnButtonReleased(released);
}
OnExtendedButtonReleased(released1, released2);
}
}
/// <summary>Updates the state of the input device</summary>
/// <remarks>
/// <para>
/// If this method is called with no snapshots in the queue, it will take
/// an immediate snapshot and make it the current state. This way, you
/// can use the input devices without caring for the snapshot system if
/// you wish.
/// </para>
/// <para>
/// If this method is called while one or more snapshots are waiting in
/// the queue, this method takes the next snapshot from the queue and makes
/// it the current state.
/// </para>
/// </remarks>
public override void Update()
{
ExtendedGamePadState previous = this.current;
if (this.states.Count == 0) {
this.current = buildState();
} else {
this.current = this.states.Dequeue();
}
generateEvents(ref previous, ref this.current);
}
public void ConstructorTakesOverAxisCount() {
var axes = new float[24];
var sliders = new float[8];
var buttons = new bool[128];
var povs = new int[4];
for (int count = 0; count < 24; ++count) {
int axisBits = 0;
for (int axisIndex = 0; axisIndex < count; ++axisIndex) {
axisBits |= (1 << axisIndex);
}
ExtendedGamePadState state = new ExtendedGamePadState(
(ExtendedAxes)axisBits, axes,
0, sliders,
0, buttons,
0, povs
);
// Only the provided axes should be reported as available by the state
Assert.AreEqual(state.AvailableAxes, (ExtendedAxes)axisBits);
Assert.AreEqual(count, state.AxisCount);
}
}
public void ExtendedGamePadStateCanBeConstructedFromGamePadState(Buttons button) {
var state = new GamePadState(
new Vector2(0.12f, 0.34f),
new Vector2(0.56f, 0.78f),
0.1234f, 0.5678f,
button
);
var extendedState = new ExtendedGamePadState(ref state);
Assert.AreEqual(0.12f, extendedState.GetAxis(ExtendedAxes.X));
Assert.AreEqual(0.34f, extendedState.GetAxis(ExtendedAxes.Y));
Assert.AreEqual(0.56f, extendedState.GetAxis(ExtendedAxes.RotationX));
Assert.AreEqual(0.78f, extendedState.GetAxis(ExtendedAxes.RotationY));
Assert.AreEqual(0.1234f, extendedState.GetSlider(ExtendedSliders.Slider1));
Assert.AreEqual(0.5678f, extendedState.GetSlider(ExtendedSliders.Slider2));
switch (button) {
case Buttons.DPadUp: {
Assert.AreEqual(0, extendedState.GetPov(0));
break;
}
case Buttons.DPadRight: {
Assert.AreEqual(9000, extendedState.GetPov(0));
break;
}
case Buttons.DPadDown: {
Assert.AreEqual(18000, extendedState.GetPov(0));
break;
}
case Buttons.DPadLeft: {
Assert.AreEqual(27000, extendedState.GetPov(0));
break;
}
default: {
Assert.IsTrue(
extendedState.IsButtonDown(
Array.IndexOf(ExtendedGamePadState.ButtonOrder, button)
)
);
break;
}
}
}
public void DefaultConstructorCanBeUsed() {
var state = new ExtendedGamePadState();
Assert.IsNotNull(state); // nonsense, avoids compiler warning
}
public void AccessingInvalidButtonsCausesException(int buttonIndex) {
var state = new ExtendedGamePadState();
Assert.Throws<ArgumentOutOfRangeException>(
delegate() { state.IsButtonDown(buttonIndex); }
);
Assert.Throws<ArgumentOutOfRangeException>(
delegate() { state.IsButtonUp(buttonIndex); }
);
}
public void InvalidPovIndexCausesException(int povIndex) {
var state = new ExtendedGamePadState();
Assert.Throws<ArgumentOutOfRangeException>(
delegate() { state.GetPov(povIndex); }
);
}
public void AccessingInvalidSliderCausesException() {
var state = new ExtendedGamePadState();
Assert.Throws<ArgumentOutOfRangeException>(
delegate() {
state.GetSlider(ExtendedSliders.Slider1 | ExtendedSliders.Slider2);
}
);
}
public void AccessingInvalidAxisCausesException() {
var state = new ExtendedGamePadState();
Assert.Throws<ArgumentOutOfRangeException>(
delegate() {
state.GetAxis(ExtendedAxes.X | ExtendedAxes.Y);
}
);
}
public void ConstructorTakesOverPovControllerStates() {
var axes = new float[24];
var sliders = new float[8];
var buttons = new bool[128];
var povs = new int[4];
for (int povIndex = 0; povIndex < 4; ++povIndex) {
Array.Clear(povs, 0, 4);
povs[povIndex] = 12345;
var state = new ExtendedGamePadState(
0, axes,
0, sliders,
0, buttons,
povIndex + 1, povs
);
// The specified number of PoV controllers should be available
Assert.AreEqual(state.PovCount, povIndex + 1);
// Ensure only the provided pov has the value assigned
for (int povIndex2 = 0; povIndex2 < 4; ++povIndex2) {
if (povIndex2 == povIndex) {
Assert.AreEqual(12345, state.GetPov(povIndex2));
} else {
Assert.AreEqual(0, state.GetPov(povIndex2));
}
} // for
} // for
}
public void ConstuctorTakesOverButtonStates() {
var axes = new float[24];
var sliders = new float[8];
var buttons = new bool[128];
var povs = new int[4];
for (int buttonIndex = 0; buttonIndex < 128; ++buttonIndex) {
Array.Clear(buttons, 0, 128);
buttons[buttonIndex] = true;
ExtendedGamePadState state = new ExtendedGamePadState(
0, axes,
0, sliders,
buttonIndex + 1, buttons,
0, povs
);
// The specified number of buttons should be available
Assert.AreEqual(state.ButtonCount, buttonIndex + 1);
// Ensure only the provided button is reported as pressed
for (int buttonIndex2 = 0; buttonIndex2 < 128; ++buttonIndex2) {
if (buttonIndex2 == buttonIndex) {
Assert.AreEqual(ButtonState.Pressed, state.GetButton(buttonIndex2));
Assert.IsTrue(state.IsButtonDown(buttonIndex2));
Assert.IsFalse(state.IsButtonUp(buttonIndex2));
} else {
Assert.AreEqual(ButtonState.Released, state.GetButton(buttonIndex2));
Assert.IsFalse(state.IsButtonDown(buttonIndex2));
Assert.IsTrue(state.IsButtonUp(buttonIndex2));
}
} // for
} // for
}
public void ConstructorTakesOverSliderStates() {
var axes = new float[24];
var sliders = new float[8];
var buttons = new bool[128];
var povs = new int[4];
int sliderIndex = 0;
foreach (ExtendedSliders slider in Enum.GetValues(typeof(ExtendedSliders))) {
Array.Clear(sliders, 0, 8);
sliders[sliderIndex] = 12.34f;
ExtendedGamePadState state = new ExtendedGamePadState(
0, axes,
slider, sliders,
0, buttons,
0, povs
);
// Only the provided slider should be reported as available by the state
Assert.AreEqual(state.AvailableSliders, slider);
// Ensure only the provided slider has the value assigned
foreach (ExtendedSliders slider2 in Enum.GetValues(typeof(ExtendedSliders))) {
if (slider2 == slider) {
Assert.AreEqual(12.34f, state.GetSlider(slider2));
} else {
Assert.AreEqual(0.0f, state.GetSlider(slider2));
}
}
++sliderIndex;
}
}
