Beispiel #1
0
        void ApplyTaskUpdate(TaskUpdateBundled taskUpdate)
        {
            // See if we have a task on this storypoint.

            StoryTask updateTask = GENERAL.GetTaskForPoint(taskUpdate.pointID);


            if (updateTask == null)
            {
                // If not, and we're a client, we create the task.
                // If we're the server, we ignore updates for task we no longer know about.

                if (GENERAL.AUTHORITY == AUTHORITY.LOCAL)
                {
                    updateTask = new StoryTask(taskUpdate.pointID, SCOPE.GLOBAL);
                    updateTask.ApplyUpdateMessage(taskUpdate);

                    Log("Created an instance of global task " + updateTask.Instruction + " id " + updateTask.PointID);

                    if (taskUpdate.pointID != "GLOBALS")
                    {
                        // Now find a pointer.

                        StoryPointer updatePointer = GENERAL.GetStorylinePointerForPointID(taskUpdate.pointID);

                        if (updatePointer == null)
                        {
                            updatePointer = new StoryPointer();

                            Log("Created a new pointer for task " + updateTask.Instruction);
                        }

                        updatePointer.PopulateWithTask(updateTask);

                        Log("Populated pointer " + updatePointer.currentPoint.StoryLine + " with task " + updateTask.Instruction);

                        DistributeTasks(new TaskArgs(updateTask));
                    }
                }
            }
            else
            {
                updateTask.ApplyUpdateMessage(taskUpdate);

                updateTask.scope = SCOPE.GLOBAL;//??

                Verbose("Applied update to existing task " + updateTask.Instruction);
            }
        }
Beispiel #2
0
        public StoryPointer(string pointID, SCOPE setScope)
        {
            // Create a pointer from a given point. Task to be added later.

            currentPoint = GENERAL.GetStoryPointByID(pointID);

            currentTask = null;
            status      = POINTERSTATUS.EVALUATE;
            scope       = setScope;

            //   GENERAL.AddPointer(this);

            GENERAL.ALLPOINTERS.Add(this);

            //  updateMessageSend = new PointerUpdateBundled(); // we'll reuse.
        }
Beispiel #3
0
        void updateTaskInfo(StoryPointer pointer)
        {
            StoryTask theTask = pointer.currentTask;

            if (theTask == null || theTask.Pointer.pointerObject == null)
            {
                return;
            }

            if (theTask.Instruction != "wait")
            {
                //string displayText;

                string displayText = theTask.scope == SCOPE.GLOBAL ? "G| " : "L| ";

                // if (theTask.scope == SCOPE.GLOBAL)
                //{
                //    displayText = "G | ";
                //}
                //else
                //{
                //    displayText = "L | ";

                //}

                displayText = displayText + theTask.Instruction + " | ";

                // If a task has a value for "debug" we display it along with task description.

                string debugText;

                if (theTask.GetStringValue("debug", out debugText))
                {
                    displayText = displayText + debugText;
                }

                theTask.Pointer.deusText.text      = displayText;
                theTask.Pointer.deusTextSuper.text = theTask.Pointer.currentPoint.StoryLine + " " + GENERAL.ALLPOINTERS.Count;
            }
            else
            {
                theTask.Pointer.deusTextSuper.text = theTask.Pointer.currentPoint.StoryLine;
            }
        }
Beispiel #4
0
        void Update()
        {
            int t = 0;

            while (t < taskList.Count)
            {
                StoryTask task = taskList[t];

                if (!GENERAL.ALLTASKS.Exists(at => at == task))
                {
                    Log("Removing task:" + task.Instruction);

                    taskList.RemoveAt(t);
                }
                else
                {
                    if (setTaskHandler != null)
                    {
                        if (setTaskHandler(task))
                        {
                            task.signOff(ID);
                            taskList.RemoveAt(t);
                        }
                        else
                        {
                            t++;
                        }
                    }
                    else
                    {
                        task.signOff(ID);
                        taskList.RemoveAt(t);

                        if (!handlerWarning)
                        {
                            Warning("No handler registered.");
                            handlerWarning = true;
                        }
                    }
                }
            }
        }
Beispiel #5
0
        public bool HandleTask(StoryTask task)
        {
            bool done = false;

            switch (task.Instruction)
            {
            case "helloworld":
                Log("Hello world");
                done = true;
                break;

            case "unknowntask":

                break;

            default:
                done = true;

                break;
            }

            return(done);
        }
Beispiel #6
0
        void handleTasks()
        {
            int t = 0;

            while (t < taskList.Count)
            {
                StoryTask task = taskList[t];

                //			if (task.pointer.getStatus () == POINTERSTATUS.KILLED && task.description != "end") {
                //				if (task.pointer.getStatus () == POINTERSTATUS.KILLED && task.description != "end") {

                if (!GENERAL.ALLTASKS.Exists(at => at == task))
                {
                    Log("Removing task:" + task.Instruction);

                    taskList.RemoveAt(t);
                }
                else
                {
                    switch (task.Instruction)
                    {
                    case "debugon":

                        DeusCanvas.SetActive(true);

                        task.signOff(ID);
                        taskList.RemoveAt(t);
                        break;


                    case "debugoff":

                        DeusCanvas.SetActive(false);
                        task.signOff(ID);
                        taskList.RemoveAt(t);
                        break;


                    case "toggledebug":
                    case "debugtoggle":

                        DeusCanvas.SetActive(!DeusCanvas.activeSelf);
                        task.signOff(ID);
                        taskList.RemoveAt(t);
                        break;


                    /*
                     * case "end":
                     *
                     *  // after finishing the end task, we mark the pointer as killed, so it gets removed.
                     *
                     *  task.pointer.setStatus (POINTERSTATUS.KILLED);
                     *
                     *
                     *
                     * //					Log.Message ("Destroying ui for pointer for storyline " + task.pointer.currentPoint.storyLineName);
                     * //
                     * //					// update first. some pointers reach end in a single go - we want those to be aligned.
                     * //
                     * //					updateTaskDisplay (task);
                     * //
                     * //					pointerList.Remove (task.pointer);
                     * //
                     * //					pointerPositions [task.pointer.position] = null;
                     * //
                     * //					Destroy (task.pointer.pointerObject);
                     * //
                     * //					// after finishing the end task, we mark the pointer as killed, so it gets removed.
                     * //
                     * //					task.pointer.setStatus (POINTERSTATUS.KILLED);
                     *
                     * //					updateTaskDisplay (task);
                     *
                     *
                     *  task.signOff (me);
                     *  taskList.RemoveAt (t);
                     *  break;
                     *
                     */

                    default:

                        //					updateTaskDisplay (task);

                        task.signOff(ID);
                        taskList.RemoveAt(t);
                        break;
                    }
                }
            }
        }
