Upon spawning, automatically call Entity Init function if it exists

diff --git a/Scripts/init.lua b/Scripts/init.lua
index f92e36667bcdab0b713ea1110e113b74af9349d2..596fe38541bd7c8b18a74530f8d92c0357a4cd32 100644 (file)
--- a/Scripts/init.lua
+++ b/Scripts/init.lua
@@ -6,6 +6,7 @@ bird = {
     Name = "bord",
     Init = function(self)
         print(self.Position.x .. "," .. self.Position.y)
+        print("Bird spawn")
     end
 }
 
@@ -38,10 +39,9 @@ animal = {
 }
 
 birdSpawn = game.spawn(bird);
-birdSpawn:Init()
 
 dogSpawn = game.spawn(dog);
-dogSpawn:Init()
 dogSpawn.Position.x = 37.5
 
 animalSpawn = game.spawn(animal);
+print("Animal pos: " .. animalSpawn.Position.x)

diff --git a/src/script.cpp b/src/script.cpp
index 1a6bda8615477b6add86827ce249208e23ceb18e..d471d650825e5cd5f94629d8b9b228603682f7d4 100644 (file)
--- a/src/script.cpp
+++ b/src/script.cpp
@@ -107,19 +107,26 @@ void ScriptSystem::scriptExport()
 
 sol::table ScriptSystem::spawn(sol::object param)
 {
-    sol::table* toRet;
+    sol::table* toRet; // "Entitiy" table to be returned
     if (param.get_type() == sol::type::table) {
-        sol::table tab = param;
-
-        entityx::Entity e = manager->create();
-        auto d = e.assign<Scripted>().get();
-        d->caller = lua.create_table();
-        toRet = &(d->caller);
-
-        *toRet = tab; // Copy table to our new entity to preserve functions
-                      //  this reduces the amount of work done in this function
-                      //  as well
-
+        sol::table tab = param; // Cast the generic parameter to a table
+
+        entityx::Entity e = manager->create(); // Create a new entity
+        auto d = e.assign<Scripted>().get(); // Since this entity was created
+                                             //  via Lua, assign the Scripted
+                                             //  component.
+        d->caller = lua.create_table(); // Create our Entity "table"
+        toRet = &(d->caller); // set our return table to the Entity "table"
+
+        *toRet = tab; /* Copy table to our new entity to preserve functions
+                      *   this reduces the amount of work done in this function
+                      *   as well. We are allowed to do this because lua allows
+                      *   for the reallocation of types.
+                      */
+
+        /*
+         * Create the component dependancies (i.e.: position) first
+         */
         if (tab["Position"] != nullptr) {
             (*toRet)["Position"] = 
                 e.assign<Position>(Position().FromLua(tab["Position"])).get();
@@ -131,22 +138,27 @@ sol::table ScriptSystem::spawn(sol::object param)
         }
 
         if (tab["Render"] != nullptr) {
-            if (!e.has_component<Position>())
-                e.assign<Position>();
+            if (!e.has_component<Position>()) // Position must exist for render
+                (*toRet)["Position"] = e.assign<Position>().get();
             (*toRet)["Render"] =
                 e.assign<Render>(Render().FromLua(tab["Render"])).get();
         }
 
         if (tab["Velocity"] != nullptr) {
-            if (!e.has_component<Position>())
-                e.assign<Position>();
+            if (!e.has_component<Position>()) // Position must exist for vel.
+                (*toRet)["Position"] = e.assign<Position>().get();
             (*toRet)["Velocity"] =
                 e.assign<Velocity>(Velocity().FromLua(tab["Velocity"])).get();
         }
 
     } else {
+        // TODO better logging
         std::cerr << "Parameter to spawn() must be a table!" << std::endl;
     }
 
+    // If the Entity has an Init function defined, call it
+    if ((*toRet)["Init"].get_type() == sol::type::function)
+        (*toRet)["Init"](*toRet);
+
     return *toRet;
 }

diff --git a/src/script.hpp b/src/script.hpp
index bd8c6209825fbdd07db4ec1c72fdec21d8969786..be02542873fa75d3bcd6fdc0f2966232b7f85096 100644 (file)
--- a/src/script.hpp
+++ b/src/script.hpp
@@ -87,6 +87,9 @@ class ScriptSystem : public entityx::System<ScriptSystem>
 
         /**
          * The function called by lua scripts in order to spawn an entity.
+         * @param param The table that must be passed in by Lua. This is a
+         * sol2 object instead of a sol2 table because this allows us to handle
+         * errors easier instead of letting sol2 do the error handling.
          */
         sol::table spawn(sol::object param);