SceneController.cs

using UnityEngine;
using UnityEngine.SceneManagement;
using SimpleJSON;
using System.IO;
using System.Collections;
using System.Collections.Generic;

namespace dlu
{

public class SceneController : MonoBehaviour
{
    public string importInstructionFile = "Assets/DLU/Resources/instruction.json";

    [HideInInspector]
    public JSONArray instruction = null;
    private SemanticBehaviour[] _semanticBehaviours;
    private Dictionary<string, GameObject> sceneDict;

    [HideInInspector]
    public SemanticBehaviour[] semanticBehaviours {
        get
        {
            return this._semanticBehaviours;
        }

        set
        {
            sceneDict = new Dictionary<string, GameObject>();
            foreach (SemanticBehaviour sb in value)
            {
                sceneDict[sb.GetComponent<InstanceIdentifier>().name] = sb.gameObject;
            }
            this._semanticBehaviours = value;
        }
    }

    public void Start()
    {
        if (instruction == null)
        {
            instruction = LoadInstruction(importInstructionFile);
        }
        if (semanticBehaviours == null)
        {
            semanticBehaviours = FindSemanticLabels();
        }
        if (!Application.isEditor)
        {
            SceneManager.LoadScene("UI", LoadSceneMode.Additive);
        }
        StartCoroutine(EvaluateInstruction());
    }

    public JSONArray LoadInstruction(string json)
    {
        return JSON.Parse(File.ReadAllText(json)) as JSONArray;
    }

    public SemanticBehaviour[] FindSemanticLabels()
    {
        return GameObject.FindObjectsOfType<SemanticBehaviour>();
    }

    public IEnumerator EvaluateInstruction()
    {
        Dictionary<string, JSONObject> taskDict = new Dictionary<string, JSONObject>();
        JSONObject task = null;
        // Populate quick access dict and search for task
        foreach (JSONObject jo in instruction)
        {
            taskDict[jo["name"]] = jo;
            if (task == null && jo.HasKey("classifies"))
            {
                task = jo;
                Debug.Log($"Task identified: {task}");
            }
        }

        // If no task is found, stop
        if (task == null)
        {
            Debug.LogError("No task found!");
            yield return null;
        }
        else  // if task is found, execute actions
        {
            foreach (JSONNode action in task["classifies"])
            {
                yield return ExecuteAction(action, taskDict);
            }
        }
    }

    public IEnumerator ExecuteAction(string actionName, Dictionary<string, JSONObject> taskDict)
    {
        JSONObject action = taskDict[actionName];
        Debug.Log($"Performing action {actionName}: {action}");
        List<string> participants = new List<string>();
        foreach (JSONNode participant in action["hasParticipant"])
        {
            Debug.Log($"Participant: {participant}");
            foreach(JSONNode is_a in taskDict[participant]["is_a"])
            {
                // TODO(@shoeffner): This is not good: we should query the ontology and don't use is_a which are also PhysicalAgents etc., also just add participants once
                if (is_a != "http://www.ontologydesignpatterns.org/ont/dul/DUL.owl#PhysicalAgent")
                {
                    participants.Add(participant);
                    break;
                }
            }
        }
        foreach (string participant in participants)
        {
            GameObject participantGO = sceneDict[participant];
            GameObject targetGO = new GameObject($"Target of {participant}");

            // Setup visuals
            GameObject renderer = new GameObject("RenderComponents");
            renderer.transform.SetParent(targetGO.transform);
            renderer.transform.localScale = participantGO.transform.lossyScale;
            MeshFilter mesh = renderer.AddComponent<MeshFilter>();
            mesh.mesh = participantGO.GetComponent<MeshFilter>().mesh;
            MeshRenderer mr = renderer.AddComponent<MeshRenderer>();
            mr.material = Resources.Load<Material>("Target");

            Vector3 position = taskDict[participant]["components"]["transform"]["position"];
            Quaternion orientation = taskDict[participant]["components"]["transform"]["orientation"];
            targetGO.transform.SetPositionAndRotation(position, orientation);
            double speed = taskDict[participant]["components"].HasKey("speed") ? taskDict[participant]["components"]["speed"].AsDouble : 1.0;

            Hashtable arguments = new Hashtable();
            arguments["name"] = actionName;
            arguments["position"] = targetGO.transform;
            arguments["speed"] = speed;

            iTween.MoveTo(participantGO, arguments);
        }
        yield return null;
    }
}

}