Ejemplo n.º 1
0
 /// <summary>
 /// Starts a coroutine, the coroutine does not run immediately but on the
 /// next call to UpdateAllCoroutines. The execution of a coroutine can
 /// be paused at any point using the yield statement. The yield return value
 /// specifies when the coroutine is resumed.
 /// </summary>
 /// <param name="fiber">The fiber.</param>
 /// <returns></returns>
 public CoroutineNode StartCoroutine(IEnumerator fiber) {
     // if function does not have a yield, fiber will be null and we no-op
     if (fiber == null) {
         return null;
     }
     // create coroutine node and run until we reach first yield
     CoroutineNode coroutine = new CoroutineNode(fiber);
     AddCoroutine(coroutine);
     return coroutine;
 }
Ejemplo n.º 2
0
 private void RemoveCoroutine(CoroutineNode coroutine) {
     if (this._firstNode == coroutine) {
         // remove first
         this._firstNode = coroutine.listNext;
     }
     else {
         // not head of list
         if (coroutine.listNext != null) {
             // remove between
             coroutine.listPrevious.listNext = coroutine.listNext;
             coroutine.listNext.listPrevious = coroutine.listPrevious;
         }
         else if (coroutine.listPrevious != null) {
             // and listNext is null
             coroutine.listPrevious.listNext = null;
             // remove last
         }
     }
     coroutine.listPrevious = null;
     coroutine.listNext = null;
 }
Ejemplo n.º 3
0
        /**
       * Executes coroutine until next yield. If coroutine has finished, flags
       * it as finished and removes it from scheduler list.
       */
        private void UpdateCoroutine(CoroutineNode coroutine) {
            IEnumerator fiber = coroutine.fiber;
            if (coroutine.fiber.MoveNext()) {
                System.Object yieldCommand = fiber.Current == null ? (System.Object)1 : fiber.Current;

                if (yieldCommand.GetType() == typeof(int)) {
                    coroutine.waitForFrame = (int)yieldCommand;
                    coroutine.waitForFrame += (int)_currentFrame;
                }
                else if (yieldCommand.GetType() == typeof(float)) {
                    coroutine.waitForTime = (float)yieldCommand;
                    coroutine.waitForTime += (float)_currentTime;
                }
                else if (yieldCommand.GetType() == typeof(CoroutineNode)) {
                    coroutine.waitForCoroutine = (CoroutineNode)yieldCommand;
                }
                else {
                    throw new System.ArgumentException("CoroutineScheduler: Unexpected coroutine yield type: " + yieldCommand.GetType());
                }
            }
            else {
                // coroutine finished
                coroutine.finished = true;
                RemoveCoroutine(coroutine);
            }
        }
Ejemplo n.º 4
0
        private void AddCoroutine(CoroutineNode coroutine) {

            if (this._firstNode != null) {
                coroutine.listNext = this._firstNode;
                _firstNode.listPrevious = coroutine;
            }
            _firstNode = coroutine;
        }
Ejemplo n.º 5
0
 /// <summary>
 /// Stops all coroutines running on this behaviour. Use of this method is
 /// discouraged, think of a natural way for your coroutines to finish
 /// on their own instead of being forcefully stopped before they finish.
 /// If you need finer control over stopping coroutines you can use multiple
 /// schedulers.
 /// </summary>
 public void StopAllCoroutines() {
     _firstNode = null;
 }