private void Update()
{
if (GameControl.Button1Count > 0 && GameControl.Button2Count > 0 && GameControl.Button3Count > 0 && GameControl.Button4Count > 0 && GameControl.Button5Count > 0)
{
//send stop message
serialController.SendSerialMessage("s");
SceneManager.LoadScene("PressButton");
}
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
InputHandler(message);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown("space"))
{
zeroize();
}
//string in format "val, val, val,"
string msg = scComp.ReadSerialMessage().Substring(1);
//Debug.Log("The serial input is " + msg);
string txtVal = msg.Split(',')[2];
float value = float.Parse(txtVal);
Debug.Log("value: " + value);
//Kind of percentage of 90degrees but, divided by 100 to make it a reasonable amount
float moveAmount = 0;
if (value > 0)
{
moveAmount = -(value - 180) / 90;
}
else
{
moveAmount = -(value + 180) / 90;
}
Debug.Log("moveAmount: " + moveAmount);
//lastReading = moveAmount;//Addition
// Debug.Log("Input: " + txtVal + ", roadPos: " + gameObject.transform.position.x);
if (gameObject.transform.position.x - 1 + moveAmount > 4.7)
{
//hit left wall
}
else if (gameObject.transform.position.x - 1 + moveAmount < -4.7)
{
//hit right wall
}
else
{
transform.Translate(new Vector3(moveAmount, 0, 0));
}
//Debug.Log("Got past if");
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Send data
//---------------------------------------------------------------------
// If you press one of these keys send it to the serial device. A
// sample serial device that accepts this input is given in the README.
if (Input.GetKeyDown(KeyCode.A))
{
Debug.Log("Sending A");
serialController.SendSerialMessage("A");
}
if (Input.GetKeyDown(KeyCode.Z))
{
Debug.Log("Sending Z");
serialController.SendSerialMessage("Z");
}
if (Input.GetKeyDown(KeyCode.K))
{
Debug.Log("Turning off the lights.");
serialController.SendSerialMessage("K");
}
if (Input.GetKeyDown(KeyCode.L))
{
Debug.Log("Let there be light");
serialController.SendSerialMessage("L");
}
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
}
private string ReceiveMessage()
{
if (serialController.enabled == false)
{
return(null);
}
return(serialController.ReadSerialMessage());
}
// Update is called once per frame
void Update()
{
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
if (message == "up" || message == "right" || message == "down" || message == "left")
{
playerInput.input = message;
}
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Send data
//---------------------------------------------------------------------
// If you press one of these keys send it to the serial device. A
// sample serial device that accepts this input is given in the README.
if (Input.GetKeyDown(KeyCode.A))
{
Debug.Log("Sending A");
serialController.SendSerialMessage("A");
// serialController.SendSerialMessage("1.75"); //test to send a string --worked
Vector3 sd = new Vector3(1.2f, 1.6f, 1.5f);
string ty = sd.ToString();
serialController.SendSerialMessage(ty); //test to send a vector --worked.
}
if (Input.GetKeyDown(KeyCode.Z))
{
Debug.Log("Sending Z");
serialController.SendSerialMessage("Z");
}
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Send data
//---------------------------------------------------------------------
// If you press one of these keys send it to the serial device. A
// sample serial device that accepts this input is given in the README.
if (GetComponent <ObjectDetect>().triggerSignal != prev)
{
if (GetComponent <ObjectDetect>().triggerSignal == false)
{
Debug.Log("Sending Z");
serialController.SendSerialMessage("Z");
}
else if (GetComponent <ObjectDetect>().triggerSignal == true)
{
Debug.Log("Sending A");
serialController.SendSerialMessage("A");
}
}
prev = GetComponent <ObjectDetect>().triggerSignal;
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
}
void getSensorsInputs()
{
message = serialController.ReadSerialMessage();
jump = false;
if (message == null)
{
return;
}
intMessage = int.Parse(message);
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
if (intMessage > 1000005 && intMessage < 1000025)
{
if (distance == 0)
{
distance = intMessage;
}
//Debug.Log("Distance: " + intMessage);
if (distance > intMessage)
{
jump = true;
Debug.Log("Jump" + "distance: " + distance + " intMessage: " + intMessage);
}
distance = intMessage;
return;
}
if (intMessage > 2000000 && intMessage < 3000000)
{
Debug.Log("Dead");
}
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Send dados
//---------------------------------------------------------------------
// If you press one of these keys send it to the serial device. A
// sample serial device that accepts this input is given in the README.
if (Input.GetKeyDown(KeyCode.Alpha1) || Input.GetKeyDown(KeyCode.Keypad1))
{
Debug.Log("Sending lights ON");
serialController.SendSerialMessage("1");
}
if (Input.GetKeyDown(KeyCode.Alpha2) || Input.GetKeyDown(KeyCode.Keypad2))
{
Debug.Log("Sending lights OFF");
serialController.SendSerialMessage("2");
}
//---------------------------------------------------------------------
// Receive dados
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain dados or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
}
// Executed each frame
void Update()
{
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
//if (debugLog) Debug.Log("Message arrived: " + message);
string selector = message[0].ToString();
int num = System.Int32.Parse(message.Substring(1));
if (debugLog)
{
Debug.Log("Message arrived: " + selector + " > " + num.ToString());
}
if (selector == "U")
{
oeCommonDataContainer.setArrInt(indexData, num);
}
if (selector == "L")
{
oeCommonDataContainer.setArrInt(indexData + 1, num);
}
if (selector == "T")
{
oeCommonDataContainer.setArrInt(indexData + 2, num);
}
}
}
// Use this for initialization
// void Start()
//{
// mySPort.Open();
//}
// Update is called once per frame
void Update()
{
rotateLeftVal1 = RotateL1.zangle + 90;
//print("rotateRLeftVal1: " + rotateLeftVal1);
rotateLeftVal2 = RotateL2.zangle + 90;
rotateLeftVal3 = RotateL3.zangle + 90;
rotateLeftVal4 = RotateL4.zangle + 90;
rotateRightVal1 = RotateR1.zangle + 90;
rotateRightVal2 = RotateR2.zangle + 90;
rotateRightVal3 = RotateR3.zangle + 90;
rotateRightVal4 = RotateR4.zangle + 90;
if (output == true)
{
writeValues();
}
//string serialValue = mySPort.ReadLine();
string serialValue = serialController.ReadSerialMessage();
string[] serialValues = serialValue.Split('&');
//print("serialValue " + serialValue);
if (serialValues.Length > 1)
{
string[] bendValues = serialValues[1].Split(',');
// for (int t = 0; t < 5; t++)
//print("bendValues " + bendValues[t]);
//float[] floatBendValues = new float[bendValues.Length];
for (int j = 0; j < (bendValues.Length); j++)
{
currentVals[j] = float.Parse(bendValues[j]);
}
}
if (Input.GetKeyDown("d"))
{
detach++;
detach = detach % 2;
}
}
// Update is called once per frame
void Update()
{
if (GameControl.Button1Count > 0 && GameControl.Button2Count > 0 && GameControl.Button3Count > 0 && GameControl.Button4Count > 0 && GameControl.Button5Count > 0)
{
if (GameControl.Animals.Count > 4)
{
for (int i = 0; i < 20; i++)
{
serialController.SendSerialMessage("1");
}
StartCoroutine(LoadNextScene(GameControl.CurrentAnimal + "Intro"));
}
else
{
StartCoroutine(LoadNextScene("Dog"));
}
}
// Debug.Log(GameControl.Button1Count > 0 && GameControl.Button2Count > 0 && GameControl.Button3Count > 0 && GameControl.Button4Count > 0 && GameControl.Button5Count > 0);
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
InputHandler(message);
}
void Update()
{
string message;
while (true)
{
message = serialController.ReadSerialMessage();
if (message == null)
{
break;
}
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
continue;
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
continue;
}
processMessage(message);
}
}
// Executed each frame
void Update()
{
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain dados or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
}
void FixedUpdate()
{
if (!isPlayerActive)
{
return;
}
serialController.SendSerialMessage("A");
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
//Debug.Log("Message arrived: " + message);
//Debug.Log("Message arrived: " + float.Parse(message, CultureInfo.InvariantCulture.NumberFormat));
myTransform.position = new Vector2(float.Parse(message, CultureInfo.InvariantCulture.NumberFormat), -4.4f);
}
CheckBounds();
}
// Executed each frame
void Update()
{
timer += Time.deltaTime;
//---------------------------------------------------------------------
// Send data
//---------------------------------------------------------------------
if (timer > timeBetweenSend)
{
serialController.SendSerialMessage(messageOUT);
timer = 0;
}
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(messageIN, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(messageIN, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + messageIN);
}
messageIN = message;
}
public void receiveMessage()
{
//Pulls data from serial command line of arduino
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
parseArduinoMessage(message);
}
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Send data
//---------------------------------------------------------------------
if (serialController.enabled)
{
// If you press one of these keys send it to the serial device. A
// sample serial device that accepts this input is given in the README.
if (Input.GetKeyDown(KeyCode.A))
{
Debug.Log("Sending A");
serialController.SendSerialMessage("A");
}
if (Input.GetKeyDown(KeyCode.Z))
{
Debug.Log("Sending Z");
serialController.SendSerialMessage("Z");
}
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
switch (message)
{
case "0":
SetCubeColor(Color.white);
startRotation(new Vector3(-1, -3, -4));
break;
case "1":
SetCubeColor(Color.blue);
break;
case "2":
SetCubeColor(Color.yellow);
break;
case "3":
SetCubeColor(Color.red);
break;
case "4":
SetCubeColor(Color.green);
break;
case "5":
SetCubeColor(Color.black);
break;
case "6":
startRotation(new Vector3(-1, -3, -4));
break;
case "7":
startRotation(new Vector3(2, 2, 2));
break;
default:
break;
}
}
}
void Update()
{
GameObject gameControllerObject = GameObject.FindGameObjectWithTag("GameController");
if (gameControllerObject != null)
{
gameController = gameControllerObject.GetComponent <Done_GameController>();
}
if (gameController == null)
{
Debug.Log("Cannot find 'GameController' script");
}
string message;
if (firsty == 0)
{
firsty = 1;
message = serialController.ReadSerialMessage();
if (message == null)
{
Debug.Log("Got nothing...");
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
}
else
{
//receive the message from Arduino
message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established...");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
if (double.TryParse(message, out dda))
{
if (dda != 0)
{
Debug.Log("Get the angle:" + dda);
}
}
else
{
// Debug.Log("error in the string..." + message + "||"); // receive some dirty data(maybe nothing), but wait to send...
}
}
}
// calculate the angle
z_collision = Done_GameController.z_collision; // get the z-coor of the collision
x_collision = Done_GameController.x_collision;
angle = Mathf.Acos(x_collision / radius) * 180 / 3.142;
if (z_collision < 0)
{
angle = 360 - angle;
}
delta_angle = angle - pre_angle; // + ccw - cw
if (delta_angle > 180)
{
delta_angle = delta_angle - 360;
}
else if (delta_angle < -180)
{
delta_angle = 360 + delta_angle;
}
/*LineRenderGameObject = GameObject.Find("line"); // draw the line before sending
* lineRenderer = (LineRenderer)LineRenderGameObject.GetComponent("LineRenderer");
* lineRenderer.SetPosition(0, new Vector3(0, 0, 0));
* lineRenderer.SetPosition(1, new Vector3(x_collision, 9.3f, z_collision));*/
// sending part...
if ((int)angle == 89)
{
// Debug.Log("Get a 89, sending 0...");
serialController.SendSerialMessage("0");
}
// send the data consistently...
string xx = (delta_angle).ToString("0.00"); // send the data, without end_sign...
serialController.SendSerialMessage(xx);
if (delta_angle != 0)
{
Debug.Log("sssending it:" + xx);
}
//Debug.Log("Send a x_cor & rr&angle&pre&delta: " + x_collision + "||" + radius + "||" + angle + "||" + pre_angle + "||" + delta_angle);
pre_angle = angle;
// end of caculate the angle
cur_pos = Done_Mover.cur_pos;
// if ((cur_pos[2] - z_collision) <= 0.3 && cur_pos[2]>=z_collision && cur_pos[2] != 0 ) // ready to send the crash message
{
// Debug.Log("now curpos2"+cur_pos[2]);
// serialController.SendSerialMessage("777");
// Debug.Log("already send it&zz:"+ cur_pos[2]+"||"+z_collision);
/* Debug.Log("Boom...");
* if (gameObject.tag == "Enemy")
* {
* Destroy(gameObject);
* }*/
}
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Sending data
//---------------------------------------------------------------------
// changing scenes
if (Input.GetKeyDown(KeyCode.A))
{
SendToArduino("SI");
}
if (Input.GetKeyDown(KeyCode.Z))
{
SendToArduino("SD");
}
if (Input.GetKeyDown(KeyCode.E))
{
SendToArduino("SA");
}
// triggering lianas
if (Input.GetKeyDown(KeyCode.Q))
{
SendToArduino("L0");
}
if (Input.GetKeyDown(KeyCode.S))
{
SendToArduino("L1");
}
if (Input.GetKeyDown(KeyCode.D))
{
SendToArduino("L2");
}
if (Input.GetKeyDown(KeyCode.F))
{
SendToArduino("L3");
}
if (Input.GetKeyDown(KeyCode.G))
{
ChangeScene(Scene.Idle, Transition.BigVictory);
}
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
}
private void Update()
{
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
InputHandler(message);
switch (GameControl.CurrentAnimal)
{
case "Bear":
if (videoPlayer.time == 10f)
{
serialController.SendSerialMessage("V");
serialController.SendSerialMessage("F");
}
if (videoPlayer.time == 11f)
{
serialController.SendSerialMessage("v");
serialController.SendSerialMessage("f");
}
break;
case "Elephant":
if (videoPlayer.time == 8.5f)
{
serialController.SendSerialMessage("V");
serialController.SendSerialMessage("f");
}
if (videoPlayer.time == 9f)
{
serialController.SendSerialMessage("v");
serialController.SendSerialMessage("f");
}
break;
case "Lion":
if (videoPlayer.time == 2f)
{
serialController.SendSerialMessage("V");
serialController.SendSerialMessage("F");
}
if (videoPlayer.time == 3f)
{
serialController.SendSerialMessage("v");
serialController.SendSerialMessage("f");
}
break;
}
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Send data
//---------------------------------------------------------------------
// If you press one of these keys send it to the serial device. A
// sample serial device that accepts this input is given in the README.
if (Input.GetKeyDown(KeyCode.A))
{
//Debug.Log("Sending A");
serialController.SendSerialMessage("A");
}
if (Input.GetKeyDown(KeyCode.Z))
{
//Debug.Log("Sending Z");
serialController.SendSerialMessage("Z");
}
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
int intMessage;
bool jump = false;
if (message == null)
{
return;
}
intMessage = int.Parse(message);
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else if (intMessage > 1000000 && intMessage < 2000000)
{
if (intMessage > 1000005 && intMessage < 1000025)
{
if (distance == 0)
{
distance = intMessage;
}
//Debug.Log("Distance: " + intMessage);
if (distance < intMessage)
{
jump = true;
Debug.Log("Jump" + "distance: " + distance + " intMessage: " + intMessage);
}
distance = intMessage;
}
}
else if (intMessage > 2000000 && intMessage < 3000000)
{
Debug.Log("KeyboardInput: " + intMessage);
}
else if (intMessage > 3000000 && intMessage < 4000000)
{
Debug.Log("Light: " + intMessage);
}
}
// Executed each frame
void Update()
{
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
messages = message.Split(" " [0]);
Debug.Log("Message: " + message);
if (message == "__Connected__" || message == "__Disconnected__")
{
Debug.Log("Trying to connect " + message);
return;
}
if (messages.Length > 0)
{
/*
* if (messages.Length>=3 && messages[3] == "0" && !clicking1)
* {
* clicking1 = true;
* //MouseDown ();
* }
* if (messages.Length >= 3 && messages[3] == "1" && clicking1)
* {
* clicking1 = false;
* //MouseUp ();
* }
*
* if (messages.Length >=4 && messages[4] == "0" && !clicking2)
* {
* clicking2 = true;
* //ButtonDown ();
* }
* if (messages.Length >= 4 && messages[4] == "1" && clicking2)
* {
* clicking2 = false;
* //ButtonUp ();
* }*/
oldRot = obj.eulerAngles;
obj.eulerAngles = new Vector3(-float.Parse(messages[2], CultureInfo.InvariantCulture.NumberFormat),
float.Parse(messages[0], CultureInfo.InvariantCulture.NumberFormat),
float.Parse(messages[1], CultureInfo.InvariantCulture.NumberFormat)) + initialRot.eulerAngles;
InputShot = float.Parse(messages[5], CultureInfo.InvariantCulture.NumberFormat);
if (messages.Length >= 5 && messages[5] == "0")
{
ShootInput = false;
}
if (messages.Length >= 5 && messages[5] == "1" && !ShootInput)
{
Debug.Log("ATIROUUUUUUUUUUUUUUUUUUUUUUUUUU " + InputShot);
Shooting.Shooting();
ShootInput = true;
}
}
message = string.Empty;
}
void Update()
{
if (manager.getIsSerialRFID())
{
RFID = serialControllerRFID.ReadSerialMessage();
if (RFID != null)
{
if (ReferenceEquals(RFID, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established RFID");
}
else if (ReferenceEquals(RFID, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + RFID);
if (RFID.Substring(0, 2) != "FF") // sometimes a tag comes too fast and its ID becomes FFFFFF
{
OnCostumeScanned(RFID); // scanned costume tags
}
}
}
}
if (manager.getIsSerialLED())
{
string message = serialControllerLED.ReadSerialMessage();
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established COM LED");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
}
// debug element combo
spell = manager.GetSpell();
keyboardControls();
// check if players are ready , if ready, setIsRitualStarted to true
if (manager.getIsRitualStarted() == false)
{
OnReadyUp();
}
// ritual, when 3 checkpoints are reached, set finish to true
if (manager.getIsRitualStarted() && (manager.getIsRitualFinished() == false))
{
OnRitual();
}
// Ending, only once: get spell from manager and send to phones
// MUST NOT set ritual finished to true, it will go to OnRitual again
if (manager.getIsRitualFinished() && onetimeEnding)
{
spell = manager.GetSpell();
// wifiNavAll("result");
wifiAll(spell);
StartCoroutine(Ending());
onetimeEnding = false;
}
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Send data
//---------------------------------------------------------------------
// If you press one of these keys send it to the serial device. A
// sample serial device that accepts this input is given in the README.
if (Input.GetKeyDown(KeyCode.K))
{
Debug.Log("Sending lights OFF");
serialController.SendSerialMessage("K");
}
if (Input.GetKeyDown(KeyCode.L))
{
Debug.Log("Sending lights ON");
serialController.SendSerialMessage("L");
}
if (Input.GetKeyDown(KeyCode.T))
{
Debug.Log("Testing serial");
serialController.SendSerialMessage("T");
}
if (Input.GetKeyDown(KeyCode.Plus) || Input.GetKeyDown(KeyCode.KeypadPlus))
{
Debug.Log("Incrementing Stepper Pulse");
serialController.SendSerialMessage("+");
}
if (Input.GetKeyDown(KeyCode.Minus) || Input.GetKeyDown(KeyCode.KeypadMinus))
{
Debug.Log("Decrementing Stepper Pulse");
serialController.SendSerialMessage("-");
}
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
OnMessageArrived(message);
}
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Send data
//---------------------------------------------------------------------
// If you press one of these keys send it to the serial device. A
// sample serial device that accepts this input is given in the README.
SteamVR_Controller.Device myController = SteamVR_Controller.Input((int)trackedObj.index);
bool triggerButtonDown;
triggerButtonDown = myController.GetPressDown(triggerButton);
if (triggerButtonDown && isRunning)
{
serialController.SendSerialMessage("Z");
isRunning = false;
}
else if (triggerButtonDown && !isRunning)
{
serialController.SendSerialMessage("1");
isRunning = true;
}
if (Input.GetKeyDown(KeyCode.A))
{
Debug.Log("Sending 1");
serialController.SendSerialMessage("1");
}
if (Input.GetKeyDown(KeyCode.Z))
{
Debug.Log("Sending Z");
serialController.SendSerialMessage("Z");
}
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established, port: " + serialController.portName);
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected, port: " + serialController.portName);
}
else
{
Debug.Log("Message arrived: " + message);
}
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else if (message == "1")
{
if (SceneManager.GetActiveScene().buildIndex == 0)
{
levelManager.LaadScene(2);
}
}
else if (message == "2")
{
if (SceneManager.GetActiveScene().buildIndex == 0)
{
levelManager.LaadVolgendeScene();
}
}
else if (message == "3")
{
if (SceneManager.GetActiveScene().buildIndex == 0)
{
levelManager.SpelAfsluiten();
}
if (SceneManager.GetActiveScene().buildIndex == 1)
{
levelManager.LaadScene(0);
}
}
else if (message == "A")
{
Debug.Log("Key A pressed");
}
else if (message == "4")
{
Debug.Log("Key 4 pressed");
}
else if (message == "5")
{
Debug.Log("Key 5 pressed");
}
else if (message == "6")
{
Debug.Log("Key 6 pressed");
}
else if (message == "B")
{
Debug.Log("Key B pressed");
}
else if (message == "7")
{
Debug.Log("Key 7 pressed");
}
else if (message == "8")
{
Debug.Log("Key 8 pressed");
}
else if (message == "9")
{
Debug.Log("Key 9 pressed");
}
else if (message == "C")
{
Debug.Log("Key C pressed");
}
else if (message == "*")
{
Debug.Log("Key * pressed");
}
else if (message == "0")
{
Debug.Log("Key 0 pressed");
}
else if (message == "#")
{
Debug.Log("Key # pressed");
}
else if (message == "D")
{
Debug.Log("Key D pressed");
}
}
public void StartSpawning()
{
message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
intMessage = int.Parse(message);
//// Check if the message is plain data or a connect/disconnect event.
//if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
// Debug.Log("Connection established");
//else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
// Debug.Log("Connection attempt failed or disconnection detected");
Debug.Log("Taha");
if (intMessage >= 4000000 && intMessage < 5000000)
{
caseSwitch = intMessage - 4000000;
switch (caseSwitch)
{
case 0:
spawnTime = 0.5f;
Debug.Log("Poteniometer: 0.5f");
break;
case 1:
spawnTime = 1.0f;
Debug.Log("Poteniometer: 1.0f");
break;
case 2:
spawnTime = 1.5f;
Debug.Log("Poteniometer: 1.5f");
break;
case 3:
spawnTime = 2.0f;
Debug.Log("Poteniometer: 2.0f");
break;
case 4:
spawnTime = 2.5f;
Debug.Log("Poteniometer: 2.5f");
break;
case 5:
spawnTime = 3.0f;
Debug.Log("Poteniometer: 3.0f");
break;
case 6:
spawnTime = 3.5f;
Debug.Log("Poteniometer: 3.5f");
break;
case 7:
spawnTime = 4.0f;
Debug.Log("Poteniometer: 4.0f");
break;
case 8:
spawnTime = 4.5f;
Debug.Log("Poteniometer: 4.0f");
break;
case 9:
spawnTime = 5.0f;
Debug.Log("Poteniometer: 4.0f");
break;
case 10:
spawnTime = 5.5f;
Debug.Log("Poteniometer: 4.0f");
break;
default:
spawnTime = 1.72f;
Debug.Log("Poteniometer: 1.72");
break;
}
}
InvokeRepeating("Spawn", spawnDelay, spawnTime);
}
// Update is called once per frame
void Update()
{
if (correct && correctplayed)
{
switch (GameControl.CurrentAnimal)
{
case "Bear":
serialController.SendSerialMessage("R");
if (videoPlayer.time == 25f || videoPlayer.time == 33f)
{
serialController.SendSerialMessage("V");
serialController.SendSerialMessage("F");
}
if (videoPlayer.time == 26f || videoPlayer.time == 35f)
{
serialController.SendSerialMessage("v");
serialController.SendSerialMessage("f");
}
break;
case "Elephant":
serialController.SendSerialMessage("B");
if (videoPlayer.time == 25.5f || videoPlayer.time == 32f)
{
serialController.SendSerialMessage("V");
serialController.SendSerialMessage("F");
}
if (videoPlayer.time == 26.5f || videoPlayer.time == 34f)
{
serialController.SendSerialMessage("v");
serialController.SendSerialMessage("f");
}
if (videoPlayer.time == 32f)
{
serialController.SendSerialMessage("E");
}
break;
case "Lion":
serialController.SendSerialMessage("P");
if (videoPlayer.time == 29f || videoPlayer.time == 35f)
{
serialController.SendSerialMessage("V");
serialController.SendSerialMessage("F");
}
if (videoPlayer.time == 31.5f)
{
serialController.SendSerialMessage("v");
serialController.SendSerialMessage("f");
}
break;
}
}
else if (correct && !correctplayed)
{
new WaitForSeconds(1);
serialController.SendSerialMessage("c");
serialController.SendSerialMessage("1");
}
//This one checks the state of the ofdjfoe
string message = serialController.ReadSerialMessage();
if (message == null)
{
return;
}
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
InputHandler(message);
}
// Executed each frame
void Update()
{
//---------------------------------------------------------------------
// Send data
//---------------------------------------------------------------------
// If you press one of these keys send it to the serial device. A
// sample serial device that accepts this input is given in the README.
if (Input.GetKeyDown(KeyCode.P))
{
Debug.Log("Sending P");
serialController.SendSerialMessage("P1");
}
if (Input.GetKeyDown(KeyCode.B))
{
Debug.Log("Sending Z");
serialController.SendSerialMessage("B-C-T-07");
}
if (Input.GetKeyDown(KeyCode.D))
{
Debug.Log("Sending Z");
serialController.SendSerialMessage("B-O-34");
}
if (Input.GetKeyDown(KeyCode.N))
{
Debug.Log("Sending Z");
serialController.SendSerialMessage("B-F-0-0");
}
if (sendtext != "lul")
{
Debug.Log(sendtext);
serialController.SendSerialMessage(sendtext);
sendtext = "lul";
}
if (Input.GetKeyDown(KeyCode.T))
{
Debug.Log("Sending T");
serialController.SendSerialMessage("T-6000");
}
//---------------------------------------------------------------------
// Receive data
//---------------------------------------------------------------------
string message = serialController.ReadSerialMessage();
//encoder
if (message == "encoderleft")
{
encoderleft = true;
Debug.Log(message);
// wenn benutzt nach if abfrage wieder auf false setzen
}
if (message == "encoderright")
{
encoderright = true;
Debug.Log(message);
}
//Kippschalter
if (message == "kippschalter1on")
{
kipp1 = true;
Debug.Log(message);
}
if (message == "kippschalter1off")
{
kipp1 = false;
Debug.Log(message);
}
if (message == "kippschalter2on")
{
kipp2 = true;
Debug.Log(message);
}
if (message == "kippschalter2off")
{
kipp2 = false;
Debug.Log(message);
}
if (message == "kippschalter3on")
{
kipp3 = true;
Debug.Log(message);
}
if (message == "kippschalter3off")
{
kipp3 = false;
Debug.Log(message);
}
if (message == "kippschalter4on")
{
kipp4 = true;
Debug.Log(message);
}
if (message == "kippschalter4off")
{
kipp4 = false;
Debug.Log(message);
}
//modulemode
if (message == "module1on")
{
module1 = true;
Debug.Log(message);
}
if (message == "module1off")
{
module1 = false;
Debug.Log(message);
}
if (message == "module2on")
{
module2 = true;
Debug.Log(message);
}
if (message == "module2off")
{
module2 = false;
Debug.Log(message);
}
if (message == "module3on")
{
module3 = true;
Debug.Log(message);
}
if (message == "module3off")
{
module3 = false;
Debug.Log(message);
}
if (message == "module4on")
{
module4 = true;
Debug.Log(message);
}
if (message == "module4off")
{
module4 = false;
Debug.Log(message);
}
//potentiometer
if ((message != null) && (message.Contains("pot1")))
{
string[] numbers = message.Split(',');
pot1value = int.Parse(numbers[1]);
Debug.Log(pot1value);
}
if ((message != null) && (message.Contains("pot2")))
{
string[] numbers = message.Split(',');
pot2value = int.Parse(numbers[1]);
Debug.Log(pot2value);
}
if ((message != null) && (message.Contains("pot3")))
{
string[] numbers = message.Split(',');
pot3value = int.Parse(numbers[1]);
Debug.Log(pot3value);
}
if ((message != null) && (message.Contains("pot4")))
{
string[] numbers = message.Split(',');
pot4value = int.Parse(numbers[1]);
Debug.Log(pot4value);
}
//Joystick
if ((message != null) && (message.Contains("JoyX")))
{
string[] numbers = message.Split(',');
JoyXvalue = int.Parse(numbers[1]);
Debug.Log(JoyXvalue);
}
if ((message != null) && (message.Contains("JoyY")))
{
string[] numbers = message.Split(',');
JoyYvalue = int.Parse(numbers[1]);
Debug.Log(JoyYvalue);
}
if (message == "beben")
{
erdbebenMode = true;
}
// keypad
if (message == "arrowup")
{
Debug.Log(message);
arrowup = true;
}
if (message == "arrowdown")
{
Debug.Log(message);
arrowdown = true;
}
if (message == "arrowleft")
{
Debug.Log(message);
arrowleft = true;
}
if (message == "arrowright")
{
Debug.Log(message);
arrowright = true;
}
if (message == "ButtonX")
{
Debug.Log(message);
buttonX = true;
}
if (message == "keypad1")
{
Debug.Log(message);
keypad1 = true;
}
if (message == "keypad2")
{
Debug.Log(message);
keypad2 = true;
}
if (message == "keypad3")
{
Debug.Log(message);
keypad3 = true;
}
if (message == "keypad4")
{
Debug.Log(message);
keypad4 = true;
}
if (message == "keypad5")
{
Debug.Log(message);
keypad5 = true;
}
if (message == "keypad6")
{
Debug.Log(message);
keypad6 = true;
}
if (message == "keypad7")
{
Debug.Log(message);
keypad7 = true;
}
if (message == "keypad8")
{
Debug.Log(message);
keypad8 = true;
}
if (message == "keypad9")
{
Debug.Log(message);
keypad9 = true;
}
if (message == "keypad*")
{
Debug.Log(message);
keypad10 = true;
}
if (message == "keypad0")
{
Debug.Log(message);
keypad11 = true;
}
if (message == "keypad#")
{
Debug.Log(message);
keypad12 = true;
}
if (message == "keypadbackspace")
{
Debug.Log(message);
keypad13 = true;
}
if (message == "keypadenter")
{
Debug.Log(message);
keypad14 = true;
}
return;
// Check if the message is plain data or a connect/disconnect event.
if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_CONNECTED))
{
Debug.Log("Connection established");
}
else if (ReferenceEquals(message, SerialController.SERIAL_DEVICE_DISCONNECTED))
{
Debug.Log("Connection attempt failed or disconnection detected");
}
else
{
Debug.Log("Message arrived: " + message);
}
}
