Esempio n. 1
0
 public static void sendMessage <T0, T1, T2, T3, T4, T5>(this GameObject target, string name, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
 {
     if (target.enabled)
     {
         Event <T0, T1, T2, T3, T4, T5> .Invoke(target.id, name, t0, t1, t2, t3, t4, t5);
     }
 }
Esempio n. 2
0
 public static void sendMessage <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this GameObject target, string name, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
 {
     if (target.enabled)
     {
         Event <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> .Invoke(target.id, name, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
     }
 }
Esempio n. 3
0
 public static void sendMessage <T0, T1, T2>(this GameObject target, string name, T0 t0, T1 t1, T2 t2)
 {
     if (target.enabled)
     {
         Event <T0, T1, T2> .Invoke(target.id, name, t0, t1, t2);
     }
 }
Esempio n. 4
0
 public static void sendMessage <T0>(this GameObject target, string name, T0 t0)
 {
     if (target.enabled)
     {
         Event <T0> .Invoke(target.id, name, t0);
     }
 }
Esempio n. 5
0
        //public static Matrix TransoformMatrix
        //{
        //    get { return Matrix.CreateTranslation(new Vector3(-Position, 0)); }
        //}
        private void draw()
        {
            current = this;
            //Event.Invoke("beforerender");
            Event.Invoke("render");

            ondraw();
            postprocess();
        }
Esempio n. 6
0
 public static void sendMessageDown <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this GameObject target, string name, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
 {
     if (target.enabled)
     {
         foreach (var c in target.allEnabledChildren())
         {
             Event <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> .Invoke(c.id, name, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
         }
     }
 }
Esempio n. 7
0
 public static void sendMessageDown <T0, T1, T2, T3, T4>(this GameObject target, string name, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4)
 {
     if (target.enabled)
     {
         foreach (var c in target.allEnabledChildren())
         {
             Event <T0, T1, T2, T3, T4> .Invoke(c.id, name, t0, t1, t2, t3, t4);
         }
     }
 }
Esempio n. 8
0
 public static void sendMessageDown <T0>(this GameObject target, string name, T0 t0)
 {
     if (target.enabled)
     {
         foreach (var c in target.allEnabledChildren())
         {
             Event <T0> .Invoke(c.id, name, t0);
         }
     }
 }
Esempio n. 9
0
 public static void sendMessageDown(this GameObject target, string name)
 {
     if (target.enabled)
     {
         foreach (var c in target.allChildren())
         {
             Event.Invoke(c.id, name);
         }
     }
 }
Esempio n. 10
0
 public static void sendMessage(this GameObject target, string name)
 {
     if (target.enabled)
     {
         //foreach (var c in target.components)
         //    if (c.enabled)
         //MessageProxy.invoke(c, name, args);
         Event.Invoke(target.id, name);
     }
 }
Esempio n. 11
0
 public static void broadcast(this GameObject target, string name)
 {
     if (target.enabled)
     {
         Event.Invoke(target.id, name);
         foreach (var c in target.allEnabledChildren())
         {
             Event.Invoke(c.id, name);
         }
     }
 }
Esempio n. 12
0
        internal void update(double newTime)
        {
            _instance = this;

            #region Entities
            for (var i = 0; i < _destroySystems.Count; i++)
            {
                _destroySystems[i].destroy();
                _systems.Remove(_destroySystems[i]);
            }

            _destroySystems.Clear();

            for (var i = 0; i < _initSystems.Count; i++)
            {
                _initSystems[i].init();
                _systems.Add(_initSystems[i]);
            }

            _initSystems.Clear();

            while (_removeEntities.Count > 0)
            {
                var next  = _removeEntities[_removeEntities.Count - 1];
                var index = _entities.IndexOf(next);

                if (index == -1)
                {
                    throw new ArgumentOutOfRangeException("index");
                }

                if (_addEntities.Count > 0)
                {
                    _entities[index] = _addEntities[_addEntities.Count - 1];
                    _addEntities.RemoveAt(_addEntities.Count - 1);

                    if (add != null)
                    {
                        add(_entities[index]);
                    }
                }

                if (remove != null)
                {
                    remove(_removeEntities[_removeEntities.Count - 1]);
                }

                _removeEntities.RemoveAt(_removeEntities.Count - 1);
            }

            while (_addEntities.Count > 0)
            {
                _entities.Add(_addEntities[_addEntities.Count - 1]);
                _addEntities.RemoveAt(_addEntities.Count - 1);

                if (add != null)
                {
                    add(_entities[_entities.Count - 1]);
                }
            }

            for (var i = 0; i < _systems.Count; i++)
            {
                _systems[i].update();
            }

            #endregion

            foreach (var go in destroyList)
            {
                go.internalDestroy();
            }

            destroyList.Clear();

            processNewScripts();

            while (Event.Count("init") > 0)
            {
                Event.Invoke("init");
                Event.Clear("init");

                processNewScripts();

                foreach (var newgo in newGameObjects)
                {
                    newgo.parent.forceSendMessage("childadded", newgo);
                }

                newGameObjects.Clear();
            }

            Root.instance.input.update();

            double frameTime = newTime - time.realtimeSinceStartupD;

            // note: max frame time to avoid spiral of death
            if (frameTime > time.maximumDeltaTimeD * time.timeScale)
            {
                frameTime = time.maximumDeltaTimeD * time.timeScale;
            }

            accumulator += frameTime;

            if (accumulator >= time.fixedDeltaTimeD)
            {
                while (accumulator >= time.fixedDeltaTimeD)
                {
                    accumulator -= time.fixedDeltaTimeD;

                    time.updateFixed(time.fixedDeltaTimeD);

                    lastFixedUpdate = 0;
                    timer.Reset();
                    timer.Start();

                    //call fixed update
                    Event.Invoke("beforefixedupdate");
                    Event.Invoke("fixedupdate");
                    Event.Invoke("afterfixedupdate");

                    timer.Stop();
                    lastFixedUpdate   = timer.ElapsedMilliseconds;
                    totalFixedUpdate += lastFixedUpdate;
                    //messageCache.invoke("fixedupdate");
                    //Console.WriteLine("fixed update");
                }
            }

            time.update(newTime, frameTime);

            lastUpdate = 0;
            timer.Reset();
            timer.Start();

            Event.Invoke("beforeupdate");
            Event.Invoke("update");
            Event.Invoke("afterupdate");

            timer.Stop();
            lastUpdate   = timer.ElapsedMilliseconds;
            totalUpdate += lastUpdate;

            //messageCache.invoke("update");

            //call update
            //Console.WriteLine("update {0}", time.smoothedTimeDeltaD);
        }
Esempio n. 13
0
 public static void forceSendMessage <T>(this GameObject target, string name, T t)
 {
     //foreach (var c in target.components)
     //MessageProxy.invoke(c, name, args);
     Event <T> .Invoke(target.id, name, t);
 }