Beispiel #7
0
        void Update()
        {
#if UNITY_EDITOR && UNITY_IOS
            // Pause applicatin simulation for debugging.

            if (Input.GetKeyDown("p"))
            {
                OnApplicationPause(true);
            }

            if (Input.GetKeyDown("o"))
            {
                OnApplicationPause(false);
            }

            if (state == STATE.PAUSED)
            {
                return;
            }
#endif


#if !SOLO
            if (displayNetworkGUIState())
            {
                SetNetworkIndicators();
            }
#endif

            int t = 0;

            while (t < taskList.Count)
            {
                StoryTask task = taskList[t];

                if (task.Instruction == "end")
                {
                    Log("Encountered end task, removing pointer " + task.Pointer.currentPoint.StoryLine);

                    GENERAL.ALLPOINTERS.Remove(task.Pointer);
                }

                if (!GENERAL.ALLTASKS.Exists(at => at == task))
                {
                    // Task was removed, so stop executing it.
                    Log("Removing task:" + task.Instruction);
                    taskList.RemoveAt(t);
                }
                else
                {
                    // Task needs to be executed.
                    // first check for storyengine tasks.
                    bool done = false;
                    switch (task.Instruction)
                    {
#if !SOLO
                    // ---------------------------- VISUAL DEBUGGING ----------------------------
                    case "debugon":

                        // Show network info.

                        displayNetworkGUI(true);
                        done = true;
                        break;

                    case "debugoff":

                        // Hide network info.

                        displayNetworkGUI(false);
                        done = true;
                        break;

                    case "toggledebug":

                        // Toggle network info.

                        displayNetworkGUI(!displayNetworkGUIState());
                        done = true;
                        break;

                    // ---------------------------- SCOPE ----------------------------

                    case "isglobal":

                        if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL)
                        {
                            task.Pointer.scope = SCOPE.GLOBAL;
                        }

                        done = true;
                        break;

                    case "islocal":

                        task.Pointer.SetLocal();

                        //Verbose("Setting pointer scope to local: " + task.Pointer.currentPoint.StoryLine);

                        done = true;
                        break;



                    // ---------------------------- SERVER SIDE ----------------------------

                    case "startserver":

                        // Start broadcast and network server if not already going.

                        if (!sending)
                        {
                            Log("Starting broadcast server, key " + ConnectionKey + " message " + ConnectionMessage);
                            startBroadcastServer(ConnectionKey, ConnectionMessage);
                        }

                        if (!serving)
                        {
                            Log("Starting network server.");
                            startNetworkServer();
                        }

                        done = true;
                        break;

                    case "stopserver":

                        // Stop broadcast and network server

                        Log("Stopping broadcast server.");
                        stopBroadcast();

                        Log("Stopping network server.");
                        stopNetworkServer();

                        done = true;
                        break;

                    case "monitorconnections":

                        if (NetworkObject == null || state == STATE.PAUSED)
                        {
                            break;
                        }

                        // Keep servers up on IOS (because of application pause)

#if UNITY_IOS
                        if (!sending)
                        {
                            Log("Starting broadcast server, key " + ConnectionKey + " message " + ConnectionMessage);
                            startBroadcastServer(ConnectionKey, ConnectionMessage);
                        }

                        if (!serving)
                        {
                            Log("Starting network server.");
                            startNetworkServer();
                        }
#endif

                        // Watch for new clients. Stays live indefinitely.

                        if (serving && NewTrackedAddresses())
                        {
                            // new addresses connected since last call

                            foreach (string add in NewConnectedAddresses())
                            {
                                Log("New client at " + add);
                            }


                            task.setCallBack("addclient");
                        }

                        task.SetStringValue("debug", "clients: " + TrackedConnectedAddresses().Count);
                        WasConnected = TrackedConnectedAddresses().Count > 0;


                        break;

                    case "pushglobaltasks":

                        // go over all pointers  and mark everything as modified
                        // that way it'll get sent.
                        // with single client apps this is ok, but for multiple clients we need something more advanced

                        Log("Pushing global tasks.");

                        foreach (StoryTask theTask in GENERAL.ALLTASKS)
                        {
                            if (theTask.scope == SCOPE.GLOBAL)
                            {
                                theTask.MarkAllAsModified();
                            }
                        }

                        done = true;
                        break;

                    // ---------------------------- CLIENT SIDE ----------------------------


                    case "serversearch":

                        if (NetworkObject == null || state == STATE.PAUSED)
                        {
                            break;
                        }

                        if (listening)
                        {
                            if (foundServer())
                            {
                                Log("Found broadcast server " + networkBroadcast.serverAddress + " key " + networkBroadcast.broadcastKey);

                                stopBroadcast();

                                task.setCallBack("serverfound");
                                listening = false;

                                done = true;
                            }
                        }
                        else
                        {
                            startBroadcastClient(ConnectionKey);
                            Log("Restarting broadcast listening for key " + ConnectionKey);
                            listening = true;
                        }

                        break;



                    case "startclient":

                        string ServerAddress = networkBroadcast.serverAddress;

                        if (ServerAddress != "")
                        {
                            Log("Starting network client for remote server " + ServerAddress);
                            startNetworkClient(ServerAddress);
                        }
                        else
                        {
                            Warning("Trying to start client without server address.");
                        }

                        done = true;
                        break;

                    case "stopclient":

                        Log("Stopping network client.");

                        StopNetworkClient();
                        WasConnected = false;

                        done = true;

                        break;

                    case "monitorserver":

                        // Watches the connection, stays active until connection lost.

                        if (clientIsConnected())
                        {
                            WasConnected = true;
                        }
                        else
                        {
                            if (WasConnected)
                            {
                                // Lost connection. Restart server search.

                                Log("Lost server connection.");

                                StopNetworkClient();
                                WasConnected = false;
                                task.setCallBack("client");

                                done = true;
                            }
                            else
                            {
                                //
                            }
                        }

                        break;
#endif
                    default:

                        // Not a controller task, pass it on.

                        if (dataTaskHandler != null)
                        {
                            done = dataTaskHandler(task);
                        }
                        else
                        {
                            // If no handler available we just sign off, but issue a warning once.
                            done = true;

                            if (!handlerWarning)
                            {
                                Warning("No handler registered.");
                                handlerWarning = true;
                            }
                        }

                        break;
                    }

                    if (done)
                    {
                        task.signOff(ID);
                        taskList.RemoveAt(t);
                    }
                    else
                    {
                        t++;
                    }
                }
            }
        }
