private async Task CheckHang(CancellationToken cancellationToken)
{
if (!SpeedSensor.IsDriving)
{
var carMoveCommand = new CarMoveCommand
{
Speed = 0
};
_motorController.MoveCar(null, carMoveCommand);
Driving = null;
await AudioPlayerController.PlayAndWaitAsync(AudioName.AutomatischesFahrenFesthaengen).WithCancellation(cancellationToken);
await TurnBackward(1000, cancellationToken);
await TurnLeft(700, cancellationToken, false);
carMoveCommand = new CarMoveCommand
{
Speed = 0
};
_motorController.MoveCar(null, carMoveCommand);
}
}
private const float k_GroundedStickingVelocityMultiplier = 3f; // This is to help the character stick to vertically moving platforms.
private void Awake()
{
m_SpriteRenderer = GetComponent <SpriteRenderer>();
m_Animator = GetComponent <Animator>();
m_CharacterController2D = GetComponent <CharacterController2D>();
m_Collider2D = GetComponent <Collider2D>();
m_HashDeadEffect = VFXController.StringToHash(deadEffect);
m_HashAppearingEffect = VFXController.StringToHash(appearingEffect);
m_HashDustEffect = VFXController.StringToHash(dustEffect);
m_HashFootStepAudioPlayer = AudioPlayerController.StringToHash(footStepAudioPlayer);
m_HashHitAudioPlayer = AudioPlayerController.StringToHash(hitAudioPlayer);
m_HashDeadAudioPlayer = AudioPlayerController.StringToHash(deadAudioPlayer);
m_HashAppearingAudioPlayer = AudioPlayerController.StringToHash(appearingAudioPlayer);
m_HashLandAudioPlayer = AudioPlayerController.StringToHash(landAudioPlayer);
m_HashStartJumpingAudioPlayer = AudioPlayerController.StringToHash(startJumpingAudioPlayer);
m_SlashPool = BulletPool.GetObjectPool(slashPrefab, 1);
m_SpriteRenderer.enabled = false;
shadow.SetActive(false);
GameManager.Instance.RegisterPlayer(this);
}
public async Task Stop()
{
if (_isStopped)
{
return;
}
Driving = null;
if (_cancellationTokenSource != null)
{
_cancellationTokenSource.Cancel();
}
_isStopping = true;
while (!_isStopped)
{
await Task.Delay(10);
}
_isStopping = false;
await AudioPlayerController.PlayAndWaitAsync(AudioName.StopAutomaticDrive);
}
private async Task Initialze()
{
if (LightningProvider.IsLightningEnabled)
{
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
}
else
{
throw new Exception("Lightning drivers not enabled. Please enable Lightning drivers.");
}
_camera = new Camera();
await _camera.Initialize();
SpeedSensor.Initialize();
SpeedSensor.Start();
SpeechSynthesis.Initialze();
await AudioPlayerController.Initialize();
_accelerometerSensor = new AccelerometerGyroscopeSensor();
await _accelerometerSensor.Initialize();
_accelerometerSensor.Start();
_automaticSpeakController = new AutomaticSpeakController(_accelerometerSensor);
_motorController = new MotorController();
await _motorController.Initialize(_automaticSpeakController);
_servoController = new ServoController();
await _servoController.Initialize();
_distanceMeasurementSensor = new DistanceMeasurementSensor();
await _distanceMeasurementSensor.Initialize(I2C_ADDRESS_SERVO);
_automaticDrive = new AutomaticDrive(_motorController, _servoController, _distanceMeasurementSensor);
_speechRecognation = new SpeechRecognition();
await _speechRecognation.Initialze(_motorController, _servoController, _automaticDrive);
_speechRecognation.Start();
_gamepadController = new GamepadController(_motorController, _servoController, _automaticDrive, _accelerometerSensor);
_camera.Start();
_httpServerController = new HttpServerController(_motorController, _servoController, _automaticDrive, _camera);
SystemController.Initialize(_accelerometerSensor, _automaticSpeakController, _motorController, _servoController, _automaticDrive, _camera, _httpServerController, _speechRecognation, _gamepadController);
await SystemController.SetAudioRenderVolume(AUDIO_RENDER_VOLUME, true);
await SystemController.SetAudioCaptureVolume(AUDIO_CAPTURE_VOLUME, true);
await AudioPlayerController.PlayAndWaitAsync(AudioName.Welcome);
_automaticSpeakController.Start();
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
DontDestroyOnLoad(this);
}
public static async Task Restart()
{
if (!_initialized)
{
return;
}
await StopAll();
await AudioPlayerController.PlayAndWaitAsync(AudioName.Restart);
await ProcessLauncher.RunToCompletionAsync(@"CmdWrapper.exe", "\"shutdown -r -t 0\"");
}
private async Task StartInternal()
{
if (!_isStopped)
{
return;
}
_isStopped = false;
Driving = null;
_cancellationTokenSource = new CancellationTokenSource();
StartInternal(_cancellationTokenSource.Token);
await AudioPlayerController.PlayAndWaitAsync(AudioName.StartAutomaticDrive);
}
public static async Task ShutdownApplication(bool unhandeledException)
{
if (unhandeledException)
{
try
{
await AudioPlayerController.PlayAndWaitAsync(AudioName.AppError);
}
catch (Exception) { }
}
try
{
await StopAll();
}
catch (Exception) { }
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Application.Current.Exit();
});
}
private void AppUnhandeledException(object sender, UnhandledExceptionEventArgs eventArgs)
{
try
{
var task = Task.Run(async() => await Logger.Write(nameof(App), eventArgs.Exception));
task.Wait();
}
catch (Exception) { }
try
{
var task = Task.Run(async() => await SystemController.StopAll());
task.Wait();
}
catch (Exception) { }
try
{
var task = Task.Run(async() => await AudioPlayerController.PlayAndWaitAsync(AudioName.AppError));
task.Wait();
}
catch (Exception) { }
}
public static async Task StopAll()
{
var stopTask = Task.Run(async() =>
{
ShutdownMotorsServos();
_httpServerController.Stop();
await _camera.Stop();
await _gamepadController.Stop();
await _speechRecognation.Stop();
await _automaticDrive.Stop();
_servoController.Stop();
_motorController.Stop();
await _automaticSpeakController.Stop();
await _accelerometerSensor.Stop();
AudioPlayerController.Stop();
SpeedSensor.Stop();
ShutdownMotorsServos();
});
var timeout = TimeSpan.FromSeconds(5);
await TaskHelper.WithTimeoutAfterStart(ct => stopTask.WithCancellation(ct), timeout);
}
private async Task WriteResponse(string relativeUrl, string request, bool requestError, IOutputStream outputStream)
{
var relativeUrlLower = relativeUrl.ToLowerInvariant();
//Request read not successfully
if (requestError)
{
HttpServerResponse.WriteResponseError("Request wurde nicht vollständig übermittelt oder zu langsam übermittelt und ist daher nicht vollständig.", outputStream);
}
//Get javascript
else if (relativeUrlLower.StartsWith("/javascript"))
{
HttpServerResponse.WriteResponseFile(ToFolderPath(relativeUrl), HttpContentType.JavaScript, outputStream);
}
//Get style
else if (relativeUrlLower.StartsWith("/styles"))
{
HttpServerResponse.WriteResponseFile(ToFolderPath(relativeUrl), HttpContentType.Css, outputStream);
}
//Get image
else if (relativeUrlLower.StartsWith("/images"))
{
HttpServerResponse.WriteResponseFile(ToFolderPath(relativeUrl), HttpContentType.Png, outputStream);
}
//Toggle automatic drive on/off
else if (relativeUrlLower.StartsWith("/automaticdrive"))
{
var requestBodyResult = GetRequestBody(request);
if (!requestBodyResult.Key)
{
HttpServerResponse.WriteResponseError("Request wurde nicht vollständig übermittelt.", outputStream);
}
var automaticDriveOn = requestBodyResult.Value["automaticDrive"].GetBoolean();
if (automaticDriveOn)
{
_automaticDrive.Start();
}
else
{
await _automaticDrive.Stop();
}
HttpServerResponse.WriteResponseOk(outputStream);
}
//Move car with command
else if (relativeUrlLower.StartsWith("/carcontrolcommand"))
{
var requestBodyResult = GetRequestBody(request);
if (!requestBodyResult.Key)
{
HttpServerResponse.WriteResponseError("Request wurde nicht vollständig übermittelt.", outputStream);
}
var carControlCommandRequest = requestBodyResult.Value;
var carControlCommand = new CarControlCommand
{
DirectionControlUp = carControlCommandRequest["directionControlUp"].GetBoolean(),
DirectionControlLeft = carControlCommandRequest["directionControlLeft"].GetBoolean(),
DirectionControlRight = carControlCommandRequest["directionControlRight"].GetBoolean(),
DirectionControlDown = carControlCommandRequest["directionControlDown"].GetBoolean(),
SpeedControlForward = carControlCommandRequest["speedControlForward"].GetBoolean(),
SpeedControlBackward = carControlCommandRequest["speedControlBackward"].GetBoolean(),
SpeedControlLeftRight = carControlCommandRequest["speedControlLeftRight"].GetNumber(),
DirectionControlUpDownStepSpeed = 7
};
if (carControlCommand.DirectionControlLeft &&
carControlCommand.DirectionControlRight)
{
carControlCommand.DirectionControlLeft = false;
carControlCommand.DirectionControlRight = false;
}
CarMoveCommand(carControlCommand);
HttpServerResponse.WriteResponseOk(outputStream);
}
//Get car speed
else if (relativeUrlLower.StartsWith("/speed"))
{
var speedResponse = new JsonObject
{
{ "RoundsPerMinute", JsonValue.CreateStringValue(SpeedSensor.RoundsPerMinute.ToString()) },
{ "KilometerPerHour", JsonValue.CreateStringValue(string.Format("{0:0.00}", SpeedSensor.KilometerPerHour).Replace(".", ",")) }
};
HttpServerResponse.WriteResponseJson(speedResponse.Stringify(), outputStream);
}
//Get speaker states (on/off) and automatic drive state (on/off)
else if (relativeUrlLower.StartsWith("/getstate"))
{
var stateResponse = new JsonObject
{
{ "CarSpeakerOn", JsonValue.CreateBooleanValue(AudioPlayerController.CarSpeakerOn) },
{ "HeadsetSpeakerOn", JsonValue.CreateBooleanValue(AudioPlayerController.HeadsetSpeakerOn) },
{ "SoundModeOn", JsonValue.CreateBooleanValue(AudioPlayerController.SoundModeOn) },
{ "AutomaticDriveOn", JsonValue.CreateBooleanValue(_automaticDrive.IsRunning) }
};
HttpServerResponse.WriteResponseJson(stateResponse.Stringify(), outputStream);
}
//Set all speaker on
else if (relativeUrlLower.StartsWith("/speakeronoff?on=true"))
{
await AudioPlayerController.SetAllSpeakerOnOff(true);
HttpServerResponse.WriteResponseOk(outputStream);
}
//Set all speaker off
else if (relativeUrlLower.StartsWith("/speakeronoff?on=false"))
{
await AudioPlayerController.SetAllSpeakerOnOff(false);
HttpServerResponse.WriteResponseOk(outputStream);
}
//Set car speaker on
else if (relativeUrlLower.StartsWith("/carspeakeronoff?on=true"))
{
await AudioPlayerController.SetCarSpeakerOnOff(true);
HttpServerResponse.WriteResponseOk(outputStream);
}
//Set car speaker off
else if (relativeUrlLower.StartsWith("/carspeakeronoff?on=false"))
{
await AudioPlayerController.SetCarSpeakerOnOff(false);
HttpServerResponse.WriteResponseOk(outputStream);
}
//Set headset speaker on
else if (relativeUrlLower.StartsWith("/headsetspeakeronoff?on=true"))
{
await AudioPlayerController.SetHeadsetSpeakerOnOff(true);
HttpServerResponse.WriteResponseOk(outputStream);
}
//Set headset speaker off
else if (relativeUrlLower.StartsWith("/headsetspeakeronoff?on=false"))
{
await AudioPlayerController.SetHeadsetSpeakerOnOff(false);
HttpServerResponse.WriteResponseOk(outputStream);
}
//Set sound mode on
else if (relativeUrlLower.StartsWith("/soundmodeonoff?on=true"))
{
await AudioPlayerController.SetSoundModeOnOff(true);
HttpServerResponse.WriteResponseOk(outputStream);
}
//Set sound mode off
else if (relativeUrlLower.StartsWith("/soundmodeonoff?on=false"))
{
await AudioPlayerController.SetSoundModeOnOff(false);
HttpServerResponse.WriteResponseOk(outputStream);
}
//Shutdown Windows
else if (relativeUrlLower.StartsWith("/ausschalten"))
{
await SystemController.Shutdown();
HttpServerResponse.WriteResponseOk(outputStream);
}
//Restart Windows
else if (relativeUrlLower.StartsWith("/neustarten"))
{
await SystemController.Restart();
HttpServerResponse.WriteResponseOk(outputStream);
}
//Get debug file
else if (relativeUrlLower.StartsWith("/debug"))
{
var debugFile = await ApplicationData.Current.LocalFolder.TryGetItemAsync(Logger.FILE_NAME);
if (debugFile != null)
{
HttpServerResponse.WriteResponseFileFromLocalFolder(Logger.FILE_NAME, HttpContentType.Text, outputStream);
}
else
{
HttpServerResponse.WriteResponseText("Debug file is empty", outputStream);
}
}
//Get camera frame
else if (relativeUrlLower.StartsWith("/videoframe"))
{
if (_camera.Frame != null)
{
HttpServerResponse.WriteResponseFile(_camera.Frame, HttpContentType.Jpeg, outputStream);
}
else
{
HttpServerResponse.WriteResponseError("Not camera fram available. Maybe there is an error or camera is not started.", outputStream);
}
}
//Get desktop html view
else if (relativeUrlLower.StartsWith("/desktop"))
{
HttpServerResponse.WriteResponseFile(@"\Views\Desktop.html", HttpContentType.Html, outputStream);
}
//Get mobile html view
else if (relativeUrlLower.StartsWith("/mobile"))
{
HttpServerResponse.WriteResponseFile(@"\Views\Mobile.html", HttpContentType.Html, outputStream);
}
//Get view that redirect to desktop oder mobile view
else
{
HttpServerResponse.WriteResponseFile(@"\Views\Index.html", HttpContentType.Html, outputStream);
}
}
private async void RecognationResult(SpeechContinuousRecognitionSession sender, SpeechContinuousRecognitionResultGeneratedEventArgs args)
{
await StopDancing();
var recognation = args.Result.Text;
switch (recognation)
{
case "Kamera hoch":
await AudioPlayerController.Play(AudioName.CameraUp);
_servoController.MoveServo(new CarControlCommand
{
DirectionControlUpDownStepSpeed = _servoSpeechMoveSpeed,
DirectionControlUp = true
});
break;
case "Kamera leicht hoch":
await AudioPlayerController.Play(AudioName.CameraLightUp);
_servoController.MoveServo(new CarControlCommand
{
DirectionControlUpDownStepSpeed = _servoSpeechMoveLightSpeed,
DirectionControlUp = true
});
break;
case "Kamera runter":
await AudioPlayerController.Play(AudioName.CameraDown);
_servoController.MoveServo(new CarControlCommand
{
DirectionControlUpDownStepSpeed = _servoSpeechMoveSpeed,
DirectionControlDown = true
});
break;
case "Kamera leicht runter":
await AudioPlayerController.Play(AudioName.CameraLightDown);
_servoController.MoveServo(new CarControlCommand
{
DirectionControlUpDownStepSpeed = _servoSpeechMoveLightSpeed,
DirectionControlDown = true
});
break;
case "Vor":
await AudioPlayerController.Play(AudioName.Vor);
_motorController.MoveCar(null, new CarMoveCommand
{
ForwardBackward = true,
Speed = _recognationSpeed
});
_recognationForwardBackward = true;
_recognationIsDriving = true;
break;
case "Zurück":
await AudioPlayerController.Play(AudioName.Zurueck);
_motorController.MoveCar(null, new CarMoveCommand
{
ForwardBackward = false,
Speed = _recognationSpeed
});
_recognationForwardBackward = false;
_recognationIsDriving = true;
break;
case "Links":
await AudioPlayerController.Play(AudioName.Links);
_motorController.MoveCar(null, new CarMoveCommand
{
LeftCircle = true,
ForwardBackward = _recognationForwardBackward,
Speed = 1
});
await Task.Delay(TimeSpan.FromMilliseconds(700));
RecognationForwardBackwardStop();
break;
case "Rechts":
await AudioPlayerController.Play(AudioName.Rechts);
_motorController.MoveCar(null, new CarMoveCommand
{
RightCircle = true,
ForwardBackward = _recognationForwardBackward,
Speed = 1
});
await Task.Delay(TimeSpan.FromMilliseconds(700));
RecognationForwardBackwardStop();
break;
case "Stop":
await AudioPlayerController.Play(AudioName.Stop);
_motorController.MoveCar(null, new CarMoveCommand
{
Speed = 0
});
_recognationIsDriving = false;
_recognationForwardBackward = true;
break;
case "Wenden":
await AudioPlayerController.Play(AudioName.Wenden);
_motorController.MoveCar(null, new CarMoveCommand
{
RightCircle = true,
Speed = 1
});
await Task.Delay(TimeSpan.FromMilliseconds(1250));
RecognationForwardBackwardStop();
break;
case "Leicht Links":
await AudioPlayerController.Play(AudioName.LeichtLinks);
_motorController.MoveCar(null, new CarMoveCommand
{
LeftCircle = true,
ForwardBackward = _recognationForwardBackward,
Speed = 1
});
await Task.Delay(TimeSpan.FromMilliseconds(350));
RecognationForwardBackwardStop();
break;
case "Leicht Rechts":
await AudioPlayerController.Play(AudioName.LeichtRechts);
_motorController.MoveCar(null, new CarMoveCommand
{
RightCircle = true,
ForwardBackward = _recognationForwardBackward,
Speed = 1
});
await Task.Delay(TimeSpan.FromMilliseconds(350));
RecognationForwardBackwardStop();
break;
case "Langsam":
await AudioPlayerController.Play(AudioName.Langsam);
_recognationSpeed = 0.3;
RecognationForwardBackwardStop();
break;
case "Normal":
await AudioPlayerController.Play(AudioName.Normal);
_recognationSpeed = 0.6;
RecognationForwardBackwardStop();
break;
case "Schnell":
await AudioPlayerController.Play(AudioName.Schnell);
_recognationSpeed = 1;
RecognationForwardBackwardStop();
break;
case "Tanzen":
await AudioPlayerController.Play(AudioName.Tanzen);
_recognationForwardBackward = true;
_recognationIsDriving = false;
_recognationShouldDancing = true;
Task.Run(RecognationDance);
break;
case "Aktiviere automatisches Fahren":
_automaticDrive.Start();
break;
case "Deaktiviere automatisches Fahren":
await _automaticDrive.Stop();
break;
case "Befehle":
await AudioPlayerController.Play(AudioName.Befehl);
break;
case "Steuerungsbefehle":
await AudioPlayerController.Play(AudioName.Steuerungsbefehle);
break;
case "Systembefehle":
await AudioPlayerController.Play(AudioName.Systembefehle);
break;
case "Starte Dich neu":
case "Neustarten":
await AudioPlayerController.PlayAndWaitAsync(AudioName.ReallyRestart);
_shouldRestart = DateTime.Now;
_shouldShutdown = null;
break;
case "Schalte Dich aus":
case "Auschalten":
await AudioPlayerController.PlayAndWaitAsync(AudioName.ReallyShutdown);
_shouldShutdown = DateTime.Now;
_shouldRestart = null;
break;
case "Nein":
_shouldRestart = null;
_shouldShutdown = null;
break;
case "Ja":
if (_shouldShutdown.HasValue && DateTime.Now <= _shouldShutdown.Value.AddSeconds(15))
{
await SystemController.Shutdown();
}
else if (_shouldRestart.HasValue && DateTime.Now <= _shouldRestart.Value.AddSeconds(15))
{
await SystemController.Restart();
}
_shouldRestart = null;
_shouldShutdown = null;
break;
case "Aktiviere Lautsprecher":
await AudioPlayerController.SetAllSpeakerOnOff(true);
break;
case "Deaktiviere Lautsprecher":
await AudioPlayerController.SetAllSpeakerOnOff(false);
break;
case "Aktiviere Headset Lautsprecher":
await AudioPlayerController.SetHeadsetSpeakerOnOff(true);
break;
case "Deaktiviere Headset Lautsprecher":
await AudioPlayerController.SetHeadsetSpeakerOnOff(false);
break;
case "Aktiviere Fahrzeug Lautsprecher":
await AudioPlayerController.SetCarSpeakerOnOff(true);
break;
case "Deaktiviere Fahrzeug Lautsprecher":
await AudioPlayerController.SetCarSpeakerOnOff(false);
break;
case "Aktiviere Sound Modus":
await AudioPlayerController.SetSoundModeOnOff(true);
break;
case "Deaktiviere Sound Modus":
await AudioPlayerController.SetSoundModeOnOff(false);
break;
case "Lautsprecher und Sound Modus":
await AudioPlayerController.PlaySpeakerOnOffSoundMode();
break;
}
if (recognation != "Starte Dich neu" &&
recognation != "Neustarten" &&
recognation != "Schalte Dich aus" &&
recognation != "Auschalten")
{
_shouldRestart = null;
_shouldShutdown = null;
}
if (_isStopped)
{
StopInternal();
}
}
private async Task StartInternal()
{
_isStopped = false;
var random = new Random();
var randomMinutes = 0;
DateTime?turnLeftStart = null;
var turnLeftSpoken = false;
DateTime?turnRightStart = null;
var turnRightSpoken = false;
var turns = new List <double>();
while (!_stopping)
{
var acceleration = _accelerometer.ReadLinearAcceleration();
var carpetVibration = 0.2;
var vibrationSpeed = (((Math.Abs(acceleration.AccelerationX) + Math.Abs(acceleration.AccelerationY) + Math.Abs(acceleration.AccelerationZ))) / 3) - carpetVibration;
turns.Add(acceleration.GyroZ);
if (turns.Count >= 20)
{
var turnLeft = turns.Max() >= 60;
var turnRight = turns.Min() <= -60;
if (turnLeft &&
!turnLeftStart.HasValue &&
!turnLeftSpoken)
{
turnLeftStart = DateTime.Now;
}
else if (!turnLeft)
{
turnLeftSpoken = false;
turnLeftStart = null;
}
if (turnRight &&
!turnRightStart.HasValue &&
!turnRightSpoken)
{
turnRightStart = DateTime.Now;
}
else if (!turnRight)
{
turnRightSpoken = false;
turnRightStart = null;
}
turns.Clear();
}
if ((CarMoveCommand?.Speed == 0 || CarMoveCommand?.Speed == null) &&
!_carNotMoving.HasValue)
{
_carNotMoving = DateTime.Now;
randomMinutes = random.Next(3, 5);
}
else if (CarMoveCommand != null && CarMoveCommand.Speed > 0)
{
_carNotMoving = null;
}
//Car not moving to long
if (_carNotMoving.HasValue &&
DateTime.Now >= _carNotMoving.Value.AddMinutes(randomMinutes))
{
await AudioPlayerController.PlayAndWaitAsync(AudioName.Steht);
_carNotMoving = null;
}
//Strong car vibration
else if (vibrationSpeed >= 0.35)
{
await AudioPlayerController.PlayAndWaitAsync(AudioName.StarkeVibration);
}
//Turn to long left
else if (turnLeftStart.HasValue &&
DateTime.Now >= turnLeftStart.Value.AddSeconds(5))
{
turnLeftStart = null;
turnLeftSpoken = true;
await AudioPlayerController.PlayAndWaitAsync(AudioName.TurnToLongLeft);
}
//Turn to long right
else if (turnRightStart.HasValue &&
DateTime.Now >= turnRightStart.Value.AddSeconds(5))
{
turnRightStart = null;
turnRightSpoken = true;
await AudioPlayerController.PlayAndWaitAsync(AudioName.TurnToLongRight);
}
await Task.Delay(10);
}
_isStopped = true;
}
private async Task StartGamepadReading(Gamepad gamepad)
{
_isGamepadReadingStopped = false;
var buttonDownTimeMiddle = TimeSpan.FromSeconds(2);
var buttonDownTimeLong = TimeSpan.FromSeconds(5);
var viewButton = new GamepadButtonDown(TimeSpan.Zero, GamepadButtons.View);
var menuButton = new GamepadButtonDown(TimeSpan.Zero, GamepadButtons.Menu);
var dPadUpButton = new GamepadButtonDown(buttonDownTimeMiddle, GamepadButtons.DPadUp);
var dPadDownButton = new GamepadButtonDown(buttonDownTimeMiddle, GamepadButtons.DPadDown);
var dPadLeftButton = new GamepadButtonDown(buttonDownTimeMiddle, GamepadButtons.DPadLeft);
var dPadRightButton = new GamepadButtonDown(buttonDownTimeMiddle, GamepadButtons.DPadRight);
var yButton = new GamepadButtonDown(buttonDownTimeMiddle, GamepadButtons.Y);
var bButton = new GamepadButtonDown(buttonDownTimeMiddle, GamepadButtons.B);
var xRightShoulderButton = new GamepadButtonDown(buttonDownTimeLong, GamepadButtons.X, GamepadButtons.RightShoulder);
var aRightShoulderButton = new GamepadButtonDown(buttonDownTimeLong, GamepadButtons.A, GamepadButtons.RightShoulder);
var xRightShoulderButtonNotClickableButtons = new List <GamepadButtons>
{
GamepadButtons.Y
};
var aRightShoulderButtonNotClickableButtons = new List <GamepadButtons>
{
GamepadButtons.X
};
var dPadUpNotClickableButtons = new List <GamepadButtons>
{
GamepadButtons.DPadDown,
GamepadButtons.DPadLeft,
GamepadButtons.DPadRight
};
var dPadDownNotClickableButtons = new List <GamepadButtons>
{
GamepadButtons.DPadUp,
GamepadButtons.DPadLeft,
GamepadButtons.DPadRight
};
var dPadLeftNotClickableButtons = new List <GamepadButtons>
{
GamepadButtons.DPadUp,
GamepadButtons.DPadDown,
GamepadButtons.DPadRight
};
var dPadRightNotClickableButtons = new List <GamepadButtons>
{
GamepadButtons.DPadUp,
GamepadButtons.DPadDown,
GamepadButtons.DPadLeft
};
while (_gamepad == gamepad)
{
//gamepad variable could be null
var gamepadReadingTry = gamepad?.GetCurrentReading();
if (!gamepadReadingTry.HasValue)
{
break;
}
var gamepadReading = gamepadReadingTry.Value;
var carMoveCommand = new CarMoveCommand(gamepadReading);
var carControlCommand = new CarControlCommand(gamepadReading);
//Move car and servo if is new command available
if (!(_carStopped &&
carMoveCommand.Speed == 0.0 &&
!carControlCommand.DirectionControlUp &&
!carControlCommand.DirectionControlDown))
{
_carStopped = false;
_motorController.MoveCar(null, carMoveCommand);
_servoController.MoveServo(carControlCommand);
}
//Car and servo not moving
if (carMoveCommand.Speed == 0.0 &&
!carControlCommand.DirectionControlUp &&
!carControlCommand.DirectionControlDown)
{
_carStopped = true;
}
// Enable/ disable gamepad vibration
var viewButtonResult = viewButton.UpdateGamepadButtonState(gamepadReading);
if (viewButtonResult.ButtonClicked)
{
_gamepadShouldVibrate = !_gamepadShouldVibrate;
if (_gamepadShouldVibrate)
{
await AudioPlayerController.Play(AudioName.GamepadVibrationOn);
}
else
{
await AudioPlayerController.Play(AudioName.GamepadVibrationOff);
}
}
//Automatic drive toggle
var menuButtonResult = menuButton.UpdateGamepadButtonState(gamepadReading);
if (menuButtonResult.ButtonClicked)
{
await _automaticDrive.StartStopToggle();
}
var dPadUpButtonResult = dPadUpButton.UpdateGamepadButtonState(gamepadReading, dPadUpNotClickableButtons);
var dPadDownButtonResult = dPadDownButton.UpdateGamepadButtonState(gamepadReading, dPadDownNotClickableButtons);
var dPadLeftButtonResult = dPadLeftButton.UpdateGamepadButtonState(gamepadReading, dPadLeftNotClickableButtons);
var dPadRightButtonResult = dPadRightButton.UpdateGamepadButtonState(gamepadReading, dPadRightNotClickableButtons);
//All speaker on
if (dPadUpButtonResult.ButtonClicked)
{
await AudioPlayerController.SetAllSpeakerOnOff(true);
}
//All speaker off
if (dPadDownButtonResult.ButtonClicked)
{
await AudioPlayerController.SetAllSpeakerOnOff(false);
}
//Car speaker on/off toggle
if (dPadLeftButtonResult.ButtonClicked)
{
await AudioPlayerController.SetCarSpeakerOnOffToggle();
}
//Headset speaker on/off toggle
if (dPadRightButtonResult.ButtonClicked)
{
await AudioPlayerController.SetHeadsetSpeakerOnOffToggle();
}
//Sound mode on/off toggle
var yButtonResult = yButton.UpdateGamepadButtonState(gamepadReading);
if (yButtonResult.ButtonClicked)
{
await AudioPlayerController.SetSoundModeOnOffToggle();
}
//Speak current speaker and sound mode state
var bButtonResult = bButton.UpdateGamepadButtonState(gamepadReading);
if (bButtonResult.ButtonClicked)
{
await AudioPlayerController.PlaySpeakerOnOffSoundMode();
}
//Shutdown
var xRightShoulderButtonResult = xRightShoulderButton.UpdateGamepadButtonState(gamepadReading, xRightShoulderButtonNotClickableButtons);
if (xRightShoulderButtonResult.ButtonClicked)
{
_isGamepadReadingStopped = true;
await SystemController.Shutdown();
}
//Restart
var aRightShoulderButtonResult = aRightShoulderButton.UpdateGamepadButtonState(gamepadReading, aRightShoulderButtonNotClickableButtons);
if (aRightShoulderButtonResult.ButtonClicked)
{
_isGamepadReadingStopped = true;
await SystemController.Restart();
}
await Task.Delay(25);
}
_isGamepadReadingStopped = true;
}
void Start()
{
data = FindObjectOfType <GameData>();
audio = FindObjectOfType <AudioPlayerController>();
}
