private void ProcessPacket(OSCPacket packet)
{
foreach (OSCPacket p in packet.Data)
{
if (p.IsBundle())
{
ProcessPacket(p);
}
else
{
OSCMessage msg = (OSCMessage)p;
if ((EyesStatus)msg.Extra != EyesStatus.NONE)
{
Status = (EyesStatus)msg.Extra;
}
if (msg.Address == "/muse/elements/alpha_absolute")
{
if (!Training || (Training && alphaIgnore == 0 && keepTrainingData))
{
if (alphaSet)
{
alpha2 = (float)msg.Data[0];
alphaSet = false;
if (prevStatus == Status)
{
TrainingValue trainingValue = new TrainingValue((int)Status, 2);
trainingValue.Features[0] = alpha1;
trainingValue.Features[1] = alpha2;
AlphaTrainingValues.Add(trainingValue);
}
}
else
{
alpha1 = (float)msg.Data[0];
alphaSet = true;
}
}
else if (Training && alphaIgnore != 0)
{
alphaIgnore--;
}
prevStatus = Status;
}
else if (msg.Address == "/muse/eeg")
{
tp9.Add((float)msg.Data[0]);
af7.Add((float)msg.Data[1]);
af8.Add((float)msg.Data[2]);
tp10.Add((float)msg.Data[3]);
}
}
}
}
// Use this for initialization
void Start()
{
Bomb[] a = bombsContainer.GetComponentsInChildren <Bomb> ();
bombs = new HashSet <Bomb> (a);
activeObjects = new HashSet <OutlineObject> ();
inactiveObjects = new HashSet <OutlineObject> (FindObjectsOfType <OutlineObject> ());
activeBombs = new HashSet <Bomb> ();
previousStatus = EyesStatus.NONE;
checkingTimer = new CounterTimer(checkingInterval);
zombies = new List <Zombie> (zombiesContainer.GetComponentsInChildren <Zombie> ());
}
public void Start()
{
while (true)
{
ConsoleKeyInfo k = Console.ReadKey();
if (k.Key == ConsoleKey.Spacebar)
{
if (!started)
{
Console.WriteLine("Started reading!");
status = EyesStatus.OPEN;
Console.WriteLine("Switched to eyes open");
started = true;
processingThread = new Thread(new ThreadStart(StartReading));
processingThread.Start();
}
else
{
if (status == EyesStatus.CLOSED)
{
Console.WriteLine("Switched to eyes open");
status = EyesStatus.OPEN;
}
else
{
Console.WriteLine("Switched to eyes closed");
status = EyesStatus.CLOSED;
}
}
}
else if (k.Key == ConsoleKey.F)
{
finished = true;
processingThread.Join();
string baseFilePath = Directory.GetCurrentDirectory();
baseFilePath += string.Format("/{0:yyyy-MM-dd_hh-mm-ss-tt}", DateTime.Now) + ".eeg";
Console.WriteLine("Saving to raw packets to: " + baseFilePath);
FileStream stream = File.OpenWrite(baseFilePath);
foreach (OSCPacket packet in packets)
{
byte[] bytes = packet.Pack();
stream.Write(BitConverter.GetBytes(bytes.Length), 0, 4);
stream.Write(bytes, 0, bytes.Length);
}
stream.Close();
return;
}
}
}
public void Reset()
{
af7.Clear();
af8.Clear();
tp9.Clear();
tp10.Clear();
TrainingValues.Clear();
AlphaTrainingValues.Clear();
trainer = null;
training = false;
readingsMean.Clear();
status = EyesStatus.NONE;
ignore = SKIP;
}
private void RunFFT()
{
readingsMean.Clear();
for (int i = 0; i < af7.Count; i++)
{
readingsMean.Add(af7[i] + tp9[i] + tp10[i] + af8[i] / FEATURE_COUNT);
}
CalculateFFT(readingsMean, FFTResults);
CalculateFFT(af7, AF7FFT);
CalculateFFT(af8, AF8FFT);
CalculateFFT(tp9, TP9FFT);
CalculateFFT(tp10, TP10FFT);
if (!Training || (Training && ignore == 0))
{
TrainingValue trainingValue = new TrainingValue((int)Status, FEATURE_COUNT);
trainingValue.Features[0] = PSD(TP9FFT, FREQ_STEP);
trainingValue.Features[1] = PSD(AF7FFT, FREQ_STEP);
trainingValue.Features[2] = PSD(AF8FFT, FREQ_STEP);
trainingValue.Features[3] = PSD(TP10FFT, FREQ_STEP);
if (!Training && trainer != null && trainer.Trained)
{
Status = (EyesStatus)trainer.Predict(trainingValue);
}
if (training || keepTrainingData)
{
TrainingValues.Add(trainingValue);
}
}
else if (Training && ignore != 0)
{
ignore--;
}
}
// Update is called once per frame
void Update()
{
if (!started)
{
processorContainer = FindObjectOfType <ProcessorContainer> ();
if ((processorContainer != null && processorContainer.processor != null))
{
EEGManager.Instance.Processor = processorContainer.processor;
EEGManager.Instance.Trained = true;
Status = GameStatus.Playing;
}
else
{
Status = GameStatus.Training;
}
started = true;
}
switch (status)
{
case GameStatus.Playing:
if (Input.GetKeyDown(KeyCode.P))
{
Status = GameStatus.Paused;
return;
}
if (player.health <= 0)
{
Status = GameStatus.GameOver;
return;
}
EyesStatus status = EEGManager.Instance.Status;
if (status == EyesStatus.CLOSED)
{
if (previousStatus == EyesStatus.OPEN)
{
visibilityOn = false;
foreach (OutlineObject visibleObject in activeObjects)
{
visibleObject.Outline = false;
}
inactiveObjects.UnionWith(activeObjects);
activeObjects.Clear();
}
visibilityTime += Time.deltaTime;
if (checkingTimer.Finished)
{
checkingTimer.Reset();
foreach (Bomb bomb in bombs)
{
float distance = Vector3.Distance(player.transform.position, bomb.transform.position);
if (distance <= hearingDistance)
{
if (!activeBombs.Contains(bomb))
{
bomb.PlayBeepSound();
activeBombs.Add(bomb);
}
}
else
{
if (activeBombs.Contains(bomb))
{
activeBombs.Remove(bomb);
bomb.StopPlaying();
}
}
}
foreach (OutlineObject inactiveObject in inactiveObjects)
{
float distance = Vector3.Distance(player.transform.position, inactiveObject.transform.position);
if (distance <= hearingDistance)
{
activeObjects.Add(inactiveObject);
}
}
inactiveObjects.RemoveWhere(x => activeObjects.Contains(x));
}
}
else
{
foreach (Bomb bomb in activeBombs)
{
bomb.StopPlaying();
}
activeBombs.Clear();
if (previousStatus == EyesStatus.CLOSED)
{
visibilityTimer = new CounterTimer(Mathf.Min(visibilityTime + EEGManager.Instance.minThreshold, maxVisibilityDuration));
foreach (OutlineObject activeObject in activeObjects)
{
activeObject.Outline = true;
}
visibilityOn = true;
}
else
{
if (visibilityOn && visibilityTimer.Finished)
{
visibilityOn = false;
foreach (OutlineObject activeObject in activeObjects)
{
activeObject.Outline = false;
}
inactiveObjects.UnionWith(activeObjects);
activeObjects.Clear();
}
}
if (visibilityOn)
{
visibilityTimer.Update(Time.deltaTime);
}
visibilityTime = 0;
}
previousStatus = status;
checkingTimer.Update(Time.deltaTime);
break;
case GameStatus.Paused:
if (Input.GetKeyDown(KeyCode.P))
{
Status = GameStatus.Playing;
return;
}
break;
case GameStatus.Training:
if (Input.GetKey(KeyCode.K))
{
EEGManager.Instance.StopTraining();
}
break;
default:
break;
}
}