Beispiel #8
0
 public StoryTask SpawnTask()
 {
     currentTask = new StoryTask(this);
     //status = POINTERSTATUS.EVALUATE;
     return(currentTask);
 }
Beispiel #9
0
 public TaskArgs(StoryTask task) : base() // extend the constructor
 {
     theTasks = new List <StoryTask>();
     theTasks.Add(task);
 }
Beispiel #10
0
        void LateUpdate()
        {
            StoryUpdate storyUpdate = new StoryUpdate(); // Contains a collection of task and pointer updates.

            // Check our loadbalance. If we're sending too many updates we'll randomly drop frames.
            // All changes will be sent but if values are updated in the meantime the previous value will never be sent.
            // This is ok for running values but not ok for status values etc.

            int QueueSize = 0;

            if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL && NetworkServer.active)
            {
                // We're an active server.

                byte error;
                QueueSize = NetworkTransport.GetOutgoingMessageQueueSize(NetworkServer.serverHostId, out error);
                //  debugValue.text = "queued out server: " + QueueSize;

                if ((NetworkError)error != NetworkError.Ok)
                {
                    Error("Networktransport error: " + (NetworkError)error);
                }
            }
            if (GENERAL.AUTHORITY == AUTHORITY.LOCAL && networkManager != null && networkManager.client != null)
            {
                // We're an active client.

                byte error = (byte)NetworkError.Ok;

                if (networkManager.client.connection != null)
                {
                    QueueSize = NetworkTransport.GetOutgoingMessageQueueSize(networkManager.client.connection.hostId, out error);
                }
                else
                {
                    Warning("Can't get queue size (yet)");
                }

                //    debugValue.text = "queued out client: " + QueueSize;

                if ((NetworkError)error != NetworkError.Ok)
                {
                    Error("Networktransport error: " + (NetworkError)error);
                }
            }

            switch (QueueSize)
            {
            case 0:
                BufferStatusOut = 0;
                break;

            case 1:
            case 2:
                BufferStatusOut = 1;
                break;

            default:
                BufferStatusOut = 2;
                break;
            }

            // forcing always send.
            // this means that a storyupdate is sent for every frame and they all arrive in order.
            // they get executed in order as well, but they may be batched together.
            // so multiple tasks might get executed in a single frame. they will be executed in the correct order.


            if (QueueSize < 3 || true)

            {
                // Iterate over all pointers to see if any were killed. Clients do not kill pointers themselves.
                // For consistency of network logic, local pointers that were killed are disposed by the director.
                // Global pointers are disposed here, after updating clients about them.

                for (int p = GENERAL.ALLPOINTERS.Count - 1; p >= 0; p--)
                {
                    StoryPointer pointer = GENERAL.ALLPOINTERS[p];

                    if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL && pointer.scope == SCOPE.GLOBAL && pointer.GetStatus() == POINTERSTATUS.KILLED)

                    //if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL && pointer.scope == SCOPE.GLOBAL && pointer.modified && pointer.GetStatus() == POINTERSTATUS.KILLED)
                    {
                        Log("Sending pointer kill update to clients: " + pointer.currentPoint.StoryLine);

                        storyUpdate.AddStoryPointerUpdate(pointer.GetUpdate()); // bundled

                        //pointer.modified = false;


                        Log("Removing pointer " + pointer.currentPoint.StoryLine);

                        GENERAL.ALLPOINTERS.Remove(pointer);
                    }
                }

                // Iterate over all tasks.

                for (int i = GENERAL.ALLTASKS.Count - 1; i >= 0; i--)
                {
                    StoryTask task = GENERAL.ALLTASKS[i];

                    // Cleanup completed tasks.

                    if (task.getStatus() == TASKSTATUS.COMPLETE)
                    {
                        GENERAL.ALLTASKS.RemoveAt(i);

                        Verbose("Task " + task.Instruction + " on storyline " + task.Pointer.currentPoint.StoryLine + " completed, removed from alltasks. ");
                    }

                    if (task.modified)
                    {
                        // Debugging: if a pointer is in the process of being killed, we may want to not send task updates
                        // as they might result in the task being recreated clientside.

                        if (task.Pointer.GetStatus() == POINTERSTATUS.KILLED)
                        {
                            Warning("Supressing sending task update for task with pointer that is dying. " + task.Instruction);
                        }
                        else
                        {
                            // Check if we need to send network updates.

                            switch (GENERAL.AUTHORITY)
                            {
                            case AUTHORITY.LOCAL:

                                if (task.scope == SCOPE.GLOBAL)
                                {
                                    Verbose("Global task " + task.Instruction + " changed, adding to update for server.");

                                    storyUpdate.AddTaskUpdate(task.GetUpdateBundled());     // bundled
                                }

                                break;

                            case AUTHORITY.GLOBAL:

                                if (task.scope == SCOPE.GLOBAL)
                                {
                                    Verbose("Global task " + task.Instruction + " changed, adding to update for clients.");

                                    storyUpdate.AddTaskUpdate(task.GetUpdateBundled());     // bundled
                                }

                                break;

                            default:

                                break;
                            }

                            task.modified = false;
                        }
                    }
                }

                // If anything to send, send.

                if (storyUpdate.AnythingToSend())

                {
                    switch (GENERAL.AUTHORITY)
                    {
                    case AUTHORITY.LOCAL:
                        SendStoryUpdateToServer(storyUpdate);
                        //Debug.Log("Sending story update to server. \n" + storyUpdate.DebugLog);

                        break;

                    case AUTHORITY.GLOBAL:

                        SendStoryUpdateToClients(storyUpdate);

                        //Debug.Log("Sending story update to clients. \n" + storyUpdate.DebugLog);
                        //Debug.Log(storyUpdate.ToString());

                        break;

                    default:
                        break;
                    }
                }
            }
            else
            {
                Warning("Dropping update.");
            }
        }
