private bool checkIfCompatible(selectAgent_vr a)
 {
     if (taskType == "Construction")
     {
         return(a.agentType == "ConstructionAgent");
     }
     else
     {
         return(a.agentType == "TransportAgent");
     }
 }
        // Update is called once per frame
        void FixedUpdate()
        {
            SteamVR_LaserPointer rLaserPointer = rightController.GetComponent <SteamVR_LaserPointer>();
            SteamVR_LaserPointer lLaserPointer = leftController.GetComponent <SteamVR_LaserPointer>();

            if (rLaserPointer.hit_game_object != null)
            {
                GameObject hitObject = rLaserPointer.hit_game_object;
                if (agent_ids.Contains(hitObject.GetInstanceID()))
                {
                    print("Hit an agent!");
                    selectAgent_vr hitAgent = hitObject.GetComponent <selectAgent_vr>();
                    if (rLaserPointer.triggered)
                    {
                        hitAgent.OnMouseDown();
                    }
                }

                if (task_ids.Contains(hitObject.GetInstanceID()))
                {
                    print("Hit a task");
                    SelectTask_vr selectedTask = hitObject.GetComponent <SelectTask_vr>();
                    if (rLaserPointer.triggered)
                    {
                        if (selectedTask.OnTrigged())
                        {
                            rLaserPointer.hit_target = true;
                        }
                    }
                }

                /*if (hitObject.Equals(plane))
                 * {
                 *  selectAgent_vr.DeselectAll();
                 * }*/
            }
            if (lLaserPointer.hit_game_object != null)
            {
                print(lLaserPointer.hit_game_object);
            }


            OnRightClick rc = plane.GetComponent <OnRightClick>();

            if (rc.clicked_off)
            {
                foreach (GameObject task in construction_tasks.Values)
                {
                    SelectTask_vr selections = task.GetComponent <SelectTask_vr>();
                    selections.rightClickAndSelected = false;
                }

                foreach (GameObject task in transport_tasks.Values)
                {
                    SelectTask_vr selections = task.GetComponent <SelectTask_vr>();
                    selections.rightClickAndSelected = false;
                }

                if (selectAgent_vr.currentlySelected.Count != 0)
                {
                    selectAgent_vr.DeselectAll();
                }
                rc.clicked_off = false;
            }

            if (!start_recieved)
            {
                rosSocket.Publish(updateID, message);
            }

            // Update agents through the update function
            if (agent_message != null)
            {
                if (!agents.ContainsKey(agent_message.name))
                {
                    GameObject addingAgent = new GameObject();
                    try
                    {
                        if (agent_message.agent_type == "ConstructionAgent")
                        {
                            addingAgent = Instantiate(contructionAgentModel, getVectFromMessage(agent_message.pose), getQuadFromMsg(agent_message.pose));
                        }
                        else
                        {
                            addingAgent = Instantiate(transportAgentModel, getVectFromMessage(agent_message.pose), getQuadFromMsg(agent_message.pose));
                        }
                        selectAgent_vr menu = addingAgent.AddComponent <selectAgent_vr>();
                        agent_ids.Add(addingAgent.GetInstanceID());
                        menu.agentType = agent_message.agent_type;
                        BoxCollider box = addingAgent.AddComponent <BoxCollider>();
                        box.size = box.size * 1.3f;
                        GameObject textObject = new GameObject();
                        textObject.transform.position = addingAgent.transform.position;
                        textObject.transform.LookAt(camera.transform);
                        Vector3 rot = textObject.transform.eulerAngles;
                        rot = new Vector3(rot.x, rot.y + 180, rot.z);
                        textObject.transform.rotation = Quaternion.Euler(rot);
                        TextMesh text_name = textObject.AddComponent <TextMesh>();
                        text_name.text     = agent_message.name;
                        text_name.fontSize = text_size;
                        //TextMesh agent_name = addingAgent.AddComponent<TextMesh>();
                        if (agent_message.agent_type == "ConstructionAgent")
                        {
                            text_name.color = red;
                        }
                        else
                        {
                            text_name.color = blue;
                        }
                        textValues.Add(agent_message.name, textObject);
                        AgentInfo agent_info = addingAgent.AddComponent <AgentInfo>();
                        //name_display.name = agent_message.name;
                        menu.agentName         = agent_message.name;
                        menu.agentCurrentTask  = agent_message.current_task;
                        menu.currentAction     = agent_message.current_action;
                        menu.agentCapabilities = getStringCompatibilities(agent_message.capabilities);
                        menu.movementSpeed     = agent_message.movement_speed.ToString();
                        menu.isAtTask          = agent_message.is_at_task.ToString();
                        agents.Add(agent_message.name, addingAgent);
                    } catch (ArgumentException e)
                    {
                        print("Some reason, the agent has already been added... " + e);
                        Destroy(addingAgent);
                        agents.Remove(agent_message.name);
                    }
                }
                else
                {
                    GameObject currentAgent;

                    agents.TryGetValue(agent_message.name, out currentAgent);
                    currentAgent.transform.position      = getVectFromMessage(agent_message.pose);
                    currentAgent.transform.localRotation = getQuadFromMsg(agent_message.pose);
                    selectAgent_vr menu = currentAgent.GetComponent <selectAgent_vr>();
                    menu.agentCurrentTask  = agent_message.current_task;
                    menu.currentAction     = agent_message.current_action;
                    menu.agentCapabilities = getStringCompatibilities(agent_message.capabilities);
                    menu.movementSpeed     = agent_message.movement_speed.ToString();
                    menu.isAtTask          = agent_message.is_at_task.ToString();
                    GameObject objText;
                    textValues.TryGetValue(agent_message.name, out objText);
                    objText.transform.position = currentAgent.transform.position;
                }
                agent_message = null;
            }

            if (construction_task_message != null)
            {
                string PERM_CONTRUCTION_NAME = String.Copy(construction_task_message.name);
                if ((!construction_tasks.ContainsKey(construction_task_message.name)))
                {
                    try
                    {
                        if (!construction_task_message.is_complete)
                        {
                            GameObject addingConstructionTask = Instantiate(contructionTaskModel, getVectFromMessage(construction_task_message.pose, new Vector3(0, 1f, 0)), getQuadFromMsg(construction_task_message.pose));
                            construction_tasks.Add(PERM_CONTRUCTION_NAME, addingConstructionTask);
                            //NameDisplay name_display = addingConstructionTask.AddComponent<NameDisplay>();
                            //name_display.name = PERM_CONTRUCTION_NAME;
                            task_ids.Add(addingConstructionTask.GetInstanceID());
                            BoxCollider box = addingConstructionTask.AddComponent <BoxCollider>();
                            box.size = box.size * 1.3f;
                            SelectTask_vr taskSelect = addingConstructionTask.AddComponent <SelectTask_vr>();
                            taskSelect.taskName = PERM_CONTRUCTION_NAME;
                            taskSelect.taskType = "Construction";

                            GameObject textObject = new GameObject();
                            textObject.transform.position = addingConstructionTask.transform.position;
                            textObject.transform.LookAt(camera.transform);
                            Vector3 rot = textObject.transform.eulerAngles;
                            rot = new Vector3(rot.x, rot.y + 180, rot.z);
                            textObject.transform.rotation = Quaternion.Euler(rot);
                            TextMesh text_name = textObject.AddComponent <TextMesh>();
                            text_name.text     = construction_task_message.name;
                            text_name.fontSize = text_size;
                            text_name.color    = offRed;
                            textValues.Add(construction_task_message.name, textObject);
                        }
                    }
                    catch (ArgumentException e)
                    {
                        print("Some reason, the contruction task has already been added... " + e);
                    }
                }
                else
                {
                    GameObject currentConstructionTask;
                    construction_tasks.TryGetValue(construction_task_message.name, out currentConstructionTask);
                    GameObject objText;
                    textValues.TryGetValue(construction_task_message.name, out objText);
                    objText.transform.position = currentConstructionTask.transform.position;
                    if (construction_task_message.is_complete)
                    {
                        construction_tasks.Remove(construction_task_message.name);
                        Destroy(currentConstructionTask);
                        textValues.Remove(construction_task_message.name);
                        Destroy(objText);
                    }
                }
                construction_task_message = null;
            }

            if (transport_task_message != null)
            {
                if (!transport_tasks.ContainsKey(transport_task_message.name))
                {
                    if (!transport_task_message.is_complete)
                    {
                        GameObject addingTransportTask    = Instantiate(transportTaskModel, getVectFromMessage(transport_task_message.pose, new Vector3(0, 0.47f, 0)), getQuadFromMsg(transport_task_message.pose));
                        GameObject addingTransportTaskEnd = Instantiate(dartModel, getVectFromMessage(transport_task_message.end_pose, new Vector3(0, 1.252f, 0)), Quaternion.Euler(90, 0, 0));
                        addingTransportTaskEnd.transform.localScale = new Vector3(200, 200, 200);
                        task_ids.Add(addingTransportTask.GetInstanceID());
                        // Makes the transport task end a child of the adding transport task.
                        // addingTransportTaskEnd.transform.parent = addingTransportTask.transform;
                        transport_tasks.Add(transport_task_message.name, addingTransportTask);
                        LineRenderer line = addingTransportTask.AddComponent <LineRenderer>();
                        line.material = lineMaterial;
                        //NameDisplay name_display = addingTransportTask.AddComponent<NameDisplay>();
                        //name_display.colour = offBlue;
                        line.SetPositions(new Vector3[2] {
                            new Vector3(addingTransportTask.transform.position.x, 0.01f, addingTransportTask.transform.position.z),
                            new Vector3(addingTransportTaskEnd.transform.position.x, 0.01f, addingTransportTaskEnd.transform.position.z)
                        });
                        line.startWidth = 0.05f;
                        line.endWidth   = 0.5f;
                        //name_display.name = transport_task_message.name;
                        BoxCollider box = addingTransportTask.AddComponent <BoxCollider>();
                        box.size = box.size * 1.3f;
                        SelectTask_vr taskSelect = addingTransportTask.AddComponent <SelectTask_vr>();
                        taskSelect.taskName = transport_task_message.name;
                        taskSelect.taskType = "Transport";

                        GameObject textObject = new GameObject();
                        textObject.transform.position = addingTransportTask.transform.position;
                        textObject.transform.LookAt(camera.transform);
                        Vector3 rot = textObject.transform.eulerAngles;
                        rot = new Vector3(rot.x, rot.y + 180, rot.z);
                        textObject.transform.rotation = Quaternion.Euler(rot);
                        TextMesh text_name = textObject.AddComponent <TextMesh>();
                        text_name.text     = transport_task_message.name;
                        text_name.fontSize = text_size;
                        text_name.color    = offBlue;
                        textValues.Add(transport_task_message.name, textObject);
                    }
                }
                else
                {
                    GameObject currentTransportTask;
                    transport_tasks.TryGetValue(transport_task_message.name, out currentTransportTask);

                    GameObject objText;
                    textValues.TryGetValue(transport_task_message.name, out objText);
                    objText.transform.position = currentTransportTask.transform.position;

                    try
                    {
                        currentTransportTask.transform.position = getVectFromMessage(transport_task_message.pose, new Vector3(0, 0.47f, 0));
                        LineRenderer line = currentTransportTask.GetComponent <LineRenderer>();
                        line.SetPosition(0, new Vector3(currentTransportTask.transform.position.x, 0.01f, currentTransportTask.transform.position.z));
                        if (transport_task_message.is_complete)
                        {
                            transport_tasks.Remove(transport_task_message.name);
                            Destroy(currentTransportTask);
                            textValues.Remove(transport_task_message.name);
                            Destroy(objText);
                        }
                    } catch (MissingReferenceException e)
                    {
                        print("Transport task was destroyed, the task is still in the dictionary for some reasons... Deleting it again.");
                        transport_tasks.Remove(transport_task_message.name);
                    }
                }
                transport_task_message = null;
            }

            if (textValues.Count > 0)
            {
                List <string> keys = new List <string>(textValues.Keys);
                foreach (string k in keys)
                {
                    textValues[k].transform.LookAt(Camera.main.transform);
                    Vector3 rot = textValues[k].transform.eulerAngles;
                    rot = new Vector3(-rot.x, rot.y + 180, rot.z);
                    textValues[k].transform.rotation = Quaternion.Euler(rot);
                }
            }

            if (construction_tasks.Count != 0)
            {
                foreach (GameObject task in construction_tasks.Values)
                {
                    task.transform.localEulerAngles = new Vector3(45, task.transform.localEulerAngles.y + 1f, 90);
                }
            }
        }