Added client's score/hiscore update to multiplayer NinjaSnowWar.

Some renames for clarity (GetEventSender() instead of GetSender())

Bin/Data/Scripts/NinjaSnowWar.as

@@ -42,6 +42,7 @@ int incrementCounter = 0;
 float enemySpawnTimer = 0;
 float powerupSpawnTimer = 0;
 uint clientNodeID = 0;
+int clientScore = 0;
 
 Array<Player> players;
 Array<HiscoreEntry> hiscores;
@@ -177,6 +178,8 @@ void InitScene()
 void InitNetworking()
 {
     network.RegisterRemoteEvent("PlayerSpawned");
+    network.RegisterRemoteEvent("UpdateScore");
+    network.RegisterRemoteEvent("UpdateHiscores");
 
     if (runServer)
     {
@@ -194,6 +197,8 @@ void InitNetworking()
         network.Connect(serverAddress, serverPort, gameScene, identity);
 
         SubscribeToEvent("PlayerSpawned", "HandlePlayerSpawned");
+        SubscribeToEvent("UpdateScore", "HandleUpdateScore");
+        SubscribeToEvent("UpdateHiscores", "HandleUpdateHiscores");
     }
 }
 
@@ -319,40 +324,53 @@ void SpawnPlayer(Connection@ connection)
     else
         playerNinja.controls = playerNinja.prevControls = connection.controls;
 
-    // Check if player already exists, in that case just clear the score
+    // Check if player entry already exists
+    int playerIndex = -1;
     for (uint i = 0; i < players.length; ++i)
     {
         if (players[i].connection is connection)
         {
-            players[i].score = 0;
-            players[i].nodeID = playerNode.id;
+            playerIndex = i;
+            break;
         }
     }
 
-    Player newPlayer;
-    newPlayer.connection = connection;
-    if (connection !is null)
+    // Does not exist, create new
+    if (playerIndex < 0)
     {
-        newPlayer.name = connection.identity["UserName"].GetString();
+        playerIndex = players.length;
+        players.Resize(players.length + 1);
+        players[playerIndex].connection = connection;
 
-        // Send remote event that tells the spawned node's ID
-        // Note: it is important for the event to be in-order so that the node update has been transmitted first
+        if (connection !is null)
+        {
+            players[playerIndex].name = connection.identity["UserName"].GetString();
+            // In multiplayer, send current hiscores to the new player
+            SendHiscores(playerIndex);
+        }
+        else
+        {
+            players[playerIndex].name = "Player";
+            // In singleplayer, create also the default hiscore entry immediately
+            HiscoreEntry newHiscore;
+            newHiscore.name = players[playerIndex].name;
+            newHiscore.score = 0;
+            hiscores.Push(newHiscore);
+        }
+    }
+
+    players[playerIndex].nodeID = playerNode.id;
+    players[playerIndex].score = 0;
+
+    if (connection !is null)
+    {
+        // In multiplayer, send initial score, then send a remote event that tells the spawned node's ID
+        // It is important for the event to be in-order so that the node has been replicated first
+        SendScore(playerIndex);
         VariantMap eventData;
         eventData["NodeID"] = playerNode.id;
         connection.SendRemoteEvent("PlayerSpawned", true, eventData);
     }
-    else
-    {
-        newPlayer.name = "Player";
-
-        // In singleplayer, create also the default hiscore entry immediately
-        HiscoreEntry newHiscore;
-        newHiscore.name = "Player";
-        newHiscore.score = 0;
-        hiscores.Push(newHiscore);
-    }
-    newPlayer.nodeID = playerNode.id;
-    players.Push(newPlayer);
 }
 
 void HandleUpdate(StringHash eventType, VariantMap& eventData)
@@ -410,29 +428,6 @@ void HandlePostUpdate()
     UpdateStatus();
 }
 
-int FindPlayerIndex(uint nodeID)
-{
-    for (uint i = 0; i < players.length; ++i)
-    {
-        if (players[i].nodeID == nodeID)
-            return i;
-    }
-    return -1;
-}
-
-Node@ FindPlayerNode(uint playerIndex)
-{
-    return gameScene.GetNodeByID(players[playerIndex].nodeID);
-}
-
-Node@ FindOwnNode()
-{
-    if (singlePlayer)
-        return gameScene.GetChild("Player", true);
-    else
-        return gameScene.GetNodeByID(clientNodeID);
-}
-
 void HandlePostRenderUpdate()
 {
     if (engine.headless)
@@ -453,7 +448,11 @@ void HandlePoints(StringHash eventType, VariantMap& eventData)
         if (playerIndex >= 0)
         {
             players[playerIndex].score += eventData["Points"].GetInt();
-            CheckHiscore(playerIndex);
+            SendScore(playerIndex);
+
+            bool newHiscore = CheckHiscore(playerIndex);
+            if (newHiscore)
+                SendHiscores(-1);
         }
     }
 }