Beispiel #11
0
        void Update()
        {
#if !SOLO
            // Handle story updates, aiming for 1 per frame, assuming we're tyring to run in sync.
            // Lowest numbers are oldest.

            int UpdateCount = StoryUpdateStack.Count;

            switch (UpdateCount)
            {
            case 0:
                BufferStatusIn = 0;
                break;

            case 1:

                // exactly one, so apply.

                ApplyStoryUpdate(StoryUpdateStack[0]);
                StoryUpdateStack.RemoveAt(0);
                BufferStatusIn = 1;

                break;

            case 2:

                // Two, normally for different frames that happened to arrive in the same frame on this end.
                // Apply the oldest one, keep the other because we exact 0 updates during our next frame.

                ApplyStoryUpdate(StoryUpdateStack[0]);
                StoryUpdateStack.RemoveAt(0);
                BufferStatusIn = 1;

                break;

            default:

                // More than 2. Apply all the older ones in order of arrival, keep latest one.

                Warning("Update buffer >2");

                BufferStatusIn = 2;

                while (StoryUpdateStack.Count > 1)
                {
                    ApplyStoryUpdate(StoryUpdateStack[0]);
                    StoryUpdateStack.RemoveAt(0);
                }


                break;
            }
#endif

            switch (theDirector.status)
            {
            case DIRECTORSTATUS.ACTIVE:

                //   Verbose("Director active .");

                foreach (StoryTask task in GENERAL.ALLTASKS)
                {
                    if (task.getCallBack() != "")
                    {
                        // if a callback was set (somewhere on the network) we act on it only if we are the server or if the task is local.

                        if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL || task.scope == SCOPE.LOCAL)
                        {
                            task.Pointer.SetStatus(POINTERSTATUS.TASKUPDATED);
                        }
                    }
                }

                theDirector.EvaluatePointers();

                List <StoryTask> newTasks = new List <StoryTask>();

                for (int p = 0; p < GENERAL.ALLPOINTERS.Count; p++)
                {
                    StoryPointer pointer = GENERAL.ALLPOINTERS[p];

                    switch (pointer.scope)
                    {
                    case SCOPE.GLOBAL:

                        // If pointer scope is global, we add a task if our own scope is global as well. (If our scope is local, we'll be receiving the task over the network)

                        if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL)
                        {
                            if (pointer.GetStatus() == POINTERSTATUS.NEWTASK)
                            {
                                pointer.SetStatus(POINTERSTATUS.PAUSED);

                                StoryTask task = new StoryTask(pointer, SCOPE.GLOBAL);
                                task.LoadPersistantData(pointer);

                                newTasks.Add(task);
                                task.modified = true;

                                Verbose("Created global task " + task.Instruction + " for pointer " + pointer.currentPoint.StoryLine);
                            }
                        }

                        break;

                    case SCOPE.LOCAL:
                    default:

                        // If pointer scope is local, check if new tasks have to be generated.

                        if (pointer.GetStatus() == POINTERSTATUS.NEWTASK)
                        {
                            pointer.SetStatus(POINTERSTATUS.PAUSED);

                            StoryTask task = new StoryTask(pointer, SCOPE.LOCAL);
                            task.LoadPersistantData(pointer);

                            newTasks.Add(task);

                            Verbose("Created local task " + task.Instruction + " for pointer " + pointer.currentPoint.StoryLine);
                        }

                        break;
                    }
                }

                if (newTasks.Count > 0)
                {
                    DistributeTasks(new TaskArgs(newTasks));     // if any new tasks call an event, passing on the list of tasks to any handlers listening
                }

                break;

            case DIRECTORSTATUS.READY:

                GENERAL.SIGNOFFS = eventHandlerCount();

                if (GENERAL.SIGNOFFS == 0)
                {
                    Error("No handlers registred. Pausing director.");
                    theDirector.status = DIRECTORSTATUS.PAUSED;
                }
                else
                {
                    Verbose("" + GENERAL.SIGNOFFS + " handlers registred.");

                    Log("Starting storyline " + launchStoryline);

                    theDirector.NewStoryLine(launchStoryline);
                    theDirector.status = DIRECTORSTATUS.ACTIVE;
                }

                break;

            case DIRECTORSTATUS.NOTREADY:

                if (script != null)
                {
                    theDirector.loadScript(script);
                    break;
                }

                //if (scriptName != "")
                //{
                //    Warning("Please use the TextAsset field for your script.");
                //    theDirector.loadScript(scriptName);
                //    break;
                //}

                Error("No script reference found.");

                break;

            default:
                break;
            }
        }
Beispiel #12
0
        void updateTaskDisplays()
        {
            if (PointerBlock == null || DebugCanvas == null)
            {
                Warning("Set references for pointerblock and deuscanvas.");
                return;
            }

            // Go over all pointers and plot them into our diplay

            for (int i = 0; i < GENERAL.ALLPOINTERS.Count; i++)
            {
                StoryPointer pointer = GENERAL.ALLPOINTERS[i];

                if (!itemList.Exists(x => x.StoryPointer == pointer))
                {
                    Item ni = new Item(pointer, PointerBlock);
                    ni.displayObject.transform.SetParent(DebugCanvas.transform, false);

                    itemList.Add(ni);
                }
            }

            //   Log("datacount " + GENERAL.ALLDATA.Count);

            // Go over all data objects and plot them into our diplay

            /*
             * for (int i = 0; i < GENERAL.ALLDATA.Count; i++)
             * {
             *
             *  StoryData data = GENERAL.ALLDATA[i];
             *
             *  if (!itemList.Exists(x => x.StoryData == data))
             *  {
             *      //    Log("addin gitem");
             *      Item ni = new Item(data, PointerBlock);
             *      ni.displayObject.transform.SetParent(DeusCanvas.transform, false);
             *
             *      itemList.Add(ni);
             *
             *  }
             *
             * }
             */


            // Go over all items backwards and remove any

            for (int i = itemList.Count - 1; i >= 0; i--)
            {
                if (itemList[i].TimeOut != 0 && itemList[i].TimeOut < Time.time)
                {
                    Destroy(itemList[i].displayObject);
                    itemList.RemoveAt(i);
                }
            }

            // Go over all display items and update them.

            for (int i = 0; i < itemList.Count; i++)
            {
                int   row   = i / PointerDisplayCols;
                int   col   = i % PointerDisplayCols;
                float scale = 1f / PointerDisplayCols;

                Item item = itemList[i];

//                item.displayObject.GetComponent<RectTransform>().localPosition = scale * new Vector3(PointerDisplayCols / 2f * -1024f + 512f + col * 1024f, PointerDisplayRows / 2f * 512f - 256f - row * 512f, 0);
                item.displayObject.GetComponent <RectTransform>().localPosition = scale * new Vector3(PointerDisplayCols / 2f * -1024f + 512f + col * 1024f, PointerDisplayRows / 2f * 512f - 256f - row * 512f, 0);

                item.displayObject.GetComponent <RectTransform>().localScale = new Vector3(scale, scale, scale);

                switch (item.Type)
                {
                case Item.TYPE.POINTER:

                    if (item.TimeOut == 0 && !GENERAL.ALLPOINTERS.Contains(item.StoryPointer))
                    {
                        item.TimeOut = Time.time + 1f;
                    }

                    StoryTask theTask = item.StoryPointer.currentTask;

                    if (theTask == null || item.displayObject == null)
                    {
                        return;
                    }

                    if (theTask.Instruction != "wait" && theTask.Instruction != "end")
                    {
                        //    string displayText = theTask.scope == SCOPE.GLOBAL ? "G| " : "L| ";

                        string displayText = theTask.Instruction;

                        // If a task has a value for "debug" we display it along with task description.

                        string debugText;

                        if (theTask.GetStringValue("debug", out debugText))
                        {
                            displayText = displayText + " | " + debugText;
                        }

                        item.deusText.text      = displayText;
                        item.deusTextSuper.text = theTask.Pointer.currentPoint.StoryLine + " " + GENERAL.ALLPOINTERS.Count + (theTask.scope == SCOPE.GLOBAL ? " G" : " L");
                    }
                    else
                    {
                        item.deusTextSuper.text = theTask.Pointer.currentPoint.StoryLine;
                    }

                    break;

                case Item.TYPE.DATA:

                    /*
                     * item.deusText.text = item.StoryData.GetChangeLog();
                     * item.deusTextSuper.text = "data: " + item.StoryData.ID + GENERAL.ALLDATA.Count;
                     */
                    break;

                default:
                    break;
                }
            }
        }
