Removed delay functionality from events. To work properly, it would need serialization when the scene is saved/loaded, but events may contain non-serializable data (pointers.) This is to be replaced with another, more manageable system.

Engine/Engine/Client.cpp

@@ -924,14 +924,9 @@ void Client::sendClientUpdate()
     std::vector<RemoteEvent>& outEvents = mScene->getQueuedRemoteEvents();
     for (std::vector<RemoteEvent>::iterator i = outEvents.begin(); i != outEvents.end();)
     {
-        if (i->mDelay <= 0.0f)
-        {
-            i->mFrameNumber = mFrameNumber;
-            mServerConnection->addRemoteEvent(*i);
-            i = outEvents.erase(i);
-        }
-        else
-            ++i;
+        i->mFrameNumber = mFrameNumber;
+        mServerConnection->addRemoteEvent(*i);
+        i = outEvents.erase(i);
     }
     
     static VectorBuffer packet;

Engine/Engine/RegisterEngine.cpp

@@ -48,11 +48,11 @@ static void SendRemoteEvent(const std::string& eventType, const VariantMap& even
         scene->sendRemoteEvent(StringHash(eventType), eventData, receiver);
 }
 
-static void SendRemoteEventDelayTTL(const std::string& eventType, const VariantMap& eventData, Connection* receiver, float delay, unsigned short timeToLive)
+static void SendRemoteEventTTL(const std::string& eventType, const VariantMap& eventData, Connection* receiver, unsigned short timeToLive)
 {
     Scene* scene = getScriptContextScene();
     if (scene)
-        scene->sendRemoteEvent(StringHash(eventType), eventData, receiver, delay, timeToLive);
+        scene->sendRemoteEvent(StringHash(eventType), eventData, receiver, timeToLive);
 }
 
 static void SendRemoteEntityEventToAll(Entity* entity, const std::string& eventType, const VariantMap& eventData)
@@ -69,11 +69,11 @@ static void SendRemoteEntityEvent(Entity* entity, const std::string& eventType,
         scene->sendRemoteEvent(entity, StringHash(eventType), eventData, receiver);
 }
 
-static void SendRemoteEntityEventDelayTTL(Entity* entity, const std::string& eventType, const VariantMap& eventData, Connection* receiver, float delay, unsigned short timeToLive)
+static void SendRemoteEntityEventTTL(Entity* entity, const std::string& eventType, const VariantMap& eventData, Connection* receiver, unsigned short timeToLive)
 {
     Scene* scene = getScriptContextScene();
     if (scene)
-        scene->sendRemoteEvent(entity, StringHash(eventType), eventData, receiver, delay, timeToLive);
+        scene->sendRemoteEvent(entity, StringHash(eventType), eventData, receiver, timeToLive);
 }
 
 static void ConstructNetUpdateInfo(NetUpdateInfo* ptr)
