public TrainerWindow()
{
InitializeComponent();
_jsonSettingsIo = new JsonSettingsIO();
_trainingProgressBox = new TrainingProgressBox(TrainingProgressTextBlock);
_sessionStatistics = new SessionStatistics(this);
_dispatcherTimer = new DispatcherTimer
{
Interval = TimeSpan.FromMinutes(5)
};
_dispatcherTimer.Tick += (sender, args) => TriggerAutoSave();
TrainerViewModel = new TrainerViewModel
{
TrainingGameSettings = _jsonSettingsIo.ReadTrainingGameSettings(),
ExperimentSettings = _jsonSettingsIo.ReadExperimentSettings(),
NeatEvolutionAlgorithmParameters = _jsonSettingsIo.ReadEvolutionAlgorithmParameters()
};
DataContext = TrainerViewModel;
_trainingState = TrainingState.Uninitialised;
_settingsMinimised = false;
}
////////////////////////////////////////////////////////////////////
private void Initialize()
{
if (mainMenuState != null)
{
return;
}
mainMenuState = new MainMenuState();
if (multiplayerState != null)
{
return;
}
multiplayerState = new MultiplayerState();
if (trainingState != null)
{
return;
}
trainingState = new TrainingState();
if (trainingSettingsState != null)
{
return;
}
trainingSettingsState = new TrainingSettingsState();
}
public void SendStateUpdate(TrainingState state)
{
TrainingMessage message = new TrainingMessage();
message.type = "state";
message.payload = JsonUtility.ToJson(state);
SendMessage(message);
}
private void Awake()
{
manager = GetComponent <TrainingManager>();
worker = GetComponent <TrainingWorker>();
state = new TrainingState();
worker.OnTrainingFrame += OnTrainingFrame;
worker.OnTrainingRequestComplete += OnTrainingRequestComplete;
}
private void checkPower(Measurement meas)
{
if (meas.Hartslag > chooser.maxHeartRate)
{
state = TrainingState.STOP;
SetText(TrainingStateLabel, "Test stop");
setWarning("WANRING: Heartrate too high");
}
else if (meas.Hartslag <= 130 && meas.Time.Seconds == 0)
{
if (wishedPower != currentPower || wishedPower >= 200)
{
return;
}
if (_isMan)
{
wishedPower += 50;
}
else
{
wishedPower += 25;
}
}
else
{
if (wishedPower != currentPower || wishedPower >= 200)
{
return;
}
if (meas.Rondes < 50)
{
if (_isMan)
{
wishedPower -= 25;
}
else
{
wishedPower -= 12;
}
}
else if (meas.Rondes > 60)
{
if (_isMan)
{
wishedPower += 25;
}
else
{
wishedPower += 12;
}
}
}
}
public void PauseTraining()
{
CurrentTrainingState = TrainingState.Paused;
trainingHelper.CurrentTrainingState = TrainingState.Paused;
var button = FindViewById(Resource.Id.button_training_left);
var layoutParams = (RelativeLayout.LayoutParams)button.LayoutParameters;
layoutParams.AddRule(LayoutRules.CenterInParent, 0);
button.LayoutParameters = layoutParams;
FindViewById(Resource.Id.button_training_left).Visibility = ViewStates.Visible;
FindViewById(Resource.Id.button_training_right).Visibility = ViewStates.Visible;
FindViewById <ImageButton>(Resource.Id.button_training_left).SetImageResource(Resource.Drawable.btn_training_start);
}
public void EndTraining()
{
trainingHelper.SaveTraining(CurrentTrainingType, TrainingStartDate, TrainingDistance, TrainingTime);
trainingHelper.Reset();
CurrentTrainingState = TrainingState.NotStarted;
ResetTrainingStatistics();
trainingHelper.CurrentTrainingState = TrainingState.NotStarted;
var button = FindViewById(Resource.Id.button_training_left);
var layoutParams = (RelativeLayout.LayoutParams)button.LayoutParameters;
layoutParams.AddRule(LayoutRules.CenterInParent, 1);
button.LayoutParameters = layoutParams;
FindViewById(Resource.Id.button_training_left).Visibility = ViewStates.Visible;
FindViewById(Resource.Id.button_training_right).Visibility = ViewStates.Gone;
FindViewById <ImageButton>(Resource.Id.button_training_left).SetImageResource(Resource.Drawable.btn_training_start);
}
public void StartTraining()
{
TrainingTime = 0;
TrainingDistance = 0;
TrainingStartDate = DateTime.Now;
trainingHelper.Reset();
CurrentTrainingState = TrainingState.Started;
trainingHelper.CurrentTrainingState = TrainingState.Started;
var button = FindViewById(Resource.Id.button_training_left);
var layoutParams = (RelativeLayout.LayoutParams)button.LayoutParameters;
layoutParams.AddRule(LayoutRules.CenterInParent, 1);
button.LayoutParameters = layoutParams;
FindViewById(Resource.Id.button_training_left).Visibility = ViewStates.Visible;
FindViewById(Resource.Id.button_training_right).Visibility = ViewStates.Gone;
FindViewById <ImageButton>(Resource.Id.button_training_left).SetImageResource(Resource.Drawable.btn_training_pause);
}
/**
* Initialise attribues used by both constructors.
*/
private void Initialise(string name, AddTraining addTraining)
{
// Some needed attributes
currentPower = 20;
wishedPower = 50;
measurements = new List <Measurement>();
_name = name;
_addTraining = addTraining;
heartRates = new List <int>();
var message = Login.Handler.GetAge(name);
_age = (int)message.data.age;
_isMan = (bool)message.data.isman;
chooser = new TrainingChooser(_age, _isMan);
state = TrainingState.START;
runThread = new Thread(React);
runThread.Start();
}
private void ResetState()
{
if (_trainingState == TrainingState.Paused)
{
_trainingProgressBox.WriteLine("Destroying previous session...");
_sessionStatistics.Reset();
}
_neatTrainer = null;
_trainingState = TrainingState.Uninitialised;
}
/**
* During a test this function is called every 1000 ms. (so, this
* is the from where the logic for the test should be implemented).
*/
private void React()
{
while (true)
{
try
{
bool giveMeas = true;
//Changed the write and read line to send and receive command
connection.StartBicycle();
Measurement meas = null;
if (state != TrainingState.STOP)
{
var temp = connection.ReceiveCommand();
if (temp == "RUN\r" && temp == "ACK\r")
{
giveMeas = false;
}
else
{
meas = ParseMeasurement(temp);
}
}
if (meas != null && meas.Time.Seconds % 5 == 0 && !meas.Time.ToString().Equals("00:00"))
{
if (currentPower > wishedPower)
{
currentPower -= 5;
connection.ChangePower($"{currentPower}");
}
else if (currentPower < wishedPower)
{
currentPower += 5;
connection.ChangePower($"{currentPower}");
}
}
switch (state)
{
case TrainingState.START:
if (meas.Rondes == 0)
{
giveMeas = false;
break;
}
SetText(TrainingStateLabel, "Warming up");
state = TrainingState.WARMINGUP;
connection.ChangePower($"{currentPower}");
break;
case TrainingState.WARMINGUP:
if (meas.Time.Seconds == 0)
{
heartRates.Add(meas.Hartslag);
}
if (meas.Time.Minutes == 2)
{
wishedPower = 50;
state = TrainingState.REALTEST;
SetText(TrainingStateLabel, "Test");
}
break;
case TrainingState.REALTEST:
if (meas.Time.Seconds % 5 == 0)
{
checkPower(meas);
}
if (meas.Time.Minutes == 5)
{
if (meas.Time.Seconds % 15 == 0)
{
heartRates.Add(meas.Hartslag);
}
}
else
{
if (meas.Time.Seconds == 0)
{
heartRates.Add(meas.Hartslag);
}
}
if (meas.Time.Minutes == 6)
{
SetText(TrainingStateLabel, "Cooling down");
state = TrainingState.COOLINGDOWN;
double vo2 = chooser.CalculateVo2(heartRates, wishedPower);
if (vo2 == -1)
{
setWarning("Can't calculate vo2, average heartrate too low");
Login.Handler.SendVo2(_name, vo2);
}
else
{
setWarning($"Vo2 calculated: {vo2:##.00}");
Login.Handler.SendVo2(_name, vo2);
}
if (wishedPower > 100)
{
wishedPower -= 50;
}
else
{
wishedPower = 50;
}
}
break;
case TrainingState.COOLINGDOWN:
if (meas.Time.Minutes == 7)
{
SetText(TrainingStateLabel, "Test stop");
state = TrainingState.STOP;
}
break;
case TrainingState.STOP:
giveMeas = false;
break;
}
if (giveMeas)
{
measurements.Add(meas);
}
Thread.Sleep(1000);
}
catch (Exception exception)
{
Console.WriteLine(exception.StackTrace);
Thread.Sleep(1000);
}
}
}
private void Awake()
{
manager = GetComponentInParent <TrainingManager>();
avatars = new List <GameObject>();
state = new TrainingState();
}
private void TriggerAutoSave()
{
if (_trainingState != TrainingState.Training)
{
return;
}
_trainingState = TrainingState.AutoSaving;
_trainingProgressBox.WriteLine("Auto Save: Pausing training...");
_neatTrainer.StopTraining();
}
private void PauseTraining()
{
_trainingState = TrainingState.AwaitingPause;
_neatTrainer.StopTraining();
}
public TrainingHelper(GoogleMap map, TrainingState state)
{
Map = map;
CurrentTrainingState = state;
}
private protected override bool GetStateHelper(TransformerEstimatorSafeHandle estimator, out TrainingState trainingState, out IntPtr errorHandle) => GetStateNative(estimator, out trainingState, out errorHandle);
private static extern bool GetStateNative(TransformerEstimatorSafeHandle estimator, out TrainingState trainingState, out IntPtr errorHandle);
private protected abstract bool GetStateHelper(TransformerEstimatorSafeHandle estimator, out TrainingState trainingState, out IntPtr errorHandle);
private void CreateSessionButton_Click(object sender, RoutedEventArgs e)
{
if (_trainingState == TrainingState.AutoSaving)
{
_trainingProgressBox.WriteLine("Please wait for auto save to complete.");
return;
}
if (!(_trainingState == TrainingState.Paused || _trainingState == TrainingState.Uninitialised))
{
_trainingProgressBox.WriteLine("Please pause the current session before creating a new one.");
return;
}
_trainingProgressBox.Clear();
ResetState();
if (!ValidateFields())
{
_trainingProgressBox.WriteLine("Could not create session. Please fix the invalid configuration settings.");
return;
}
_neatTrainer = CreateTrainingSession();
_trainingState = TrainingState.Paused;
_trainingProgressBox.WriteLine("Created a new training session.");
}
public TrainingStateEventArgs(TrainingState trainingState)
{
_trainingState = trainingState;
}
protected void OnTrainingStateChanged(TrainingState trainingState)
{
if (TrainingStateChanged != null)
{
TrainingStateChanged(this, new TrainingStateEventArgs(trainingState));
}
}
private NeatTrainer CreateTrainingSession()
{
var neatTrainer = new NeatTrainer(TrainerViewModel.ExperimentSettings, TrainerViewModel.NeatEvolutionAlgorithmParameters, TrainerViewModel.TrainingGameSettings);
neatTrainer.OnStatusUpdate += (generation, highestFitness, averageFitness) =>
{
if (_trainingState == TrainingState.AwaitingTraining)
{
_trainingState = TrainingState.Training;
}
_sessionStatistics.CurrentGeneration = generation;
_sessionStatistics.CurrentAverageFitness = averageFitness;
_trainingProgressBox.WriteStatusUpdate(generation, highestFitness, averageFitness);
};
neatTrainer.OnTrainingPaused += () =>
{
_sessionStatistics.StopTimer();
_dispatcherTimer.Stop();
if (_trainingState == TrainingState.AutoSaving)
{
PerformAutoSave();
}
else
{
_trainingState = TrainingState.Paused;
_trainingProgressBox.WriteLine("Training paused.");
}
};
var stagnationDetectedMessage =
$"Stagnation detected: Previous {TrainerViewModel.ExperimentSettings.StagnationDetectionTriggerValue} generations had the same fitness value.";
if (TrainerViewModel.ExperimentSettings.StopTrainingOnStagnationDetection)
{
neatTrainer.OnStagnationDetected += () =>
{
OnStagnationDetected(stagnationDetectedMessage);
if (_trainingState == TrainingState.Training)
{
_trainingProgressBox.WriteLine("Auto stop enabled, training will now be paused...");
PauseTraining();
}
};
}
else
{
neatTrainer.OnStagnationDetected += () => OnStagnationDetected(stagnationDetectedMessage);
}
neatTrainer.OnHighestFitnessAchieved += fitness =>
{
_sessionStatistics.OverallHighestFitness = fitness;
};
neatTrainer.OnDesiredFitnessAchieved += () =>
{
_sessionStatistics.DesiredFitnessAchieved = true;
_trainingProgressBox.WriteLine("Desired fitness has been achieved.");
};
return neatTrainer;
}
private void StartTraining()
{
_trainingState = TrainingState.AwaitingTraining;
Task.Run(() => _neatTrainer.StartTraining());
_sessionStatistics.StartTimer();
_dispatcherTimer.Start();
}