@@ -477,7 +476,7 @@ void HandleKill(StringHash eventType, VariantMap& eventData)
 
 void HandleClientIdentity(StringHash eventType, VariantMap& eventData)
 {
-    Connection@ connection = sender;
+    Connection@ connection = GetEventSender();
     // If user has empty name, invent one
     if (connection.identity["UserName"].GetString().Trimmed().empty)
         connection.identity["UserName"] = "user" + RandomInt(999);
@@ -488,7 +487,7 @@ void HandleClientIdentity(StringHash eventType, VariantMap& eventData)
 void HandleClientSceneLoaded(StringHash eventType, VariantMap& eventData)
 {
     // Now client is actually ready to begin. If first player, clear the scene and restart the game
-    Connection@ connection = sender;
+    Connection@ connection = GetEventSender();
     if (players.empty)
         StartGame(connection);
     else
@@ -497,7 +496,7 @@ void HandleClientSceneLoaded(StringHash eventType, VariantMap& eventData)
 
 void HandleClientDisconnected(StringHash eventType, VariantMap& eventData)
 {
-    Connection@ connection = sender;
+    Connection@ connection = GetEventSender();
     // Erase the player entry, and make the player's ninja commit seppuku (if exists)
     for (uint i = 0; i < players.length; ++i)
     {
@@ -533,15 +532,68 @@ void HandlePlayerSpawned(StringHash eventType, VariantMap& eventData)
     }
 }
 
-void CheckHiscore(uint playerIndex)
+void HandleUpdateScore(StringHash eventType, VariantMap& eventData)
+{
+    clientScore = eventData["Score"].GetInt();
+    scoreText.text = "Score " + clientScore;
+}
+
+void HandleUpdateHiscores(StringHash eventType, VariantMap& eventData)
+{
+    VectorBuffer data = eventData["Hiscores"].GetBuffer();
+    hiscores.Resize(data.ReadVLE());
+    for (uint i = 0; i < hiscores.length; ++i)
+    {
+        hiscores[i].name = data.ReadString();
+        hiscores[i].score = data.ReadInt();
+    }
+
+    String allHiscores;
+    for (uint i = 0; i < hiscores.length; ++i)
+        allHiscores += hiscores[i].name + " " + hiscores[i].score + "\n";
+    hiscoreText.text = allHiscores;    
+}
+                      
+int FindPlayerIndex(uint nodeID)
+{
+    for (uint i = 0; i < players.length; ++i)
+    {
+        if (players[i].nodeID == nodeID)
+            return i;
+    }
+    return -1;
+}
+
+Node@ FindPlayerNode(int playerIndex)
+{
+    if (playerIndex >= 0 && playerIndex < int(players.length))
+        return gameScene.GetNodeByID(players[playerIndex].nodeID);
+    else
+        return null;
+}
+
+Node@ FindOwnNode()
+{
+    if (singlePlayer)
+        return gameScene.GetChild("Player", true);
+    else
+        return gameScene.GetNodeByID(clientNodeID);
+}
+
+bool CheckHiscore(int playerIndex)
 {
     for (uint i = 0; i < hiscores.length; ++i)
     {
         if (hiscores[i].name == players[playerIndex].name)
         {
             if (players[playerIndex].score > hiscores[i].score)
+            {
                 hiscores[i].score = players[playerIndex].score;
-            return;
+                SortHiscores();
+                return true;
+            }
+            else
+                return false; // No update to individual hiscore
         }
     }
 
@@ -550,12 +602,62 @@ void CheckHiscore(uint playerIndex)
     newHiscore.name = players[playerIndex].name;
     newHiscore.score = players[playerIndex].score;
     hiscores.Push(newHiscore);
+    SortHiscores();
+    return true;
+}
 
-    // Todo: in multiplayer, send updated hiscores to everyone
+void SortHiscores()
+{
+    for (int i = 1; i < int(hiscores.length); ++i)
+    {
+        HiscoreEntry temp = hiscores[i];
+        int j = i;
+        while (j > 0 && temp.score > hiscores[j - 1].score)
+        {
+            hiscores[j] = hiscores[j - 1];
+            --j;
+        }
+        hiscores[j] = temp;
+    }
+}
+
+void SendScore(int playerIndex)
+{
+    if (!runServer || playerIndex < 0 || playerIndex >= int(players.length))
+        return;
+
+    VariantMap eventData;
+    eventData["Score"] = players[playerIndex].score;
+    players[playerIndex].connection.SendRemoteEvent("UpdateScore", true, eventData);
+}
+
+void SendHiscores(int playerIndex)
+{
+    if (!runServer)
+        return;
+
+    VectorBuffer data;
+    data.WriteVLE(hiscores.length);
+    for (uint i = 0; i < hiscores.length; ++i)
+    {
+        data.WriteString(hiscores[i].name);
+        data.WriteInt(hiscores[i].score);
+    }
+
+    VariantMap eventData;
+    eventData["Hiscores"] = data;
+
+    if (playerIndex >= 0 && playerIndex < int(players.length))
+        players[playerIndex].connection.SendRemoteEvent("UpdateHiscores", true, eventData);
+    else
+        network.BroadcastRemoteEvent(gameScene, "UpdateHiscores", true, eventData); // Send to all in scene
 }
 
 void SpawnObjects(float timeStep)
 {
+    if (!gameOn)
+        return;
+
     // Spawn powerups
     powerupSpawnTimer += timeStep;
     if (powerupSpawnTimer >= powerupSpawnRate)
@@ -706,7 +808,7 @@ void UpdateCamera()
     Quaternion dir;
     
     // In multiplayer, make controls seem more immediate by forcing the current mouse yaw into player ninja's Y-axis rotation
-    if (runClient)
+    if (runClient && playerNode.vars["Health"].GetInt() > 0)
         playerNode.SnapRotation(Quaternion(0, playerControls.yaw, 0));
 
     dir = dir * Quaternion(playerNode.rotation.yaw, Vector3(0, 1, 0));

Engine/Core/Context.cpp

@@ -41,7 +41,7 @@ void RemoveNamedAttribute(Vector<AttributeInfo>& attributes, const String& name)
 }
 
 Context::Context() :
-    handler_(0)
+    eventHandler_(0)
 {
 }
 
@@ -115,7 +115,7 @@ void Context::CopyBaseAttributes(ShortStringHash baseType, ShortStringHash deriv
 
 void Context::AddEventReceiver(Object* receiver, StringHash eventType)
 {
-    PODVector<Object*>& receivers = receivers_[eventType];
+    PODVector<Object*>& receivers = eventReceivers_[eventType];
     for (PODVector<Object*>::ConstIterator j = receivers.Begin(); j != receivers.End(); ++j)
     {
         // Check if already registered
@@ -128,7 +128,7 @@ void Context::AddEventReceiver(Object* receiver, StringHash eventType)
 
 void Context::AddEventReceiver(Object* receiver, Object* sender, StringHash eventType)
 {
-    PODVector<Object*>& receivers = specificReceivers_[MakePair(sender, eventType)];
+    PODVector<Object*>& receivers = specificEventReceivers_[MakePair(sender, eventType)];
     for (PODVector<Object*>::ConstIterator j = receivers.Begin(); j != receivers.End(); ++j)
     {
         if (*j == receiver)
@@ -140,8 +140,8 @@ void Context::AddEventReceiver(Object* receiver, Object* sender, StringHash even
 
 void Context::RemoveEventSender(Object* sender)
 {
-    for (Map<Pair<Object*, StringHash>, PODVector<Object*> >::Iterator i = specificReceivers_.Begin();
-        i != specificReceivers_.End();)
+    for (Map<Pair<Object*, StringHash>, PODVector<Object*> >::Iterator i = specificEventReceivers_.Begin();
+        i != specificEventReceivers_.End();)
     {
         Map<Pair<Object*, StringHash>, PODVector<Object*> >::Iterator current = i++;
         if (current->first_.first_ == sender)
@@ -152,7 +152,7 @@ void Context::RemoveEventSender(Object* sender)
                 if (*j)
                     (*j)->RemoveEventSender(sender);
             }
-            specificReceivers_.Erase(current);
+            specificEventReceivers_.Erase(current);
         }
     }
 }
@@ -168,7 +168,7 @@ void Context::RemoveEventReceiver(Object* receiver, StringHash eventType)
         if (*i == receiver)
         {
             // If no event handling going on, can erase the receiver. Otherwise reset the pointer and clean up later
-            if (senders_.Empty())
+            if (eventSenders_.Empty())
                 group->Erase(i);
             else
             {
@@ -190,7 +190,7 @@ void Context::RemoveEventReceiver(Object* receiver, Object* sender, StringHash e
     {
         if (*i == receiver)
         {
-            if (senders_.Empty())
+            if (eventSenders_.Empty())
                 group->Erase(i);
             else
             {
@@ -211,10 +211,10 @@ Object* Context::GetSubsystem(ShortStringHash type) const
         return 0;
 }
 
-Object* Context::GetSender() const
+Object* Context::GetEventSender() const
 {
-    if (!senders_.Empty())
-        return senders_.Back();
+    if (!eventSenders_.Empty())
+        return eventSenders_.Back();
     else
         return 0;
 }

Engine/Core/Context.h

@@ -62,29 +62,29 @@ public:
     /// Set current event handler. Called by Object
     void SetEventHandler(EventHandler* handler)
     {
-        handler_ = handler;
+        eventHandler_ = handler;
     }
     
     /// Begin event send
     void BeginSendEvent(Object* sender)
     {
-        senders_.Push(sender);
+        eventSenders_.Push(sender);
     }
     
     /// End event send. Clean up event receivers removed in the meanwhile
     void EndSendEvent()
     {
-        senders_.Pop();
+        eventSenders_.Pop();
     
         // Clean up dirtied event receiver groups when event handling finishes
-        if (senders_.Empty())
+        if (eventSenders_.Empty())
         {
             if (!dirtySpecificReceivers_.Empty())
             {
                 for (Set<Pair<Object*, StringHash> >::Iterator i = dirtySpecificReceivers_.Begin();
                     i != dirtySpecificReceivers_.End(); ++i)
                 {
-                    PODVector<Object*>& receivers = specificReceivers_[*i];
+                    PODVector<Object*>& receivers = specificEventReceivers_[*i];
                     for (PODVector<Object*>::Iterator j = receivers.Begin(); j != receivers.End();)
                     {
                         if (*j == 0)
@@ -100,7 +100,7 @@ public:
             {
                 for (Set<StringHash>::Iterator i = dirtyReceivers_.Begin(); i != dirtyReceivers_.End(); ++i)
                 {
-                    PODVector<Object*>& receivers = receivers_[*i];
+                    PODVector<Object*>& receivers = eventReceivers_[*i];
                     for (PODVector<Object*>::Iterator j = receivers.Begin(); j != receivers.End();)
                     {
                         if (*j == 0)
@@ -134,9 +134,9 @@ public:
     /// Return network replication attributes for all object types
     const Map<ShortStringHash, Vector<AttributeInfo> >& GetAllNetworkAttributes() const { return networkAttributes_; }
     /// Return active event sender. Null outside event handling
-    Object* GetSender() const;
+    Object* GetEventSender() const;
     /// Return active event handler. Set by Object. Null outside event handling
-    EventHandler* GetHandler() const { return handler_; }
+    EventHandler* GetEventHandler() const { return eventHandler_; }
     /// Return object type name from hash, or empty if unknown
     const String& GetTypeName(ShortStringHash type) const;
     /// Template version of returning a subsystem
@@ -160,15 +160,15 @@ public:
     PODVector<Object*>* GetReceivers(Object* sender, StringHash eventType)
     {
         Map<Pair<Object*, StringHash>, PODVector<Object*> >::Iterator i = 
-            specificReceivers_.Find(MakePair(sender, eventType));
-        return i != specificReceivers_.End() ? &i->second_ : 0;
+            specificEventReceivers_.Find(MakePair(sender, eventType));
+        return i != specificEventReceivers_.End() ? &i->second_ : 0;
     }
     
     /// Return event receivers for an event type, or null if they do not exist
     PODVector<Object*>* GetReceivers(StringHash eventType)
     {
-        Map<StringHash, PODVector<Object*> >::Iterator i = receivers_.Find(eventType);
-        return i != receivers_.End() ? &i->second_ : 0;
+        Map<StringHash, PODVector<Object*> >::Iterator i = eventReceivers_.Find(eventType);
+        return i != eventReceivers_.End() ? &i->second_ : 0;
     }
     
 private:
@@ -181,17 +181,17 @@ private:
     /// Network replication attribute descriptions per object type
     Map<ShortStringHash, Vector<AttributeInfo> > networkAttributes_;
     /// Event receivers for non-specific events
-    Map<StringHash, PODVector<Object*> > receivers_;
+    Map<StringHash, PODVector<Object*> > eventReceivers_;
     /// Event receivers for specific senders' events
-    Map<Pair<Object*, StringHash>, PODVector<Object*> > specificReceivers_;
+    Map<Pair<Object*, StringHash>, PODVector<Object*> > specificEventReceivers_;
     /// Event sender stack
-    PODVector<Object*> senders_;
+    PODVector<Object*> eventSenders_;
     /// Event types that have had receivers removed during event handling
     Set<StringHash> dirtyReceivers_;
     /// Event types for specific senders that have had receivers removed during event handling
     Set<Pair<Object*, StringHash> > dirtySpecificReceivers_;
     /// Active event handler. Not stored in a stack for performance reasons; is needed only in esoteric cases
-    WeakPtr<EventHandler> handler_;
+    WeakPtr<EventHandler> eventHandler_;
 };
 
 template <class T> void Context::RegisterFactory()

Engine/Core/Object.cpp

@@ -288,9 +288,9 @@ bool Object::HasSubscribedToEvent(Object* sender, StringHash eventType) const
     return eventHandlers_.Find(MakePair(sender, eventType)) != eventHandlers_.End();
 }
 
-Object* Object::GetSender() const
+Object* Object::GetEventSender() const
 {
-    return context_->GetSender();
+    return context_->GetEventSender();
 }
 
 void Object::RemoveEventSender(Object* sender)

Engine/Core/Object.h

@@ -79,7 +79,7 @@ public:
     /// Return whether has subscribed to a specific sender's event
     bool HasSubscribedToEvent(Object* sender, StringHash eventType) const;
     /// Return active event sender
-    Object* GetSender() const;
+    Object* GetEventSender() const;
     /// Template version of returning a subsystem
     template <class T> T* GetSubsystem() const;
     

Engine/Engine/CoreAPI.cpp

@@ -88,8 +88,8 @@ static void RegisterStringHash(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("StringHash", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructStringHash), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("StringHash", asBEHAVE_CONSTRUCT, "void f(const StringHash&in)", asFUNCTION(ConstructStringHashCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("StringHash", asBEHAVE_CONSTRUCT, "void f(const String&in)", asFUNCTION(ConstructStringHashInit), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("StringHash", "StringHash &opAssign(const StringHash&in)", asMETHOD(StringHash, operator =), asCALL_THISCALL);
-    engine->RegisterObjectMethod("StringHash", "StringHash &opAddAssign(const StringHash&in)", asMETHOD(StringHash, operator +=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("StringHash", "StringHash& opAssign(const StringHash&in)", asMETHOD(StringHash, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("StringHash", "StringHash& opAddAssign(const StringHash&in)", asMETHOD(StringHash, operator +=), asCALL_THISCALL);
     engine->RegisterObjectMethod("StringHash", "bool opEquals(const StringHash&in) const", asMETHOD(StringHash, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("StringHash", "int opCmp(const StringHash&in) const", asFUNCTION(StringHashCmp), asCALL_CDECL_OBJFIRST);
     engine->RegisterObjectMethod("StringHash", "StringHash opAdd(const StringHash&in) const", asMETHOD(StringHash, operator +), asCALL_THISCALL);
@@ -101,7 +101,7 @@ static void RegisterStringHash(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("ShortStringHash", asBEHAVE_CONSTRUCT, "void f(const ShortStringHash&in)", asFUNCTION(ConstructShortStringHashCopyShort), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("ShortStringHash", asBEHAVE_CONSTRUCT, "void f(const StringHash&in)", asFUNCTION(ConstructShortStringHashCopyLong), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("ShortStringHash", asBEHAVE_CONSTRUCT, "void f(const String&in)", asFUNCTION(ConstructShortStringHashInit), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("ShortStringHash", "ShortStringHash &opAssign(const ShortStringHash&in)", asMETHODPR(ShortStringHash, operator =, (const ShortStringHash&), ShortStringHash&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("ShortStringHash", "ShortStringHash& opAssign(const ShortStringHash&in)", asMETHODPR(ShortStringHash, operator =, (const ShortStringHash&), ShortStringHash&), asCALL_THISCALL);
     engine->RegisterObjectMethod("ShortStringHash", "bool opEquals(const ShortStringHash&in) const", asMETHOD(ShortStringHash, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("ShortStringHash", "int opCmp(const ShortStringHash&in) const", asFUNCTION(ShortStringHashCmp), asCALL_CDECL_OBJFIRST);
     engine->RegisterObjectMethod("ShortStringHash", "String ToString() const", asMETHOD(ShortStringHash, ToString), asCALL_THISCALL);
@@ -338,7 +338,7 @@ static void RegisterVariant(asIScriptEngine* engine)
     engine->RegisterObjectType("ResourceRef", sizeof(ResourceRef), asOBJ_VALUE | asOBJ_POD | asOBJ_APP_CLASS_CAK);
     engine->RegisterObjectBehaviour("ResourceRef", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructResourceRef), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("ResourceRef", asBEHAVE_CONSTRUCT, "void f(const ResourceRef&in)", asFUNCTION(ConstructResourceRefCopy), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("ResourceRef", "ResourceRef &opAssign(const ResourceRef&in)", asMETHOD(ResourceRef, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("ResourceRef", "ResourceRef& opAssign(const ResourceRef&in)", asMETHOD(ResourceRef, operator =), asCALL_THISCALL);
     engine->RegisterObjectMethod("ResourceRef", "bool opEquals(const ResourceRef&in) const", asMETHOD(ResourceRef, operator ==), asCALL_THISCALL);
     engine->RegisterObjectProperty("ResourceRef", "ShortStringHash type", offsetof(ResourceRef, type_));
     engine->RegisterObjectProperty("ResourceRef", "StringHash id", offsetof(ResourceRef, id_));
@@ -347,7 +347,7 @@ static void RegisterVariant(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("ResourceRefList", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructResourceRefList), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("ResourceRefList", asBEHAVE_CONSTRUCT, "void f(const ResourceRefList&in)", asFUNCTION(ConstructResourceRefListCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("ResourceRefList", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructResourceRefList), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("ResourceRefList", "ResourceRefList &opAssign(const ResourceRefList&in)", asMETHOD(ResourceRefList, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("ResourceRefList", "ResourceRefList& opAssign(const ResourceRefList&in)", asMETHOD(ResourceRefList, operator =), asCALL_THISCALL);
     engine->RegisterObjectMethod("ResourceRefList", "bool opEquals(const ResourceRefList&in) const", asMETHOD(ResourceRefList, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("ResourceRefList", "void Resize(uint)", asFUNCTION(ResourceRefListResize), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("ResourceRefList", "uint get_length() const", asFUNCTION(ResourceRefListGetSize), asCALL_CDECL_OBJLAST);
@@ -375,20 +375,20 @@ static void RegisterVariant(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Variant", asBEHAVE_CONSTRUCT, "void f(const VariantMap&in)", asFUNCTION(ConstructVariantVariantMap), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Variant", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructVariant), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("Variant", "void Clear()", asMETHOD(Variant, Clear), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(const Variant&in)", asMETHODPR(Variant, operator =, (const Variant&), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(int)", asMETHODPR(Variant, operator =, (int), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(uint)", asMETHODPR(Variant, operator =, (unsigned), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(const StringHash&in)", asMETHODPR(Variant, operator =, (const StringHash&), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(const ShortStringHash&in)", asMETHODPR(Variant, operator =, (const ShortStringHash&), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(bool)", asMETHODPR(Variant, operator =, (bool), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(float)", asMETHODPR(Variant, operator =, (float), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(const Vector2&in)", asMETHODPR(Variant, operator =, (const Vector2&), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(const Vector3&in)", asMETHODPR(Variant, operator =, (const Vector3&), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(const Quaternion&in)", asMETHODPR(Variant, operator =, (const Quaternion&), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(const Color&in)", asMETHODPR(Variant, operator =, (const Color&), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(const String&in)", asMETHODPR(Variant, operator =, (const String&), Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(const Array<Variant>@+)", asFUNCTION(VariantAssignVariantVector), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Variant", "Variant &opAssign(const VariantMap&in)", asMETHODPR(Variant, operator =, (const VariantMap&), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const Variant&in)", asMETHODPR(Variant, operator =, (const Variant&), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(int)", asMETHODPR(Variant, operator =, (int), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(uint)", asMETHODPR(Variant, operator =, (unsigned), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const StringHash&in)", asMETHODPR(Variant, operator =, (const StringHash&), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const ShortStringHash&in)", asMETHODPR(Variant, operator =, (const ShortStringHash&), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(bool)", asMETHODPR(Variant, operator =, (bool), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(float)", asMETHODPR(Variant, operator =, (float), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const Vector2&in)", asMETHODPR(Variant, operator =, (const Vector2&), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const Vector3&in)", asMETHODPR(Variant, operator =, (const Vector3&), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const Quaternion&in)", asMETHODPR(Variant, operator =, (const Quaternion&), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const Color&in)", asMETHODPR(Variant, operator =, (const Color&), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const String&in)", asMETHODPR(Variant, operator =, (const String&), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const Array<Variant>@+)", asFUNCTION(VariantAssignVariantVector), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const VariantMap&in)", asMETHODPR(Variant, operator =, (const VariantMap&), Variant&), asCALL_THISCALL);
     engine->RegisterObjectMethod("Variant", "bool opEquals(const Variant&in) const", asMETHODPR(Variant, operator ==, (const Variant&) const, bool), asCALL_THISCALL);
     engine->RegisterObjectMethod("Variant", "bool opEquals(int) const", asMETHODPR(Variant, operator ==, (int) const, bool), asCALL_THISCALL);
     engine->RegisterObjectMethod("Variant", "bool opEquals(uint) const", asMETHODPR(Variant, operator ==, (unsigned) const, bool), asCALL_THISCALL);
@@ -584,9 +584,9 @@ static void UnsubscribeFromAllEvents()
         listener->UnsubscribeFromAllEventsWithUserData();
 }
 
-static Object* GetSender()
+static Object* GetEventSender()
 {
-    return GetScriptContext()->GetSender();
+    return GetScriptContext()->GetEventSender();
 }
 
 void RegisterObject(asIScriptEngine* engine)
@@ -612,8 +612,7 @@ void RegisterObject(asIScriptEngine* engine)
     engine->RegisterGlobalFunction("void UnsubscribeFromEvent(Object@+, const String&in)", asFUNCTION(UnsubscribeFromSenderEvent), asCALL_CDECL);
     engine->RegisterGlobalFunction("void UnsubscribeFromEvents(Object@+)", asFUNCTION(UnsubscribeFromSenderEvents), asCALL_CDECL);
     engine->RegisterGlobalFunction("void UnsubscribeFromAllEvents()", asFUNCTION(UnsubscribeFromAllEvents), asCALL_CDECL);
-    
-    engine->RegisterGlobalFunction("Object@+ get_sender()", asFUNCTION(GetSender), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Object@+ GetEventSender()", asFUNCTION(GetEventSender), asCALL_CDECL);
 }
 
 void RegisterCoreAPI(asIScriptEngine* engine)

Engine/Engine/GraphicsAPI.cpp

@@ -209,7 +209,7 @@ static void RegisterTextures(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Viewport", asBEHAVE_CONSTRUCT, "void f(Scene@+, Camera@+)", asFUNCTION(ConstructViewportSceneCamera), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Viewport", asBEHAVE_CONSTRUCT, "void f(Scene@+, Camera@+, const IntRect&in)", asFUNCTION(ConstructViewportSceneCameraRect), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Viewport", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructViewport), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Viewport", "Viewport &opAssign(const Viewport&in)", asMETHOD(Viewport, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Viewport", "Viewport& opAssign(const Viewport&in)", asMETHOD(Viewport, operator =), asCALL_THISCALL);
     engine->RegisterObjectMethod("Viewport", "void set_scene(Scene@+)", asFUNCTION(ViewportSetScene), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("Viewport", "void set_camera(Camera@+)", asFUNCTION(ViewportSetCamera), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("Viewport", "Scene@+ get_scene() const", asFUNCTION(ViewportGetScene), asCALL_CDECL_OBJLAST);

Engine/Engine/IOAPI.cpp

@@ -174,6 +174,12 @@ static void ConstructVariantBuffer(const VectorBuffer& buffer, Variant* ptr)
     new(ptr) Variant(buffer.GetBuffer());
 }
 
+static Variant& VariantAssignBuffer(const VectorBuffer& buffer, Variant* ptr)
+{
+    *ptr = buffer.GetBuffer();
+    return *ptr;
+}
+
 static VectorBuffer VariantGetBuffer(Variant* ptr)
 {
     VectorBuffer ret(ptr->GetBuffer());
@@ -246,7 +252,7 @@ static void RegisterSerialization(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("VectorBuffer", asBEHAVE_CONSTRUCT, "void f(const VectorBuffer&in)", asFUNCTION(ConstructVectorBufferCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("VectorBuffer", asBEHAVE_CONSTRUCT, "void f(Deserializer@+, uint)", asFUNCTION(ConstructVectorBufferFromStream), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("VectorBuffer", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructVectorBuffer), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("VectorBuffer", "VectorBuffer &opAssign(const VectorBuffer&in)", asMETHOD(VectorBuffer, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("VectorBuffer", "VectorBuffer& opAssign(const VectorBuffer&in)", asMETHOD(VectorBuffer, operator =), asCALL_THISCALL);
     engine->RegisterObjectMethod("VectorBuffer", "void SetData(Deserializer@+, uint)", asFUNCTION(VectorBufferSetData), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("VectorBuffer", "void Clear()", asMETHOD(VectorBuffer, Clear), asCALL_THISCALL);
     engine->RegisterObjectMethod("VectorBuffer", "void Resize(uint)", asMETHOD(VectorBuffer, Resize), asCALL_THISCALL);
@@ -257,6 +263,7 @@ static void RegisterSerialization(asIScriptEngine* engine)
     
     // Register VectorBuffer conversions to Variant
     engine->RegisterObjectBehaviour("Variant", asBEHAVE_CONSTRUCT, "void f(const VectorBuffer&in)", asFUNCTION(ConstructVariantBuffer), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const VectorBuffer&in)", asFUNCTION(VariantAssignBuffer), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("Variant", "VectorBuffer GetBuffer() const", asFUNCTION(VariantGetBuffer), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("Variant", "bool opEquals(const VectorBuffer&in) const", asFUNCTION(VariantEqualsBuffer), asCALL_CDECL_OBJLAST);
 }

Engine/Engine/MathAPI.cpp

@@ -114,7 +114,7 @@ static void RegisterIntRect(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("IntRect", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructIntRect), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("IntRect", asBEHAVE_CONSTRUCT, "void f(const IntRect&in)", asFUNCTION(ConstructIntRectCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("IntRect", asBEHAVE_CONSTRUCT, "void f(int, int, int, int)", asFUNCTION(ConstructIntRectInit), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("IntRect", "IntRect &opAssign(const IntRect&in)", asMETHOD(IntRect, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("IntRect", "IntRect& opAssign(const IntRect&in)", asMETHOD(IntRect, operator =), asCALL_THISCALL);
     engine->RegisterObjectMethod("IntRect", "bool opEquals(const IntRect&in) const", asMETHOD(IntRect, operator ==), asCALL_THISCALL);
     engine->RegisterObjectProperty("IntRect", "int left", offsetof(IntRect, left_));
     engine->RegisterObjectProperty("IntRect", "int top", offsetof(IntRect, top_));
@@ -144,11 +144,11 @@ static void RegisterIntVector2(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("IntVector2", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructIntVector2), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("IntVector2", asBEHAVE_CONSTRUCT, "void f(const IntVector2&in)", asFUNCTION(ConstructIntVector2Copy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("IntVector2", asBEHAVE_CONSTRUCT, "void f(int, int)", asFUNCTION(ConstructIntVector2Init), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("IntVector2", "IntVector2 &opAssign(const IntVector2&in)", asMETHOD(IntVector2, operator =), asCALL_THISCALL);
-    engine->RegisterObjectMethod("IntVector2", "IntVector2 &opAddAssign(const IntVector2&in)", asMETHOD(IntVector2, operator +=), asCALL_THISCALL);
-    engine->RegisterObjectMethod("IntVector2", "IntVector2 &opSubAssign(const IntVector2&in)", asMETHOD(IntVector2, operator -=), asCALL_THISCALL);
-    engine->RegisterObjectMethod("IntVector2", "IntVector2 &opMulAssign(int)", asMETHODPR(IntVector2, operator *=, (int), IntVector2&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("IntVector2", "IntVector2 &opDivAssign(int)", asMETHODPR(IntVector2, operator /=, (int), IntVector2&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("IntVector2", "IntVector2& opAssign(const IntVector2&in)", asMETHOD(IntVector2, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("IntVector2", "IntVector2& opAddAssign(const IntVector2&in)", asMETHOD(IntVector2, operator +=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("IntVector2", "IntVector2& opSubAssign(const IntVector2&in)", asMETHOD(IntVector2, operator -=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("IntVector2", "IntVector2& opMulAssign(int)", asMETHODPR(IntVector2, operator *=, (int), IntVector2&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("IntVector2", "IntVector2& opDivAssign(int)", asMETHODPR(IntVector2, operator /=, (int), IntVector2&), asCALL_THISCALL);
     engine->RegisterObjectMethod("IntVector2", "bool opEquals(const IntVector2&in) const", asMETHOD(IntVector2, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("IntVector2", "IntVector2 opNeg() const", asMETHODPR(IntVector2, operator -, () const, IntVector2), asCALL_THISCALL);
     engine->RegisterObjectMethod("IntVector2", "IntVector2 opAdd(const IntVector2&in) const", asMETHOD(IntVector2, operator +), asCALL_THISCALL);
@@ -182,13 +182,13 @@ static void RegisterVector2(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Vector2", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructVector2), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Vector2", asBEHAVE_CONSTRUCT, "void f(const Vector2&in)", asFUNCTION(ConstructVector2Copy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Vector2", asBEHAVE_CONSTRUCT, "void f(float, float)", asFUNCTION(ConstructVector2Init), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Vector2", "Vector2 &opAssign(const Vector2&in)", asMETHOD(Vector2, operator =), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector2", "Vector2 &opAddAssign(const Vector2&in)", asMETHOD(Vector2, operator +=), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector2", "Vector2 &opSubAssign(const Vector2&in)", asMETHOD(Vector2, operator -=), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector2", "Vector2 &opMulAssign(const Vector2&in)", asMETHODPR(Vector2, operator *=, (const Vector2&), Vector2&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector2", "Vector2 &opMulAssign(float)", asMETHODPR(Vector2, operator *=, (float), Vector2&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector2", "Vector2 &opDivAssign(const Vector2&in)", asMETHODPR(Vector2, operator /=, (const Vector2&), Vector2&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector2", "Vector2 &opDivAssign(float)", asMETHODPR(Vector2, operator /=, (float), Vector2&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector2", "Vector2& opAssign(const Vector2&in)", asMETHOD(Vector2, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector2", "Vector2& opAddAssign(const Vector2&in)", asMETHOD(Vector2, operator +=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector2", "Vector2& opSubAssign(const Vector2&in)", asMETHOD(Vector2, operator -=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector2", "Vector2& opMulAssign(const Vector2&in)", asMETHODPR(Vector2, operator *=, (const Vector2&), Vector2&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector2", "Vector2& opMulAssign(float)", asMETHODPR(Vector2, operator *=, (float), Vector2&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector2", "Vector2& opDivAssign(const Vector2&in)", asMETHODPR(Vector2, operator /=, (const Vector2&), Vector2&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector2", "Vector2& opDivAssign(float)", asMETHODPR(Vector2, operator /=, (float), Vector2&), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector2", "bool opEquals(const Vector2&in) const", asMETHOD(Vector2, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector2", "Vector2 opNeg() const", asMETHODPR(Vector2, operator -, () const, Vector2), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector2", "Vector2 opAdd(const Vector2&in) const", asMETHOD(Vector2, operator +), asCALL_THISCALL);
@@ -231,13 +231,13 @@ static void RegisterVector3(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Vector3", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructVector3), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Vector3", asBEHAVE_CONSTRUCT, "void f(const Vector3&in)", asFUNCTION(ConstructVector3Copy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Vector3", asBEHAVE_CONSTRUCT, "void f(float, float, float)", asFUNCTION(ConstructVector3Init), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Vector3", "Vector3 &opAssign(const Vector3&in)", asMETHOD(Vector3, operator =), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector3", "Vector3 &opAddAssign(const Vector3&in)", asMETHOD(Vector3, operator +=), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector3", "Vector3 &opSubAssign(const Vector3&in)", asMETHOD(Vector3, operator -=), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector3", "Vector3 &opMulAssign(const Vector3&in)", asMETHODPR(Vector3, operator *=, (const Vector3&), Vector3&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector3", "Vector3 &opMulAssign(float)", asMETHODPR(Vector3, operator *=, (float), Vector3&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector3", "Vector3 &opDivAssign(const Vector3&in)", asMETHODPR(Vector3, operator /=, (const Vector3&), Vector3&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector3", "Vector3 &opDivAssign(float)", asMETHODPR(Vector3, operator /=, (float), Vector3&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector3", "Vector3& opAssign(const Vector3&in)", asMETHOD(Vector3, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector3", "Vector3& opAddAssign(const Vector3&in)", asMETHOD(Vector3, operator +=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector3", "Vector3& opSubAssign(const Vector3&in)", asMETHOD(Vector3, operator -=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector3", "Vector3& opMulAssign(const Vector3&in)", asMETHODPR(Vector3, operator *=, (const Vector3&), Vector3&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector3", "Vector3& opMulAssign(float)", asMETHODPR(Vector3, operator *=, (float), Vector3&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector3", "Vector3& opDivAssign(const Vector3&in)", asMETHODPR(Vector3, operator /=, (const Vector3&), Vector3&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector3", "Vector3& opDivAssign(float)", asMETHODPR(Vector3, operator /=, (float), Vector3&), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector3", "bool opEquals(const Vector3&in) const", asMETHOD(Vector3, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector3", "Vector3 opNeg() const", asMETHODPR(Vector3, operator -, () const, Vector3), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector3", "Vector3 opAdd(const Vector3&in) const", asMETHOD(Vector3, operator +), asCALL_THISCALL);
@@ -282,13 +282,13 @@ static void RegisterVector4(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Vector4", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructVector4), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Vector4", asBEHAVE_CONSTRUCT, "void f(const Vector4&in)", asFUNCTION(ConstructVector4Copy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Vector4", asBEHAVE_CONSTRUCT, "void f(float, float, float)", asFUNCTION(ConstructVector4Init), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Vector4", "Vector4 &opAssign(const Vector4&in)", asMETHOD(Vector4, operator =), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector4", "Vector4 &opAddAssign(const Vector4&in)", asMETHOD(Vector4, operator +=), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector4", "Vector4 &opSubAssign(const Vector4&in)", asMETHOD(Vector4, operator -=), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector4", "Vector4 &opMulAssign(const Vector4&in)", asMETHODPR(Vector4, operator *=, (const Vector4&), Vector4&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector4", "Vector4 &opMulAssign(float)", asMETHODPR(Vector4, operator *=, (float), Vector4&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector4", "Vector4 &opDivAssign(const Vector4&in)", asMETHODPR(Vector4, operator /=, (const Vector4&), Vector4&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Vector4", "Vector4 &opDivAssign(float)", asMETHODPR(Vector4, operator /=, (float), Vector4&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector4", "Vector4& opAssign(const Vector4&in)", asMETHOD(Vector4, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector4", "Vector4& opAddAssign(const Vector4&in)", asMETHOD(Vector4, operator +=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector4", "Vector4& opSubAssign(const Vector4&in)", asMETHOD(Vector4, operator -=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector4", "Vector4& opMulAssign(const Vector4&in)", asMETHODPR(Vector4, operator *=, (const Vector4&), Vector4&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector4", "Vector4& opMulAssign(float)", asMETHODPR(Vector4, operator *=, (float), Vector4&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector4", "Vector4& opDivAssign(const Vector4&in)", asMETHODPR(Vector4, operator /=, (const Vector4&), Vector4&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Vector4", "Vector4& opDivAssign(float)", asMETHODPR(Vector4, operator /=, (float), Vector4&), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector4", "bool &opEquals(const Vector4&in) const", asMETHOD(Vector4, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector4", "Vector4 opNeg() const", asMETHODPR(Vector4, operator -, () const, Vector4), asCALL_THISCALL);
     engine->RegisterObjectMethod("Vector4", "Vector4 opAdd(const Vector4&in) const", asMETHOD(Vector4, operator +), asCALL_THISCALL);
@@ -346,8 +346,8 @@ static void RegisterQuaternion(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(float, const Vector3&in)", asFUNCTION(ConstructQuaternionAngleAxis), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(float, float, float)", asFUNCTION(ConstructQuaternionEuler), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Vector3&in, const Vector3&in)", asFUNCTION(ConstructQuaternionRotation), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Quaternion", "Quaternion &opAssign(const Quaternion&in)", asMETHOD(Quaternion, operator =), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Quaternion", "Quaternion &opAddAssign(const Quaternion&in)", asMETHOD(Quaternion, operator +=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion& opAssign(const Quaternion&in)", asMETHOD(Quaternion, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion& opAddAssign(const Quaternion&in)", asMETHOD(Quaternion, operator +=), asCALL_THISCALL);
     engine->RegisterObjectMethod("Quaternion", "bool opEquals(const Quaternion&in) const", asMETHOD(Quaternion, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("Quaternion", "Quaternion opMul(float) const", asMETHODPR(Quaternion, operator *, (float) const, Quaternion), asCALL_THISCALL);
     engine->RegisterObjectMethod("Quaternion", "Vector3 opMul(const Vector3&in) const", asMETHODPR(Quaternion, operator *, (const Vector3&) const, Vector3), asCALL_THISCALL);
@@ -395,7 +395,7 @@ static void RegisterRay(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Ray", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructRay), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Ray", asBEHAVE_CONSTRUCT, "void f(const Ray&in)", asFUNCTION(ConstructRayCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Ray", asBEHAVE_CONSTRUCT, "void f(const Vector3&in, const Vector3&in)", asFUNCTION(ConstructRayInit), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Ray", "Ray &opAssign(const Ray&in)", asMETHOD(Ray, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Ray", "Ray& opAssign(const Ray&in)", asMETHOD(Ray, operator =), asCALL_THISCALL);
     engine->RegisterObjectMethod("Ray", "bool opEquals(const Ray&in) const", asMETHOD(Ray, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("Ray", "void Define(const Vector3&in, const Vector3&in)", asMETHOD(Ray, Define), asCALL_THISCALL);
     engine->RegisterObjectMethod("Ray", "float Distance(const Vector3&in, const Vector3&in, const Vector3&in) const", asMETHODPR(Ray, Distance, (const Vector3&, const Vector3&, const Vector3&) const, float), asCALL_THISCALL);
@@ -431,7 +431,7 @@ static void RegisterRect(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Rect", asBEHAVE_CONSTRUCT, "void f(const Rect&in)", asFUNCTION(ConstructRectCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Rect", asBEHAVE_CONSTRUCT, "void f(float, float, float, float)", asFUNCTION(ConstructRectInit), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Rect", asBEHAVE_CONSTRUCT, "void f(const Vector2&in, const Vector2&in)", asFUNCTION(ConstructRectInitVec), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Rect", "Rect &opAssign(const Rect&in)", asMETHOD(Rect, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Rect", "Rect& opAssign(const Rect&in)", asMETHOD(Rect, operator =), asCALL_THISCALL);
     engine->RegisterObjectMethod("Rect", "bool opEquals(const Rect&in) const", asMETHOD(Rect, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("Rect", "void Define(const Vector2&in, const Vector2&in)", asMETHODPR(Rect, Define, (const Vector2&, const Vector2&), void), asCALL_THISCALL);
     engine->RegisterObjectMethod("Rect", "void Define(const Vector2&in)", asMETHODPR(Rect, Define, (const Vector2&), void), asCALL_THISCALL);
@@ -518,7 +518,7 @@ static void RegisterVolumes(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("BoundingBox", asBEHAVE_CONSTRUCT, "void f(const BoundingBox&in)", asFUNCTION(ConstructBoundingBoxCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("BoundingBox", asBEHAVE_CONSTRUCT, "void f(const Vector3&in, const Vector3&in)", asFUNCTION(ConstructBoundingBoxInit), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("BoundingBox", asBEHAVE_CONSTRUCT, "void f(float, float)", asFUNCTION(ConstructBoundingBoxFloat), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("BoundingBox", "BoundingBox &opAssign(const BoundingBox&in)", asMETHODPR(BoundingBox, operator =, (const BoundingBox&), BoundingBox&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("BoundingBox", "BoundingBox& opAssign(const BoundingBox&in)", asMETHODPR(BoundingBox, operator =, (const BoundingBox&), BoundingBox&), asCALL_THISCALL);
     engine->RegisterObjectMethod("BoundingBox", "bool opEquals(const BoundingBox&in) const", asMETHOD(BoundingBox, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("BoundingBox", "void Define(const Vector3&in, const Vector3&in)", asMETHODPR(BoundingBox, Define, (const Vector3&, const Vector3&), void), asCALL_THISCALL);
     engine->RegisterObjectMethod("BoundingBox", "void Define(float, float)", asMETHODPR(BoundingBox, Define, (float, float), void), asCALL_THISCALL);
@@ -543,7 +543,7 @@ static void RegisterVolumes(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Sphere", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructSphere), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Sphere", asBEHAVE_CONSTRUCT, "void f(const Sphere&in)", asFUNCTION(ConstructSphereCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Sphere", asBEHAVE_CONSTRUCT, "void f(const Vector3&in, float)", asFUNCTION(ConstructSphereInit), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Sphere", "Sphere &opAssign(const Sphere&in)", asMETHODPR(Sphere, operator =, (const Sphere&), Sphere&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Sphere", "Sphere& opAssign(const Sphere&in)", asMETHODPR(Sphere, operator =, (const Sphere&), Sphere&), asCALL_THISCALL);
     engine->RegisterObjectMethod("Sphere", "bool &opEquals(const Sphere&in) const", asMETHOD(Sphere, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("Sphere", "void Define(const Vector3&in, float)", asMETHODPR(Sphere, Define, (const Vector3&, float), void), asCALL_THISCALL);
     engine->RegisterObjectMethod("Sphere", "void Define(const BoundingBox&in)", asMETHODPR(Sphere, Define, (const BoundingBox&), void), asCALL_THISCALL);
@@ -563,7 +563,7 @@ static void RegisterVolumes(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Frustum", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructFrustum), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Frustum", asBEHAVE_CONSTRUCT, "void f(const Frustum&in)", asFUNCTION(ConstructFrustumCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Frustum", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructFrustum), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Frustum", "Frustum &opAssign(const Frustum&in)", asMETHODPR(Frustum, operator =, (const Frustum&), Frustum&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Frustum", "Frustum& opAssign(const Frustum&in)", asMETHODPR(Frustum, operator =, (const Frustum&), Frustum&), asCALL_THISCALL);
     engine->RegisterObjectMethod("Frustum", "Intersection IsInside(const Vector3&in)", asMETHODPR(Frustum, IsInside, (const Vector3&) const, Intersection), asCALL_THISCALL);
     engine->RegisterObjectMethod("Frustum", "Intersection IsInside(const BoundingBox&in)", asMETHODPR(Frustum, IsInside, (const BoundingBox&) const, Intersection), asCALL_THISCALL);
     engine->RegisterObjectMethod("Frustum", "Intersection IsInside(const Sphere&in)", asMETHODPR(Frustum, IsInside, (const Sphere&) const, Intersection), asCALL_THISCALL);
@@ -598,8 +598,8 @@ static void RegisterColor(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Color", asBEHAVE_CONSTRUCT, "void f(const Color&in)", asFUNCTION(ConstructColorCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Color", asBEHAVE_CONSTRUCT, "void f(float, float, float, float)", asFUNCTION(ConstructColorRGBA), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Color", asBEHAVE_CONSTRUCT, "void f(float, float, float)", asFUNCTION(ConstructColorRGB), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Color", "Color &opAssign(const Color&in)", asMETHOD(Color, operator =), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Color", "Color &opAddAssign(const Color&in)", asMETHOD(Color, operator +=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Color", "Color& opAssign(const Color&in)", asMETHOD(Color, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Color", "Color& opAddAssign(const Color&in)", asMETHOD(Color, operator +=), asCALL_THISCALL);
     engine->RegisterObjectMethod("Color", "bool opEquals(const Color&in) const", asMETHOD(Color, operator ==), asCALL_THISCALL);
     engine->RegisterObjectMethod("Color", "Color opMul(float) const", asMETHOD(Color, operator *), asCALL_THISCALL);
     engine->RegisterObjectMethod("Color", "Color opAdd(const Color&in) const", asMETHOD(Color, operator +), asCALL_THISCALL);

Engine/Engine/NetworkAPI.cpp

@@ -48,7 +48,7 @@ static void RegisterControls(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Controls", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructControls), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Controls", asBEHAVE_CONSTRUCT, "void f(const Controls&in)", asFUNCTION(ConstructControlsCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("Controls", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructControls), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Controls", "Controls &opAssign(const Controls&in)", asMETHOD(Controls, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Controls", "Controls& opAssign(const Controls&in)", asMETHOD(Controls, operator =), asCALL_THISCALL);
     engine->RegisterObjectMethod("Controls", "void Reset()", asMETHOD(Controls, Reset), asCALL_THISCALL);
     engine->RegisterObjectMethod("Controls", "void Set(uint, bool)", asMETHOD(Controls, Set), asCALL_THISCALL);
     engine->RegisterObjectMethod("Controls", "bool IsDown(uint) const", asMETHOD(Controls, IsDown), asCALL_THISCALL);

Engine/Engine/ResourceAPI.cpp

@@ -171,7 +171,7 @@ static void RegisterXMLElement(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("XMLElement", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructXMLElement), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("XMLElement", asBEHAVE_CONSTRUCT, "void f(const XMLElement&in)", asFUNCTION(ConstructXMLElementCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("XMLElement", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructXMLElement), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("XMLElement", "XMLElement &opAssign(const XMLElement&in)", asMETHOD(XMLElement, operator =), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement& opAssign(const XMLElement&in)", asMETHOD(XMLElement, operator =), asCALL_THISCALL);
     engine->RegisterObjectMethod("XMLElement", "XMLElement CreateChild(const String&in)", asMETHOD(XMLElement, CreateChild), asCALL_THISCALL);
     engine->RegisterObjectMethod("XMLElement", "bool RemoveChild(const String&in name = String(), bool last = true)", asMETHOD(XMLElement, RemoveChild), asCALL_THISCALL);
     engine->RegisterObjectMethod("XMLElement", "bool RemoveChildren(const String&in name = String())", asMETHOD(XMLElement,RemoveChildren), asCALL_THISCALL);

Engine/Script/Addons.cpp

@@ -563,7 +563,7 @@ void RegisterArray(asIScriptEngine* engine)
     engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_RELEASE, "void f()", asMETHOD(CScriptArray,Release), asCALL_THISCALL);
     engine->RegisterObjectMethod("Array<T>", "T& opIndex(uint)", asMETHOD(CScriptArray, At), asCALL_THISCALL);
     engine->RegisterObjectMethod("Array<T>", "const T& opIndex(uint) const", asMETHOD(CScriptArray, At), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "Array<T> &opAssign(const Array<T>& in)", asMETHOD(CScriptArray, operator=), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "Array<T>& opAssign(const Array<T>& in)", asMETHOD(CScriptArray, operator=), asCALL_THISCALL);
     engine->RegisterObjectMethod("Array<T>", "void Insert(uint, const T& in)", asMETHOD(CScriptArray, InsertAt), asCALL_THISCALL);
     engine->RegisterObjectMethod("Array<T>", "void Erase(uint)", asMETHOD(CScriptArray, RemoveAt), asCALL_THISCALL);
     engine->RegisterObjectMethod("Array<T>", "void Push(const T& in)", asMETHOD(CScriptArray, InsertLast), asCALL_THISCALL);
@@ -740,8 +740,8 @@ void RegisterString(asIScriptEngine *engine)
     engine->RegisterObjectBehaviour("String", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructString), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("String", asBEHAVE_CONSTRUCT, "void f(const String& in)", asFUNCTION(ConstructStringCopy), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("String", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructString), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String &opAssign(const String& in)", asMETHODPR(String, operator =, (const String&), String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("String", "String &opAddAssign(const String& in)", asMETHODPR(String, operator +=, (const String&), String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("String", "String& opAssign(const String& in)", asMETHODPR(String, operator =, (const String&), String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("String", "String& opAddAssign(const String& in)", asMETHODPR(String, operator +=, (const String&), String&), asCALL_THISCALL);
     engine->RegisterObjectMethod("String", "bool opEquals(const String& in) const", asMETHODPR(String, operator ==, (const String&) const, bool), asCALL_THISCALL);
     engine->RegisterObjectMethod("String", "int opCmp(const String& in) const", asFUNCTION(StringCmp), asCALL_CDECL_OBJFIRST);
     engine->RegisterObjectMethod("String", "String opAdd(const String& in) const", asMETHODPR(String, operator +, (const String&) const, String), asCALL_THISCALL);
@@ -768,20 +768,20 @@ void RegisterString(asIScriptEngine *engine)
     engine->RegisterObjectBehaviour("String", asBEHAVE_CONSTRUCT, "void f(uint)", asFUNCTION(ConstructStringUInt), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("String", asBEHAVE_CONSTRUCT, "void f(float)", asFUNCTION(ConstructStringFloat), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectBehaviour("String", asBEHAVE_CONSTRUCT, "void f(bool)", asFUNCTION(ConstructStringBool), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String &opAssign(int)", asFUNCTION(StringAssignInt), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String &opAddAssign(int)", asFUNCTION(StringAddAssignInt), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAssign(int)", asFUNCTION(StringAssignInt), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAddAssign(int)", asFUNCTION(StringAddAssignInt), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "String opAdd(int) const", asFUNCTION(StringAddInt), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "String opAdd_r(int) const", asFUNCTION(StringAddIntReverse), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String &opAssign(uint)", asFUNCTION(StringAssignUInt), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String &opAddAssign(uint)", asFUNCTION(StringAddAssignUInt), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAssign(uint)", asFUNCTION(StringAssignUInt), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAddAssign(uint)", asFUNCTION(StringAddAssignUInt), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "String opAdd(uint) const", asFUNCTION(StringAddUInt), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "String opAdd_r(uint) const", asFUNCTION(StringAddUIntReverse), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String &opAssign(float)", asFUNCTION(StringAssignFloat), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String &opAddAssign(float)", asFUNCTION(StringAddAssignFloat), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAssign(float)", asFUNCTION(StringAssignFloat), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAddAssign(float)", asFUNCTION(StringAddAssignFloat), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "String opAdd(float) const", asFUNCTION(StringAddFloat), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "String opAdd_r(float) const", asFUNCTION(StringAddFloatReverse), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String &opAssign(bool)", asFUNCTION(StringAssignBool), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String &opAddAssign(bool)", asFUNCTION(StringAddAssignBool), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAssign(bool)", asFUNCTION(StringAssignBool), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAddAssign(bool)", asFUNCTION(StringAddAssignBool), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "String opAdd(bool) const", asFUNCTION(StringAddBool), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("String", "String opAdd_r(bool) const", asFUNCTION(StringAddBoolReverse), asCALL_CDECL_OBJLAST);
 }

Engine/Script/ScriptFile.cpp

@@ -543,7 +543,7 @@ void ScriptFile::HandleScriptEvent(StringHash eventType, VariantMap& eventData)
     if (!compiled_)
         return;
     
-    asIScriptFunction* function = static_cast<asIScriptFunction*>(context_->GetHandler()->GetUserData());
+    asIScriptFunction* function = static_cast<asIScriptFunction*>(context_->GetEventHandler()->GetUserData());
     
     VariantVector parameters;
     if (function->GetParamCount() > 0)

Engine/Script/ScriptInstance.cpp

@@ -480,7 +480,7 @@ void ScriptInstance::HandleScriptEvent(StringHash eventType, VariantMap& eventDa
     if (!active_ || !scriptFile_ || !scriptObject_)
         return;
     
-    asIScriptFunction* method = static_cast<asIScriptFunction*>(context_->GetHandler()->GetUserData());
+    asIScriptFunction* method = static_cast<asIScriptFunction*>(context_->GetEventHandler()->GetUserData());
     
     VariantVector parameters;
     if (method->GetParamCount() > 0)