Beispiel #13
0
        public bool HandleTask(StoryTask task)
        {
            bool done = false;

            switch (task.Instruction)
            {
            case "pause1":

                float timeOut1;

                if (!task.GetFloatValue("timeOut", out timeOut1))
                {
                    task.SetFloatValue("timeOut", Time.time + 1f);
                }
                else
                {
                    if (Time.time > timeOut1)
                    {
                        done = true;
                    }
                }
                break;

            case "pause5":

                float timeOut5;

                if (!task.GetFloatValue("timeOut", out timeOut5))
                {
                    task.SetFloatValue("timeOut", Time.time + 5f);
                }
                else
                {
                    if (Time.time > timeOut5)
                    {
                        done = true;
                    }
                }
                break;


            case "pause10":

                float timeOut10;

                if (!task.GetFloatValue("timeOut", out timeOut10))
                {
                    task.SetFloatValue("timeOut", Time.time + 5f);
                }
                else
                {
                    if (Time.time > timeOut10)
                    {
                        done = true;
                    }
                }
                break;

            case "debugon":

                GENERAL.Debugging = true;
                //DeusCanvas.SetActive(true);

                done = true;
                break;


            case "debugoff":
                GENERAL.Debugging = false;
                //DeusCanvas.SetActive(false);
                done = true;
                break;


            case "toggledebug":
            case "debugtoggle":
                GENERAL.Debugging = !GENERAL.Debugging;

                //DeusCanvas.SetActive(!DeusCanvas.activeSelf);
                done = true;
                break;

            default:
                done = true;

                break;
            }

            return(done);
        }