@@ -135,10 +135,10 @@ static void registerConnection(asIScriptEngine* engine)
     // Add remote event functionality as global functions because the Scene can be found out through the context
     engine->RegisterGlobalFunction("void sendRemoteEvent(const string& in, const VariantMap& in)", asFUNCTION(SendRemoteEventToAll), asCALL_CDECL);
     engine->RegisterGlobalFunction("void sendRemoteEvent(const string& in, const VariantMap& in, Connection@+)", asFUNCTION(SendRemoteEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void sendRemoteEvent(const string& in, const VariantMap& in, Connection@+, float, uint16)", asFUNCTION(SendRemoteEventDelayTTL), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void sendRemoteEvent(const string& in, const VariantMap& in, Connection@+, uint16)", asFUNCTION(SendRemoteEventTTL), asCALL_CDECL);
     engine->RegisterGlobalFunction("void sendRemoteEvent(Entity@+, const string& in, const VariantMap& in)", asFUNCTION(SendRemoteEntityEventToAll), asCALL_CDECL);
     engine->RegisterGlobalFunction("void sendRemoteEvent(Entity@+, const string& in, const VariantMap& in, Connection@+)", asFUNCTION(SendRemoteEntityEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void sendRemoteEvent(Entity@+, const string& in, const VariantMap& in, Connection@+, float, uint16)", asFUNCTION(SendRemoteEntityEventDelayTTL), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void sendRemoteEvent(Entity@+, const string& in, const VariantMap& in, Connection@+, uint16)", asFUNCTION(SendRemoteEntityEventTTL), asCALL_CDECL);
     engine->RegisterGlobalFunction("void registerLocalOnlyEvent(const string& in)", asFUNCTIONPR(registerLocalOnlyEvent, (const std::string&), void), asCALL_CDECL);
     engine->RegisterGlobalFunction("Connection@+ getRemoteEventSender()", asFUNCTION(getRemoteEventSender), asCALL_CDECL);
 }

Engine/Engine/RegisterScene.cpp

@@ -485,38 +485,6 @@ static CScriptArray* SceneGetScriptedEntitiesWithClass(const std::string& classN
     return vectorToHandleArray<Entity>(result, "array<Entity@>");
 }
 
-static void SendDelayedEvent(const std::string& eventType, const VariantMap& eventData, float delay)
-{
-    Scene* scene = getScriptContextScene();
-    if (scene)
-        scene->sendDelayedEvent(StringHash(eventType), eventData, delay);
-}
-
-static void SendDelayedEntityEvent(Entity* entity, const std::string& eventType, const VariantMap& eventData, float delay)
-{
-    Scene* scene = getScriptContextScene();
-    if (scene)
-        scene->sendDelayedEvent(entity, StringHash(eventType), eventData, delay);
-}
-
-static void SendDelayedComponentEvent(Component* component, const std::string& eventType, const VariantMap& eventData, float delay)
-{
-    Scene* scene = getScriptContextScene();
-    if (scene)
-    {
-        EventListener* listener = dynamic_cast<EventListener*>(component);
-        if (listener)
-            scene->sendDelayedEvent(listener, StringHash(eventType), eventData, delay);
-    }
-}
-
-static void ClearDelayedEvents()
-{
-    Scene* scene = getScriptContextScene();
-    if (scene)
-        scene->clearDelayedEvents();
-}
-
 static void registerScene(asIScriptEngine* engine)
 {
     engine->RegisterObjectBehaviour("Scene", asBEHAVE_ADDREF, "void f()", asMETHOD(Scene, addRef), asCALL_THISCALL);
@@ -564,12 +532,6 @@ static void registerScene(asIScriptEngine* engine)
     engine->RegisterGlobalFunction("Scene@+ getScene()", asFUNCTION(GetScene), asCALL_CDECL);
     engine->RegisterGlobalFunction("Scene@+ get_scene()", asFUNCTION(GetScene), asCALL_CDECL);
     
-    // Add delayed event functionality as global functions because the Scene can be found out through the context
-    engine->RegisterGlobalFunction("void sendDelayedEvent(const string& in, const VariantMap& in, float)", asFUNCTION(SendDelayedEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void sendDelayedEvent(Entity@+, const string& in, const VariantMap& in, float)", asFUNCTION(SendDelayedEntityEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void sendDelayedEvent(Component@+, const string& in, const VariantMap& in, float)", asFUNCTION(SendDelayedComponentEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void clearDelayedEvents()", asFUNCTION(ClearDelayedEvents), asCALL_CDECL);
-    
     // Register Variant getPtr() for Scene
     engine->RegisterObjectMethod("Variant", "Scene@+ getScene() const", asFUNCTION(getVariantPtr<Scene>), asCALL_CDECL_OBJLAST);
 }

Engine/Engine/Server.cpp

@@ -614,32 +614,27 @@ void Server::checkRemoteEvents()
         std::vector<RemoteEvent>& outEvents = scene->getQueuedRemoteEvents();
         for (std::vector<RemoteEvent>::iterator j = outEvents.begin(); j != outEvents.end();)
         {
-            if (j->mDelay <= 0.0f)
+            j->mFrameNumber = mFrameNumber;
+            
+            // Check for broadcast event
+            if (!j->mReceiver)
             {
-                j->mFrameNumber = mFrameNumber;
-                
-                // Check for broadcast event
-                if (!j->mReceiver)
+                for (unsigned k = 0; k < mConnections.size(); ++k)
                 {
-                    for (unsigned k = 0; k < mConnections.size(); ++k)
-                    {
-                        Connection* connection = mConnections[k];
-                        if (connection->getScene() == scene)
-                            connection->addRemoteEvent(*j);
-                    }
-                }
-                else
-                {
-                    // The connection stored in the event might not be valid by now, so verify it
-                    Connection* connection = verifyConnection(j->mReceiver);
-                    if (connection)
+                    Connection* connection = mConnections[k];
+                    if (connection->getScene() == scene)
                         connection->addRemoteEvent(*j);
                 }
-                
-                j = outEvents.erase(j);
             }
             else
-                ++j;
+            {
+                // The connection stored in the event might not be valid by now, so verify it
+                Connection* connection = verifyConnection(j->mReceiver);
+                if (connection)
+                    connection->addRemoteEvent(*j);
+            }
+            
+            j = outEvents.erase(j);
         }
     }
 }

Engine/Event/DelayedEventQueue.cpp

@@ -1,70 +0,0 @@
-//
-// Urho3D Engine
-// Copyright (c) 2008-2011 Lasse Öörni
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#include "DelayedEventQueue.h"
-
-DelayedEventQueue::DelayedEventQueue()
-{
-}
-
-DelayedEventQueue::~DelayedEventQueue()
-{
-}
-
-void DelayedEventQueue::sendDelayedEvent(StringHash eventType, const VariantMap& eventData, float delay)
-{
-    mDelayedEvents.push_back(DelayedEvent(eventType, eventData, delay));
-}
-
-void DelayedEventQueue::sendDelayedEvent(EventListener* receiver, StringHash eventType, const VariantMap& eventData, float delay)
-{
-    if (!receiver)
-        return;
-    
-    mDelayedEvents.push_back(DelayedEvent(receiver, eventType, eventData, delay));
-}
-
-void DelayedEventQueue::processDelayedEvents(float timeStep)
-{
-    for (std::vector<DelayedEvent>::iterator i = mDelayedEvents.begin(); i != mDelayedEvents.end();)
-    {
-        i->mDelay -= timeStep;
-        if (i->mDelay <= 0.0f)
-        {
-            if (!i->mReceiver)
-                sendEvent(i->mEventType, i->mEventData);
-            else
-                // The event receiver might not exist anymore, so use indirect send
-                sendEvent(i->mReceiver, i->mEventType, i->mEventData, false);
-            i = mDelayedEvents.erase(i);
-        }
-        else
-            ++i;
-    }
-}
-
-void DelayedEventQueue::clearDelayedEvents()
-{
-    mDelayedEvents.clear();
-}
-

Engine/Event/DelayedEventQueue.h

@@ -1,95 +0,0 @@
-//
-// Urho3D Engine
-// Copyright (c) 2008-2011 Lasse Öörni
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef EVENT_DELAYEDEVENTQUEUE_H
-#define EVENT_DELAYEDEVENTQUEUE_H
-
-#include "Event.h"
-
-class EventListener;
-
-//! Delayed event
-struct DelayedEvent
-{
-    //! Construct with no event data
-    DelayedEvent() :
-        mReceiver(0),
-        mDelay(0.0f)
-    {
-    }
-    
-    //! Construct with event data but no receiver
-    DelayedEvent(StringHash eventType, const VariantMap& eventData, float delay) :
-        mReceiver(0),
-        mEventType(eventType),
-        mEventData(eventData),
-        mDelay(delay)
-    {
-    }
-    
-    //! Construct with event data and receiver
-    DelayedEvent(EventListener* receiver, StringHash eventType, const VariantMap& eventData, float delay) :
-        mReceiver(receiver),
-        mEventType(eventType),
-        mEventData(eventData),
-        mDelay(delay)
-    {
-    }
-    
-    //! Event receiver
-    EventListener* mReceiver;
-    //! Event type
-    StringHash mEventType;
-    //! Event parameters
-    VariantMap mEventData;
-    //! Delay until sending
-    float mDelay;
-};
-
-//! Stores delayed events
-class DelayedEventQueue
-{
-public:
-    //! Construct
-    DelayedEventQueue();
-    //! Destruct
-    virtual ~DelayedEventQueue();
-    
-    //! Store a delayed event with no receiver specified
-    void sendDelayedEvent(StringHash eventType, const VariantMap& eventData = VariantMap(), float delay = 0.0f);
-    //! Store a delayed event with receiver specified
-    void sendDelayedEvent(EventListener* receiver, StringHash eventType, const VariantMap& eventData = VariantMap(), float delay = 0.0f);
-    //! Update delay timers and send events as necessary
-    void processDelayedEvents(float timeStep);
-    //! Clear all delayed events
-    void clearDelayedEvents();
-    
-    //! Return all delayed events
-    const std::vector<DelayedEvent>& getDelayedEvents() const { return mDelayedEvents; }
-    
-private:
-    //! Delayed events
-    std::vector<DelayedEvent> mDelayedEvents;
-};
-
-#endif // EVENT_DELAYEDEVENTQUEUE_H

Engine/Scene/RemoteEvent.h

@@ -41,23 +41,21 @@ struct RemoteEvent
     }
     
     //! Construct with parameters
-    RemoteEvent(StringHash eventType, const VariantMap& eventData, Connection* receiver, float delay, unsigned short timeToLive) :
+    RemoteEvent(StringHash eventType, const VariantMap& eventData, Connection* receiver, unsigned short timeToLive) :
         mEntityID(0),
         mEventType(eventType),
         mEventData(eventData),
         mReceiver(receiver),
-        mDelay(delay),
         mTimeToLive(timeToLive)
     {
     }
     
     //! Construct with target entity and parameters
-    RemoteEvent(EntityID entityID, StringHash eventType, const VariantMap& eventData, Connection* receiver, float delay, unsigned short timeToLive) :
+    RemoteEvent(EntityID entityID, StringHash eventType, const VariantMap& eventData, Connection* receiver, unsigned short timeToLive) :
         mEntityID(entityID),
         mEventType(eventType),
         mEventData(eventData),
         mReceiver(receiver),
-        mDelay(delay),
         mTimeToLive(timeToLive)
     {
     }
@@ -79,8 +77,6 @@ struct RemoteEvent
     EntityID mEntityID;
     //! Receiving connection. If null on the server, broadcast to all. On client has no significance
     Connection* mReceiver;
-    //! Delay until sending
-    float mDelay;
     //! Time to live in network frames. If not acked when expires, will no longer be sent. 0 is infinite
     unsigned short mTimeToLive;
 };

