/// <summary>Retrieve the pressed state of a button</summary>
/// <param name="buttonID">The identification of the requested button</param>
public bool GetButton(Controller.Button buttonID)
{
switch (buttonID)
{
case Controller.Button.ButtonOne:
return(buttons[0]);
case Controller.Button.ButtonTwo:
return(buttons[1]);
case Controller.Button.ButtonThree:
return(buttons[2]);
case Controller.Button.ButtonFour:
return(buttons[3]);
case Controller.Button.Bumper:
return(trigger1 > 0.9F);
case Controller.Button.Trigger:
return(trigger2 > 0.9F);
case Controller.Button.StickButton:
return(stickButton);
case Controller.Button.StickTouch:
return(stickTouch);
case Controller.Button.Option:
return(option);
default:
return(false);
}
}
public ButtonImg(Controller.Button type, Point center, int radius, Color color)
{
this.center = center;
this.radius = radius;
this.color = color;
this.type = type;
}
public void on_press(Controller.Button what)
{
if (block_input || authority_block)
{
return;
}
previous_position = transform.position;
float step = game.get_cell_size();
Vector3 next_position = previous_position;
switch (what)
{
case Controller.Button.Up:
next_position += (Vector3.up * step);
break;
case Controller.Button.Down:
next_position += (Vector3.down * step);
break;
case Controller.Button.Left:
next_position += (Vector3.left * step);
break;
case Controller.Button.Right:
next_position += (Vector3.right * step);
break;
}
next_position = game.clamp(next_position);
transform.position = next_position;
block_input = true;
var outcome = game.refresh_player_position_and_check_death(transform.position, previous_position);
switch (outcome)
{
case Screen.Outcome.None:
if (previous_position != (Vector2)transform.position)
{
audio_source.Play();
}
return;
case Screen.Outcome.Lose:
game.game_over();
break;
case Screen.Outcome.Win:
game.win_level();
break;
}
}
/// <summary>
/// the controllers client send are transfered here
/// </summary>
void KeyHandle()
{
//in order: a b select start up down left right
Controller.Button key_pressed = Controller.Button.A;
for (int i = 0; i < keyButtons.Length; i++)
{
switch (i)
{
case 0:
key_pressed = Controller.Button.A;
break;
case 1:
key_pressed = Controller.Button.B;
break;
case 2:
key_pressed = Controller.Button.Select;
break;
case 3:
key_pressed = Controller.Button.Start;
break;
case 4:
key_pressed = Controller.Button.Up;
break;
case 5:
key_pressed = Controller.Button.Down;
break;
case 6:
key_pressed = Controller.Button.Left;
break;
case 7:
key_pressed = Controller.Button.Right;
break;
}
uploadConsole.Controller.setButtonState(key_pressed, keyButtons[i] ? true : false);
}
}
/// <summary>
/// Returns true if the provided button was pressed this frame.
/// </summary>
/// <param name="button">A button on an Xbox controller.</param>
/// <returns>True if the provided button was pressed this frame.</returns>
public bool WasPressed(Controller.Button button)
{
// This button press was already registered earlier this frame
if (this.pressedButton == button && this.pressedButtonState == ButtonState.Pressed)
{
return(true);
}
// No button currently pressed and this is the next button to be pressed
if (!this.pressedButton.HasValue && this.buttonPressIndex < this.buttonPresses.Length && this.buttonPresses[this.buttonPressIndex] == button)
{
this.pressedButton = this.buttonPresses[this.buttonPressIndex];
this.pressedButtonState = ButtonState.Pressed;
this.pressedButtonTime = Time.time;
this.buttonPressIndex++;
return(true);
}
return(false);
}
void VirtualHandControl()
{
Controller.Button rightTouched = this.rightHand.TouchButton(this.buttonsVirtual);
Controller.Button leftTouched = this.leftHand.TouchButton(this.buttonsVirtual);
if (keyStates.A == false)
{
if (rightTouched == Controller.Button.A || leftTouched == Controller.Button.A)
{
_console.Controller.setButtonState(Controller.Button.A, true);
keyStates.A = true;
}
}
else
{
if (rightTouched != Controller.Button.A && leftTouched != Controller.Button.A)
{
_console.Controller.setButtonState(Controller.Button.A, false);
keyStates.A = false;
}
}
if (keyStates.B == false)
{
if (rightTouched == Controller.Button.B || leftTouched == Controller.Button.B)
{
_console.Controller.setButtonState(Controller.Button.B, true);
keyStates.B = true;
}
}
else
{
if (rightTouched != Controller.Button.B && leftTouched != Controller.Button.B)
{
_console.Controller.setButtonState(Controller.Button.B, false);
keyStates.B = false;
}
}
if (keyStates.Start == false)
{
if (rightTouched == Controller.Button.Start || leftTouched == Controller.Button.Start)
{
_console.Controller.setButtonState(Controller.Button.Start, true);
keyStates.Start = true;
}
}
else
{
if (rightTouched != Controller.Button.Start && leftTouched != Controller.Button.Start)
{
_console.Controller.setButtonState(Controller.Button.Start, false);
keyStates.Start = false;
}
}
if (keyStates.Selete == false)
{
if (rightTouched == Controller.Button.Select || leftTouched == Controller.Button.Select)
{
_console.Controller.setButtonState(Controller.Button.Select, true);
keyStates.Selete = true;
}
}
else
{
if (rightTouched != Controller.Button.Select && leftTouched != Controller.Button.Select)
{
_console.Controller.setButtonState(Controller.Button.Select, false);
keyStates.Selete = false;
}
}
if (keyStates.Up == false)
{
if (rightTouched == Controller.Button.Up || leftTouched == Controller.Button.Up)
{
_console.Controller.setButtonState(Controller.Button.Up, true);
keyStates.Up = true;
}
}
else
{
if (rightTouched != Controller.Button.Up && leftTouched != Controller.Button.Up)
{
_console.Controller.setButtonState(Controller.Button.Up, false);
keyStates.Up = false;
}
}
if (keyStates.Down == false)
{
if (rightTouched == Controller.Button.Down || leftTouched == Controller.Button.Down)
{
_console.Controller.setButtonState(Controller.Button.Down, true);
keyStates.Down = true;
}
}
else
{
if (rightTouched != Controller.Button.Down && leftTouched != Controller.Button.Down)
{
_console.Controller.setButtonState(Controller.Button.Down, false);
keyStates.Down = false;
}
}
if (keyStates.Right == false)
{
if (rightTouched == Controller.Button.Right || leftTouched == Controller.Button.Right)
{
_console.Controller.setButtonState(Controller.Button.Right, true);
keyStates.Right = true;
}
}
else
{
if (rightTouched != Controller.Button.Right && leftTouched != Controller.Button.Right)
{
_console.Controller.setButtonState(Controller.Button.Right, false);
keyStates.Right = false;
}
}
if (keyStates.Left == false)
{
if (rightTouched == Controller.Button.Left || leftTouched == Controller.Button.Left)
{
_console.Controller.setButtonState(Controller.Button.Left, true);
keyStates.Left = true;
}
}
else
{
if (rightTouched != Controller.Button.Left && leftTouched != Controller.Button.Left)
{
_console.Controller.setButtonState(Controller.Button.Left, false);
keyStates.Left = false;
}
}
}
public static void PressButton(Controller.Button pButton, bool pPressed)
{
_console.Controller.setButtonState(pButton, pPressed);
}
/// <summary>
/// Returns true if the provided button was released this frame.
/// </summary>
/// <param name="button">A button on an Xbox controller.</param>
/// <returns>True if the provided button was released this frame.</returns>
public bool WasReleased(Controller.Button button)
{
return(button == this.pressedButton && this.pressedButtonState == ButtonState.Released);
}
/// <summary>
/// Returns true if the provided button is pressed.
/// </summary>
/// <param name="button">A button on an Xbox controller.</param>
/// <returns>True if the provided button is currently pressed.</returns>
public bool IsDown(Controller.Button button)
{
return(button == this.HeldButton || (button == this.pressedButton && this.pressedButtonState != ButtonState.Released));
}
/// <summary>
/// Handles a call to a Python function.
/// </summary>
/// <param name="function">The Python function to call (start or update)</param>
private void PythonCall(Header function)
{
if (!this.isSyncConnected)
{
this.HandleError("Not connected to a Python script.");
}
// Tell Python what function to call
this.udpClient.Send(new byte[] { (byte)function }, 1);
// Respond to API calls from Python until we receive a python_finished message
bool pythonFinished = false;
while (!pythonFinished)
{
// Receive a response from Python
byte[] data = this.SafeRecieve();
if (data == null)
{
break;
}
Header header = (Header)data[0];
// Send the appropriate response if it was an API call, or break if it was a python_finished message
byte[] sendData;
switch (header)
{
case Header.error:
HandleError("Error code sent from Python.");
break;
case Header.python_finished:
pythonFinished = true;
break;
case Header.racecar_get_delta_time:
sendData = BitConverter.GetBytes(Time.deltaTime);
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.camera_get_color_image:
this.SendFragmented(this.racecar.Camera.ColorImageRaw, 32);
break;
case Header.camera_get_depth_image:
sendData = this.racecar.Camera.DepthImageRaw;
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.camera_get_width:
sendData = BitConverter.GetBytes(CameraModule.ColorWidth);
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.camera_get_height:
sendData = BitConverter.GetBytes(CameraModule.ColorHeight);
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.controller_is_down:
Controller.Button buttonDown = (Controller.Button)data[1];
sendData = BitConverter.GetBytes(this.racecar.Controller.IsDown(buttonDown));
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.controller_was_pressed:
Controller.Button buttonPressed = (Controller.Button)data[1];
sendData = BitConverter.GetBytes(this.racecar.Controller.WasPressed(buttonPressed));
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.controller_was_released:
Controller.Button buttonReleased = (Controller.Button)data[1];
sendData = BitConverter.GetBytes(this.racecar.Controller.WasReleased(buttonReleased));
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.controller_get_trigger:
Controller.Trigger trigger = (Controller.Trigger)data[1];
sendData = BitConverter.GetBytes(this.racecar.Controller.GetTrigger(trigger));
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.controller_get_joystick:
Controller.Joystick joystick = (Controller.Joystick)data[1];
Vector2 joystickValues = this.racecar.Controller.GetJoystick(joystick);
sendData = new byte[sizeof(float) * 2];
Buffer.BlockCopy(new float[] { joystickValues.x, joystickValues.y }, 0, sendData, 0, sendData.Length);
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.drive_set_speed_angle:
this.racecar.Drive.Speed = BitConverter.ToSingle(data, 4);
this.racecar.Drive.Angle = BitConverter.ToSingle(data, 8);
break;
case Header.drive_stop:
this.racecar.Drive.Stop();
break;
case Header.drive_set_max_speed:
this.racecar.Drive.MaxSpeed = BitConverter.ToSingle(data, 4);
break;
case Header.lidar_get_num_samples:
sendData = BitConverter.GetBytes(Lidar.NumSamples);
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.lidar_get_samples:
sendData = new byte[sizeof(float) * Lidar.NumSamples];
Buffer.BlockCopy(this.racecar.Lidar.Samples, 0, sendData, 0, sendData.Length);
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.physics_get_linear_acceleration:
Vector3 linearAcceleration = this.racecar.Physics.LinearAccceleration;
sendData = new byte[sizeof(float) * 3];
Buffer.BlockCopy(new float[] { linearAcceleration.x, linearAcceleration.y, linearAcceleration.z }, 0, sendData, 0, sendData.Length);
this.udpClient.Send(sendData, sendData.Length);
break;
case Header.physics_get_angular_velocity:
Vector3 angularVelocity = this.racecar.Physics.AngularVelocity;
sendData = new byte[sizeof(float) * 3];
Buffer.BlockCopy(new float[] { angularVelocity.x, angularVelocity.y, angularVelocity.z }, 0, sendData, 0, sendData.Length);
this.udpClient.Send(sendData, sendData.Length);
break;
default:
Debug.LogError($">> Error: The function {header} is not supported by RacecarSim.");
break;
}
}
}
/// <summary>
/// Calls a Python function on all connected scripts.
/// </summary>
/// <param name="function">The Python function to call (start or update)</param>
private void PythonCall(Header function)
{
for (int i = 0; i < this.pythonEndPoints.Count; i++)
{
if (this.pythonEndPoints[i] == null)
{
continue;
}
Racecar racecar = LevelManager.GetCar(i);
IPEndPoint endPoint = this.pythonEndPoints[i];
// Tell Python what function to call
this.udpClient.Send(new byte[] { (byte)function }, 1, endPoint);
// Respond to API calls from Python until we receive a python_finished message
bool pythonFinished = false;
while (!pythonFinished)
{
// Receive a response from Python
byte[] data = this.SafeRecieve(endPoint);
if (data == null)
{
break;
}
Header header = (Header)data[0];
bool shouldSendController = LevelManager.LevelManagerMode != LevelManagerMode.Race || Settings.CheatMode;
// Send the appropriate response if it was an API call, or break if it was a python_finished message
byte[] sendData;
switch (header)
{
case Header.error:
Error errorCode = (Error)data[1];
HandleError($"Error code [{errorCode}] sent from the Python script controlling car {i}.", errorCode);
pythonFinished = true;
break;
case Header.python_finished:
pythonFinished = true;
break;
case Header.python_exit:
this.RemoveSyncClient(endPoint.Port);
pythonFinished = true;
break;
case Header.racecar_get_delta_time:
sendData = BitConverter.GetBytes(Time.deltaTime);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.camera_get_color_image:
pythonFinished = !this.SendFragmented(racecar.Camera.ColorImageRaw, 32, endPoint);
break;
case Header.camera_get_depth_image:
sendData = racecar.Camera.DepthImageRaw;
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.camera_get_width:
sendData = BitConverter.GetBytes(CameraModule.ColorWidth);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.camera_get_height:
sendData = BitConverter.GetBytes(CameraModule.ColorHeight);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
// Always return null controller data when in race mode (except in cheat mode)
case Header.controller_is_down:
Controller.Button buttonDown = (Controller.Button)data[1];
sendData = BitConverter.GetBytes(Controller.IsDown(buttonDown) && shouldSendController);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.controller_was_pressed:
Controller.Button buttonPressed = (Controller.Button)data[1];
sendData = BitConverter.GetBytes(Controller.WasPressed(buttonPressed) && shouldSendController);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.controller_was_released:
Controller.Button buttonReleased = (Controller.Button)data[1];
sendData = BitConverter.GetBytes(Controller.WasReleased(buttonReleased) && shouldSendController);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.controller_get_trigger:
Controller.Trigger trigger = (Controller.Trigger)data[1];
float triggerValue = shouldSendController ? Controller.GetTrigger(trigger) : 0;
sendData = BitConverter.GetBytes(triggerValue);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.controller_get_joystick:
Controller.Joystick joystick = (Controller.Joystick)data[1];
Vector2 joystickValues = shouldSendController ? Controller.GetJoystick(joystick) : Vector2.zero;
sendData = new byte[sizeof(float) * 2];
Buffer.BlockCopy(new float[] { joystickValues.x, joystickValues.y }, 0, sendData, 0, sendData.Length);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.drive_set_speed_angle:
racecar.Drive.Speed = BitConverter.ToSingle(data, 4);
racecar.Drive.Angle = BitConverter.ToSingle(data, 8);
break;
case Header.drive_stop:
racecar.Drive.Stop();
break;
case Header.drive_set_max_speed:
racecar.Drive.MaxSpeed = BitConverter.ToSingle(data, 4);
break;
case Header.lidar_get_num_samples:
sendData = BitConverter.GetBytes(Lidar.NumSamples);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.lidar_get_samples:
sendData = new byte[sizeof(float) * Lidar.NumSamples];
Buffer.BlockCopy(racecar.Lidar.Samples, 0, sendData, 0, sendData.Length);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.physics_get_linear_acceleration:
Vector3 linearAcceleration = racecar.Physics.LinearAccceleration;
sendData = new byte[sizeof(float) * 3];
Buffer.BlockCopy(new float[] { linearAcceleration.x, linearAcceleration.y, linearAcceleration.z }, 0, sendData, 0, sendData.Length);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
case Header.physics_get_angular_velocity:
Vector3 angularVelocity = racecar.Physics.AngularVelocity;
sendData = new byte[sizeof(float) * 3];
Buffer.BlockCopy(new float[] { angularVelocity.x, angularVelocity.y, angularVelocity.z }, 0, sendData, 0, sendData.Length);
this.udpClient.Send(sendData, sendData.Length, endPoint);
break;
default:
Debug.LogError($">> Error: The function {header} is not supported by RacecarSim.");
pythonFinished = true;
break;
}
}
}
}