Beispiel #14
0
        bool HandleTask(StoryTask task)
        {
            //#if UNITY_EDITOR && UNITY_IOS

            //            // Pause applicatin simulation for debugging.

            //            if (Input.GetKeyDown("p"))
            //            {
            //                OnApplicationPause(true);
            //            }

            //            if (Input.GetKeyDown("o"))
            //            {
            //                OnApplicationPause(false);
            //            }

            //            if (state == STATE.PAUSED)
            //                return;

            //#endif



            //if (displayNetworkGUIState())
            //    SetNetworkIndicators();



            // Task needs to be executed.
            // first check for storyengine tasks.
            bool done = false;

            switch (task.Instruction)
            {
            // ---------------------------- SCOPE ----------------------------

            case "isglobal":

                if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL)
                {
                    task.Pointer.scope = SCOPE.GLOBAL;
                    Log("Setting pointer scope to global: " + task.Pointer.currentPoint.StoryLine);
                }
                else
                {
                    Log("No global authority, not changing pointer scope. ");
                }

                done = true;
                break;

            case "islocal":

                task.Pointer.SetLocal();

                Log("Setting pointer scope to local: " + task.Pointer.currentPoint.StoryLine);

                done = true;
                break;

            case "setglobalauth":
            case "amhub":

                GENERAL.AUTHORITY = AUTHORITY.GLOBAL;
                Log("Setting authority to global");
                //     AlertHandler.Log("Launching environment " + SessionSettings.Environment);
                //      Log("Launching " + Management.UserSettingsHandler.GetActiveModuleName() + ", environment " + StorageSettings.Environment);

                done = true;
                break;

            case "setlocalauth":
            case "amremote":

                GENERAL.AUTHORITY = AUTHORITY.LOCAL;
                Log("Setting authority to local");
                //    AlertHandler.Log("Launching environment " + SessionSettings.Environment);
                //  Log("Launching " + Management.UserSettingsHandler.GetActiveModuleName() + ", environment " + StorageSettings.Environment);

                done = true;
                break;


            // ---------------------------- SERVER SIDE ----------------------------

            case "startserver":

                // Start broadcast and network server if not already going.

                if (!Broadcasting)
                {
                    if (BroadcastKey == 0 || BroadcastMessageString == null || BroadcastMessageString.Length == 0)
                    {
                        // no info on how to configure broadcasterver

                        Warning("No broadcast info, not starting broadcastserver.");
                    }
                    else
                    {
                        startBroadcastServer(BroadcastKey, BroadcastMessageString);
                        Log("Starting broadcast server, key: " + BroadcastKey + " message: " + BroadcastMessageString);
                    }

                    //ModuleInfo mi = SessionData.GetModuleInfo();

                    //if (mi != null)
                    //{
                    //    startBroadcastServer(mi.BroadcastKey, mi.ID);
                    //    Log("Starting broadcast server, key: " + mi.BroadcastKey + " message: " + mi.ID);
                    //}
                    //else
                    //{
                    //    Warning("No module info, starting generic broadcast server.");
                    //    Log("key: " + ConnectionKey + " message: " + ConnectionMessage);
                    //    startBroadcastServer(ConnectionKey, ConnectionMessage);
                    //}
                }

                if (!Serving)
                {
                    Log("Starting network server.");
                    startNetworkServer();
                }

                done = true;
                break;

            case "stopserver":

                // Stop broadcast and network server

                Log("Stopping broadcast server.");
                stopBroadcast();

                Log("Stopping network server.");
                stopNetworkServer();

                done = true;
                break;

            case "monitorconnections":

                if (NetworkObject == null || state == STATE.PAUSED)
                {
                    break;
                }

                // Keep servers up on IOS (because of application pause)

#if UNITY_IOS
                if (!Broadcasting)
                {
                    Log("Starting broadcast server, key " + BroadcastKey + " message " + BroadcastMessageString);
                    //startBroadcastServer(ConnectionKey, ConnectionMessage);
                    startBroadcastServer(BroadcastKey, BroadcastMessageString);
                }

                if (!Serving)
                {
                    Log("Starting network server.");
                    startNetworkServer();
                }
#endif



                // Watch for new clients. Stays live indefinitely.

                if (Serving && NewTrackedAddresses())
                {
                    // new addresses connected since last call

                    foreach (string add in NewConnectedAddresses())
                    {
                        Log("New client at " + add);
                        // note: pass addresses on so we can send targeted messages...
                    }

                    task.setCallBack("addclient");
                }

                if (networkManager != null)
                {
                    NetworkConnection[] connections = networkManager.GetConnectedClients();
                    task.SetStringValue("debug", "clients: " + connections.Length);
                    WasConnected = connections.Length > 0;
                }
                else
                {
                    Warning("Network manager not available, cannot monitor connections");
                }


                //task.SetStringValue("debug", "clients: " + TrackedConnectedAddresses().Count);
                //WasConnected = TrackedConnectedAddresses().Count > 0;

                break;


            //case "pushglobaldata":



            //    done = true;
            //    break;


            case "pushglobaltasks":

                // go over all pointers  and mark everything as modified
                // that way it'll get sent.
                // with single client apps this is ok, but for multiple clients we need something more advanced

                Log("Pushing global tasks.");

                foreach (StoryTask theTask in GENERAL.ALLTASKS)
                {
                    if (theTask.scope == SCOPE.GLOBAL)
                    {
                        theTask.MarkAllAsModified();
                    }
                }

                done = true;
                break;

            // ---------------------------- CLIENT SIDE ----------------------------

            case "serversearch":

                if (NetworkObject == null || state == STATE.PAUSED)
                {
                    break;
                }

                if (Listening)
                {
                    if (foundServer())
                    {
                        stopBroadcast();

                        string   message = networkBroadcast.serverMessage;
                        char[]   param   = { '\0' };
                        string[] split   = message.Split(param);

                        task.SetStringValue("persistantData", split[0]);

                        task.setCallBack("serverfound");

                        Listening = false;

                        Log("Found broadcast server: " + networkBroadcast.serverAddress + " key: " + networkBroadcast.broadcastKey + " message: " + split[0]);


                        done = true;
                    }
                }
                else
                {
                    /*
                     * ModuleInfo mi = SessionData.GetModuleInfo();
                     * if (mi != null)
                     * {
                     *  startBroadcastClient(mi.BroadcastKey);
                     *  Log("(Re)starting broadcast listening for key " + mi.BroadcastKey);
                     * }
                     * else
                     * {
                     *  startBroadcastClient(BroadcastKey);
                     *  Log("(Re)starting broadcast listening for key " + BroadcastKey);
                     * }
                     */

                    startBroadcastClient(BroadcastKey);
                    Log("(Re)starting broadcast listening for key " + BroadcastKey);

                    Listening = true;
                }

                break;



            case "startclient":

                string ServerAddress = networkBroadcast.serverAddress;

                if (ServerAddress != "")
                {
                    //        Log("Starting network client for remote server " + ServerAddress);
                    startNetworkClient(ServerAddress);
                }
                else
                {
                    Warning("Trying to start client without server address.");
                }

                done = true;
                break;

            case "stopclient":

                //          Verbose("Stopping network client.");

                StopNetworkClient();
                WasConnected = false;

                done = true;

                break;

            case "monitorserver":

                // Watches the connection, stays active until connection lost.

                if (clientIsConnected())
                {
                    WasConnected = true;
                }
                else
                {
                    if (WasConnected)
                    {
                        // Lost connection. Restart server search.

                        Log("Lost server connection.");

                        StopNetworkClient();
                        WasConnected = false;
                        task.setCallBack("client");

                        done = true;
                    }
                    else
                    {
                        //
                    }
                }

                break;



            default:

                done = true;

                break;
            }
            return(done);
        }