Engine/Scene/Scene.cpp

@@ -82,10 +82,6 @@ void Scene::update(float timeStep)
     sceneUpdateData[P_TIMESTEP] = timeStep;
     sendEvent(EVENT_SCENEUPDATE, sceneUpdateData);
     
-    // Update delayed events & delayed remote events
-    processDelayedEvents(timeStep);
-    processRemoteEvents(timeStep);
-    
     // Update extensions
     for (std::map<ShortStringHash, SharedPtr<SceneExtension> >::iterator i = mExtensions.begin(); i != mExtensions.end(); ++i)
         i->second->update(timeStep);
@@ -714,7 +710,7 @@ void Scene::setInterpolationSnapThreshold(float threshold)
     mInterpolationSnapThreshold = threshold * threshold;
 }
 
-bool Scene::sendRemoteEvent(StringHash eventType, const VariantMap& eventData, Connection* receiver, float delay, unsigned short timeToLive)
+bool Scene::sendRemoteEvent(StringHash eventType, const VariantMap& eventData, Connection* receiver, unsigned short timeToLive)
 {
     if (!checkRemoteEvent(eventType))
     {
@@ -723,11 +719,11 @@ bool Scene::sendRemoteEvent(StringHash eventType, const VariantMap& eventData, C
     }
     
     // Put to outgoing queue. Server or Client will later assign framenumber and actually send
-    mRemoteEvents.push_back(RemoteEvent(eventType, eventData, receiver, delay, timeToLive));
+    mRemoteEvents.push_back(RemoteEvent(eventType, eventData, receiver, timeToLive));
     return true;
 }
 
-bool Scene::sendRemoteEvent(Entity* entity, StringHash eventType, const VariantMap& eventData, Connection* receiver, float delay, unsigned short timeToLive)
+bool Scene::sendRemoteEvent(Entity* entity, StringHash eventType, const VariantMap& eventData, Connection* receiver, unsigned short timeToLive)
 {
     if (!entity)
     {
@@ -746,7 +742,7 @@ bool Scene::sendRemoteEvent(Entity* entity, StringHash eventType, const VariantM
     }
     
     // Put to outgoing queue. Server or Client will later assign framenumber and actually send
-    mRemoteEvents.push_back(RemoteEvent(entity->getID(), eventType, eventData, receiver, delay, timeToLive));
+    mRemoteEvents.push_back(RemoteEvent(entity->getID(), eventType, eventData, receiver, timeToLive));
     return true;
 }
 
@@ -955,15 +951,6 @@ void Scene::removeEntity(std::map<EntityID, SharedPtr<Entity> >::iterator i)
     mEntities.erase(i);
 }
 
-void Scene::processRemoteEvents(float timeStep)
-{
-    for (std::vector<RemoteEvent>::iterator i = mRemoteEvents.begin(); i != mRemoteEvents.end(); ++i)
-    {
-        if (i->mDelay > 0.0f)
-            i->mDelay -= timeStep;
-    }
-}
-
 void Scene::updateAsyncLoading()
 {
     PROFILE(Scene_UpdateAsyncLoading);

Engine/Scene/Scene.h

@@ -25,7 +25,6 @@
 #define SCENE_SCENE_H
 
 #include "BoundingBox.h"
-#include "DelayedEventQueue.h"
 #include "Entity.h"
 #include "RemoteEvent.h"
 #include "VectorBuffer.h"
@@ -44,7 +43,7 @@ class Serializer;
 class XMLFile;
 
 //! A simulated world consisting of entities
-class Scene : public RefCounted, public EventListener, public DelayedEventQueue
+class Scene : public RefCounted, public EventListener
 {
 public:
     //! Construct with resource cache pointer and name
@@ -118,9 +117,9 @@ public:
     //! Set visual smoothing position snap threshold
     void setInterpolationSnapThreshold(float threshold);
     //! Queue a remote event to be sent
-    bool sendRemoteEvent(StringHash eventType, const VariantMap& eventData = VariantMap(), Connection* receiver = 0, float delay = 0.0f, unsigned short timeToLive = 0);
+    bool sendRemoteEvent(StringHash eventType, const VariantMap& eventData = VariantMap(), Connection* receiver = 0, unsigned short timeToLive = 0);
     //! Queue a remote entity event to be sent
-    bool sendRemoteEvent(Entity* entity, StringHash eventType, const VariantMap& eventData = VariantMap(), Connection* receiver = 0, float delay = 0.0f, unsigned short timeToLive = 0);
+    bool sendRemoteEvent(Entity* entity, StringHash eventType, const VariantMap& eventData = VariantMap(), Connection* receiver = 0, unsigned short timeToLive = 0);
     //! Clear all queued remote events
     void clearQueuedRemoteEvents();
     //! Mark a package file as required (server only)
@@ -203,8 +202,6 @@ public:
 private:
     //! Remove an entity by iterator
     void removeEntity(std::map<EntityID, SharedPtr<Entity> >::iterator i);
-    //! Update remote events' delay timers
-    void processRemoteEvents(float timeStep);
     //! Update asynchronous loading. Load entities until a set time has passed
     void updateAsyncLoading();
     //! Load an entity from a stream