Beispiel #15
0
        /*
         * private async void LoadScript()
         * {
         *  if (scriptAddressable != null && scriptAddressable != "")
         *  {
         *      theDirector.status = DIRECTORSTATUS.PAUSED;
         *      AsyncOperationHandle<TextAsset> handle = Addressables.LoadAssetAsync<TextAsset>(scriptAddressable);
         *      await handle.Task;
         *
         *      if (handle.Status==)
         *      if (handle.Result == null)
         *      {
         *          Error("Addressable script asset failed: " + obj.OperationException.Message);
         *
         *      }
         *      else
         *      {
         *
         *          theDirector.loadScriptAsset(obj.Result);
         *          Log("Script loaded, from addressable asset.");
         *
         *
         *      }
         *
         *  }
         *
         *
         *
         *
         *
         *  // The task is complete. Be sure to check the Status is successful before storing the Result.
         *
         * }
         *
         */



        #region SENDUPDATES


        void LateUpdate()
        {
            // Check if any data changed during this frame, and send updates across network.

            StoryUpdate storyUpdate = new StoryUpdate(); // Contains a collection of task and pointer updates.


            // Is there a networkhandler.

            if (NetworkHandler.Instance != null)
            {
                int Queue = NetworkHandler.Instance.GetQueueSize();

                if (Queue == -1)
                {
                    //  Verbose("no network active");
                }
                else
                {
                    switch (Queue)
                    {
                    case 0:
                        BufferStatusOut = 0;
                        break;

                    case 1:
                    case 2:
                        BufferStatusOut = 1;
                        break;

                    default:
                        BufferStatusOut = 2;
                        break;
                    }

                    // forcing always send.
                    // this means that a storyupdate is sent for every frame and they all arrive in order.
                    // they get executed in order as well, but they may be batched together.
                    // so multiple tasks might get executed in a single frame. they will be executed in the correct order.

                    if (Queue < 3 || true)
                    {
                        // Iterate over all pointers to see if any were killed. Clients do not kill pointers themselves.
                        // For consistency of network logic, local pointers that were killed are disposed by the director.
                        // Global pointers are disposed here, after updating clients about them.

                        for (int p = GENERAL.ALLPOINTERS.Count - 1; p >= 0; p--)
                        {
                            StoryPointer pointer = GENERAL.ALLPOINTERS[p];

                            if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL && pointer.scope == SCOPE.GLOBAL && pointer.GetStatus() == POINTERSTATUS.KILLED)

                            //if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL && pointer.scope == SCOPE.GLOBAL && pointer.modified && pointer.GetStatus() == POINTERSTATUS.KILLED)
                            {
                                Log("Sending pointer kill update to clients: " + pointer.currentPoint.StoryLine);

                                storyUpdate.AddStoryPointerUpdate(pointer.GetUpdate()); // bundled

                                //pointer.modified = false;

                                Log("Removing pointer " + pointer.currentPoint.StoryLine);

                                GENERAL.ALLPOINTERS.Remove(pointer);
                            }
                        }

                        // Iterate over all tasks.

                        for (int i = GENERAL.ALLTASKS.Count - 1; i >= 0; i--)
                        {
                            StoryTask task = GENERAL.ALLTASKS[i];

                            // Cleanup completed tasks.

                            if (task.getStatus() == TASKSTATUS.COMPLETE)
                            {
                                GENERAL.ALLTASKS.RemoveAt(i);

                                Verbose("Task " + task.Instruction + " on storyline " + task.Pointer.currentPoint.StoryLine + " completed, removed from alltasks. ");
                            }

                            if (task.modified)
                            {
                                // Debugging: if a pointer is in the process of being killed, we may want to not send task updates
                                // as they might result in the task being recreated clientside.

                                if (task.Pointer.GetStatus() == POINTERSTATUS.KILLED)
                                {
                                    Warning("Supressing sending task update for task with pointer that is dying. " + task.Instruction);
                                }
                                else
                                {
                                    // Check if we need to send network updates.

                                    switch (GENERAL.AUTHORITY)
                                    {
                                    case AUTHORITY.LOCAL:

                                        if (task.scope == SCOPE.GLOBAL)
                                        {
                                            Verbose("Global task " + task.Instruction + " with id " + task.PointID + " changed, adding to update for server.");

                                            storyUpdate.AddTaskUpdate(task.GetUpdate());     // bundled
                                        }

                                        break;

                                    case AUTHORITY.GLOBAL:

                                        if (task.scope == SCOPE.GLOBAL)
                                        {
                                            Verbose("Global task " + task.Instruction + " with id " + task.PointID + " changed, adding to update for clients.");

                                            storyUpdate.AddTaskUpdate(task.GetUpdate());     // bundled
                                        }

                                        break;

                                    default:

                                        break;
                                    }

                                    task.modified = false;
                                }
                            }
                        }

                        // If anything to send, send.

                        if (storyUpdate.AnythingToSend())

                        {
                            switch (GENERAL.AUTHORITY)
                            {
                            case AUTHORITY.LOCAL:

                                if (NetworkHandler.Instance != null)
                                {
                                    NetworkHandler.Instance.SendStoryUpdateToServer(storyUpdate);
                                }
                                Log("Sending story update to server. \n" + storyUpdate.DebugLog);

                                break;

                            case AUTHORITY.GLOBAL:

                                if (NetworkHandler.Instance != null)
                                {
                                    NetworkHandler.Instance.SendStoryUpdateToClients(storyUpdate);
                                }

                                Log("Sending story update to clients. \n" + storyUpdate.DebugLog);
                                //Debug.Log(storyUpdate.ToString());

                                break;

                            default:
                                break;
                            }
                        }
                    }
                }



                /*
                 *
                 *
                 *
                 *          if (NetworkHandler.Instance.IsClient())
                 *          {
                 *              StoryUpdate storyUpdate = new StoryUpdate(); // Contains a collection of dataupdates.
                 *
                 *              // Iterate over all data.
                 *
                 *              for (int i = GENERAL.ALLTASKS.Count - 1; i >= 0; i--)
                 *              {
                 *                  StoryTask data = GENERAL.ALLTASKS[i];
                 *
                 *                  if (data.modified)
                 *                  {
                 *                      // Data was modified locally, if global, compile an update for the server.
                 *
                 *                      if (data.scope == SCOPE.GLOBAL)
                 *                      {
                 *                          Verbose("Data was modified locally as client, creating update for server for " + data.ID);
                 *                          storyUpdate.AddDataUpdate(data.GetDataUpdate()); // bundled
                 *                      }
                 *
                 *                      data.modified = false;
                 *                  }
                 *              }
                 *
                 *              // If anything to send, send.
                 *
                 *              if (storyUpdate.AnythingToSend())
                 *
                 *              {
                 *
                 *                 NetworkHandler.Instance.SendStoryUpdateToServer(storyUpdate);
                 *
                 *                  Verbose("Sending story update to server. \n" + storyUpdate.DebugLog);
                 *
                 *
                 *
                 *              }
                 *
                 *
                 *
                 *          }
                 *
                 *
                 *
                 *
                 *          // If server, messages may differ for clients.
                 *
                 *
                 *          if (NetworkHandler.Instance.IsServer())
                 *          {
                 *
                 *              string[] clients = NetworkHandler.Instance.TrackedConnectedAddresses().ToArray();
                 *
                 *              for (int c = 0; c < clients.Length; c++)
                 *              {
                 *
                 *                  StoryUpdate storyUpdate = new StoryUpdate(); // Contains a collection of dataupdates.
                 *
                 *                  // Iterate over all data.
                 *
                 *                  for (int i = GENERAL.ALLTASKS.Count - 1; i >= 0; i--)
                 *                  {
                 *                      StoryTask data = GENERAL.ALLTASKS[i];
                 *
                 *                      if (data.modified)
                 *                      {
                 *                          // Data was modified locally, if global, compile an update for the server.
                 *
                 *                          if (data.scope == SCOPE.GLOBAL)
                 *                          {
                 *                              Verbose("Data was modified locally as client, creating update for server for " + data.ID);
                 *                              storyUpdate.AddDataUpdate(data.GetDataUpdateFor(clients[c])); // bundled
                 *                          }
                 *
                 *                          data.modified = false;
                 *                      }
                 *                  }
                 *
                 *                  // If anything to send, send.
                 *
                 *                  if (storyUpdate.AnythingToSend())
                 *
                 *                  {
                 *                      NetworkHandler.Instance.SendStoryUpdateToClient(storyUpdate, clients[c]);
                 *
                 *                      Verbose("Sending story update to client. \n" + storyUpdate.DebugLog);
                 *
                 *
                 *
                 *                  }
                 *
                 *
                 *              }
                 *
                 *
                 *
                 *
                 *          }
                 *
                 *
                 */
            }
        }
Beispiel #16
0
        void Update()
        {
            SetDebugLevels();

            #region APPLYUPDATES

            if (NetworkHandler.Instance != null)
            {
                // Handle story updates, aiming for 1 per frame, assuming we're tyring to run in sync.
                // Lowest numbers are oldest.

                int UpdateCount = NetworkHandler.Instance.StoryUpdateStack.Count;

                switch (UpdateCount)
                {
                case 0:
                    BufferStatusIn = 0;
                    break;

                case 1:

                    // exactly one, so apply.

                    ApplyStoryUpdate(NetworkHandler.Instance.StoryUpdateStack[0]);
                    NetworkHandler.Instance.StoryUpdateStack.RemoveAt(0);
                    BufferStatusIn = 1;

                    break;

                case 2:

                    // Two, normally for different frames that happened to arrive in the same frame on this end.
                    // Apply the oldest one, keep the other because we expect to get 0 updates during our next frame
                    // (If we're on similar fps)

                    ApplyStoryUpdate(NetworkHandler.Instance.StoryUpdateStack[0]);
                    NetworkHandler.Instance.StoryUpdateStack.RemoveAt(0);
                    BufferStatusIn = 1;

                    break;

                default:

                    // More than 2. Apply all the older ones in order of arrival, keep latest one because we may get 0 next frame.

                    Warning("Update buffer >2");
                    BufferStatusIn = 2;

                    while (NetworkHandler.Instance.StoryUpdateStack.Count > 1)
                    {
                        ApplyStoryUpdate(NetworkHandler.Instance.StoryUpdateStack[0]);
                        NetworkHandler.Instance.StoryUpdateStack.RemoveAt(0);
                    }

                    break;
                }
            }

            #endregion

            #region DIRECTOR

            switch (theDirector.status)
            {
            case DIRECTORSTATUS.ACTIVE:

                //   Verbose("Director active .");

                foreach (StoryTask task in GENERAL.ALLTASKS)
                {
                    if (task.getCallBack() != "")
                    {
                        // if a callback was set (somewhere on the network) we act on it only if we are the server or if the task is local.

                        if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL || task.scope == SCOPE.LOCAL)
                        //  if (true || task.scope == SCOPE.LOCAL)
                        {
                            task.Pointer.SetStatus(POINTERSTATUS.TASKUPDATED);
                        }
                    }
                }

                theDirector.EvaluatePointers();

                List <StoryTask> newTasks = new List <StoryTask>();

                for (int p = 0; p < GENERAL.ALLPOINTERS.Count; p++)
                {
                    StoryPointer pointer = GENERAL.ALLPOINTERS[p];

                    switch (pointer.scope)
                    {
                    case SCOPE.GLOBAL:

                        // If pointer scope is global, we add a task if our own scope is global as well. (If our scope is local, we'll be receiving the task over the network)

                        if (GENERAL.AUTHORITY == AUTHORITY.GLOBAL)
                        //      if (true)
                        {
                            if (pointer.GetStatus() == POINTERSTATUS.NEWTASK)
                            {
                                pointer.SetStatus(POINTERSTATUS.PAUSED);

                                StoryTask task = pointer.SpawnTask();



                                //  StoryTask task = new StoryTask(pointer, SCOPE.GLOBAL);
                                task.LoadPersistantData(pointer);

                                newTasks.Add(task);
                                task.modified = true;

                                Verbose("Created global task " + task.Instruction + " with pointid " + task.PointID + " for pointer " + pointer.currentPoint.StoryLine);
                            }
                        }

                        break;

                    case SCOPE.LOCAL:
                    default:

                        // If pointer scope is local, check if new tasks have to be generated.

                        if (pointer.GetStatus() == POINTERSTATUS.NEWTASK)
                        {
                            pointer.SetStatus(POINTERSTATUS.PAUSED);
                            StoryTask task = pointer.SpawnTask();

                            //StoryTask task = new StoryTask(pointer, SCOPE.LOCAL);
                            task.LoadPersistantData(pointer);

                            newTasks.Add(task);


                            Verbose("Created local task " + task.Instruction + " with pointid " + task.PointID + " for pointer " + pointer.currentPoint.StoryLine);
                        }

                        break;
                    }
                }

                if (newTasks.Count > 0)
                {
                    if (newTasksEventUnity != null)
                    {
                        newTasksEventUnity.Invoke(newTasks);
                    }
                    //     if (newTasksEvent != null) newTasksEvent(this, new TaskArgs(newTasks)); // trigger the event, if there are any listeners

                    //  DistributeTasks(new TaskArgs(newTasks)); // if any new tasks call an event, passing on the list of tasks to any handlers listening
                }

                break;

            case DIRECTORSTATUS.READY:

                int SIGNOFFS = eventHandlerCount();

                if (SIGNOFFS == 0)
                {
                    Error("No handlers registred. Pausing director.");
                    theDirector.status = DIRECTORSTATUS.PAUSED;
                }
                else
                {
                    Verbose("" + SIGNOFFS + " handlers registred at this time.");

                    Verbose("Starting storyline " + launchStoryline);

                    theDirector.NewStoryLine(launchStoryline);
                    theDirector.status = DIRECTORSTATUS.ACTIVE;
                }

                break;

            case DIRECTORSTATUS.NOTREADY:

                // try addressable script first.

                //if (scriptAddressable != null && scriptAddressable != "")
                //{
                //    // pause while loading
                //    theDirector.status = DIRECTORSTATUS.PAUSED;



                //    Addressables.LoadAssetAsync<TextAsset>(scriptAddressable).Completed += obj =>
                //    {
                //        if (obj.Result == null)
                //        {
                //            Error("Addressable script asset failed: " + obj.OperationException.Message);

                //        }
                //        else
                //        {

                //            theDirector.loadScriptAsset(obj.Result);
                //            Log("Script loaded, from addressable asset.");


                //        }



                //    };

                //}


                if (scriptFile != null && scriptFile != "")
                {
                    // we have a reference to a local script file, so we'll attempt to load it (synchronous). we try to load it from a folder with the current version

                    string script = Transport.FileToText(Application.persistentDataPath + "/scripts/" + App.GetMinor() + "/" + scriptFile);

                    if (script == "")
                    {
                        Log("No script on disk for version: " + App.GetMinor());
                    }
                    else
                    {
                        theDirector.loadScriptText(script);
                        Log("Script loaded, from local file.");
                        break;
                    }
                }

                if (scriptAsset != null)
                {
                    theDirector.loadScriptAsset(scriptAsset);
                    Log("Script loaded, from asset.");
                    break;
                }

                Error("No script reference found, pausing director.");

                theDirector.status = DIRECTORSTATUS.PAUSED;
                break;

            default:
                break;
            }

            #endregion
        }