Changeset 11549 for code/branches/ScriptableController_HS17/src/orxonox/scriptablecontroller

Timestamp:

Nov 6, 2017, 5:23:08 PM (7 years ago)

Author:

kohlia

Message:

Not working yet

Location:

code/branches/ScriptableController_HS17/src/orxonox/scriptablecontroller

Files:

• luatb.h (modified) (1 diff)
• luatb.ipp (modified) (4 diffs)
• luatb_typed_stack.cc (modified) (1 diff)
• luatb_typed_stack.h (modified) (3 diffs)
• scriptable_controller.cc (modified) (2 diffs)
• scriptable_controller.h (modified) (3 diffs)
• scriptable_controller_api.cc (modified) (2 diffs)
• scriptable_controller_api.h (modified) (2 diffs)

code/branches/ScriptableController_HS17/src/orxonox/scriptablecontroller/luatb.h

@@ -15 +15 @@
     // visible, you should call it like this:
     //
-    // LuaWrapper<decltype(foo)>::registerFunction<foo>( ... );
+    // LuaTB<decltype(foo)>::registerFunction<foo>( ... );
     template<FunctionType func>
     static void registerFunction(ThisType *_this, lua_State *lua, std::string name);

code/branches/ScriptableController_HS17/src/orxonox/scriptablecontroller/luatb.ipp

@@ -3 +3 @@
 #include <iostream>
 #include <type_traits>
-#include "scriptable_controller_api.h"
 #include "luatb_typed_stack.h"
 
@@ -20 +19 @@
     {
         // Store the 'this' pointer of the caller in the extraspace
-//        *static_cast<ThisType**>(lua_getextraspace(lua)) = _this;
+        LuaTB<ThisType, Ret (ThisType::*)(Args...)>::stateToClassMap[lua] = _this;
 
         // Make a function visible to lua that will call 'func' with the correct
@@ -28 +27 @@
 
 private:
+    static std::map<lua_State*, ThisType*> stateToClassMap;
+
     // Represents a function that can made visible to lua with the correct
     // signature. It will call the corresponding C++ function with the
@@ -34 +35 @@
     static int toLuaSignature(lua_State *lua)
     {
-        // The number of arguments is the first item on the stack
-        int argc = lua_tointeger(lua, lua_gettop(lua));
-        lua_pop(lua, 1);
+        // The index of the topmost item on the stack equals the size of
+        // the stack, which also equals the number of arguments
+        int argc = lua_gettop(lua);
 
         // Check if the number of arguments match
         if(argc != sizeof...(Args))
         {
-            std::cerr << "ERROR: LuaTB: Lua script called a function with wrong number of arguments" << std::endl;
+            std::cerr << "ERROR: LuaTB: Lua script called a function with wrong number of arguments (" << argc << " given, " << sizeof...(Args) << " expected)" << std::endl;
             return LUA_ERRSYNTAX;
         }
-
-        // Retrieve 'this' pointer of caller
-//        ThisType *_this = *static_cast<ThisType**>(lua_getextraspace(lua));
-ThisType *_this = orxonox::ScriptableControllerAPI::this_;
+        orxonox::orxout(orxonox::user_warning) << "what" << std::endl;
 
         // Call getArgument for every argument seperately to convert each argument
         // to the correct type and call the function afterwards
-        ((*_this).*func)( (LuaTBTypedStack::getArgument<Args>(lua))... );
+        ((*LuaTB<ThisType, Ret (ThisType::*)(Args...)>::stateToClassMap[lua]).*func)( (LuaTBTypedStack::getArgument<Args>(lua))... );
 
         return 0;
     }
 };
+
+// This needs to be here and not in a source file, because the compiler can't know
+// the template types if it's in a separate module.
+template<typename ThisType, typename Ret, typename... Args>
+std::map<lua_State*, ThisType*> LuaTB<ThisType, Ret (ThisType::*)(Args...)>::stateToClassMap = std::map<lua_State*, ThisType*>();

code/branches/ScriptableController_HS17/src/orxonox/scriptablecontroller/luatb_typed_stack.cc

@@ -1 +1 @@
 
 #include "luatb_typed_stack.h"
+#include "luatb.h"
 #include <string>
 

code/branches/ScriptableController_HS17/src/orxonox/scriptablecontroller/luatb_typed_stack.h

@@ -6 +6 @@
 #include <lua.hpp>
 #include "is_callable.h"
+#include "core/CoreIncludes.h"
 
 // We need a separate class for this because we need to specialize the functions
@@ -54 +55 @@
         static std::function<Ret (Args...)> value(lua_State *lua, int ref)
         {
+            orxonox::orxout(orxonox::user_warning) << "Ref1: " << ref << std::endl;
             return [lua, ref](Args... args){return callLuaFunction<Ret, Args...>(lua, ref, args...);};
         }
@@ -65 +67 @@
         // We pass one extra argument in case the function has no arguments at all
         pushArgumentsToLuaStack<Args...>(lua, args..., false);
-        lua_pcall(lua, 1, sizeof...(args), 0);
+        int r = lua_pcall(lua, 1, sizeof...(args), 0);
+
+        orxonox::orxout(orxonox::user_warning) << "Ref2: " << ref << std::endl;
+if(r != 0){
+        const char* message = lua_tostring(lua, -1);
+        std::cout << message << std::endl;
+        lua_pop(lua, 1);
+}
 
         // TODO

code/branches/ScriptableController_HS17/src/orxonox/scriptablecontroller/scriptable_controller.cc

@@ -6 +6 @@
 {
 
+RegisterUnloadableClass(ScriptableController);
+
 // Used https://csl.name/post/lua-and-cpp/ as a reference
+ScriptableController::ScriptableController(Context* context)
+    : BaseObject(context)
+{
+    RegisterObject(ScriptableController);
+}
+
 int ScriptableController::runScript(const std::string &file_path)
 {
@@ -71 +79 @@
 }
 
+void ScriptableController::registerTimeout(std::function<void ()> callback, double timeout)
+{
+    this->timeouts.push_back(std::make_pair(callback, static_cast<float>(timeout)));
+    orxout(user_warning) << "Calling should work..." << std::endl;
+    callback();
+}
+
+void ScriptableController::tick(float dt)
+{
+    auto timeout = this->timeouts.begin();
+
+    while(timeout != this->timeouts.end())
+    {
+        timeout->second -= dt;
+        if(timeout->second <= 0)
+        {
+            orxout(user_warning) << "Calling..." << std::endl;
+            timeout->first();
+            timeout = this->timeouts.erase(timeout);
+        }
+        else
+        {
+            timeout++;
+        }
+    }
+
+    Tickable::tick(dt);
+}
+
 void ScriptableController::printLuaError(lua_State *lua)
 {

code/branches/ScriptableController_HS17/src/orxonox/scriptablecontroller/scriptable_controller.h

@@ -17 +17 @@
 {
 
-class ScriptableController
+class ScriptableController : public BaseObject, public Tickable
 {
 public:
+    explicit ScriptableController(Context *context);
+
     int runScript(const std::string &file_path);
 
@@ -28 +30 @@
     ControllableEntity *getControllableEntityByID(int id) const;
 
+    void registerTimeout(std::function<void (void)> callback, double timeout);
+
+    virtual void tick(float dt) override;
+
 private:
     std::list<std::unique_ptr<ScriptableControllerAPI> > apis_;
@@ -33 +39 @@
     std::map<int, WorldEntity*> worldEntities_;
     std::map<int, ControllableEntity*> controllabelEntities_;
+    std::list<std::pair<std::function<void (void)>, float> > timeouts;
 
     void printLuaError(lua_State *lua);

code/branches/ScriptableController_HS17/src/orxonox/scriptablecontroller/scriptable_controller_api.cc

@@ -9 +9 @@
 {
 
-ScriptableControllerAPI *ScriptableControllerAPI::this_;
-
 ScriptableControllerAPI::ScriptableControllerAPI(lua_State *lua, ScriptableController *controller)
 {
     this->lua_ = lua;
     this->controller_ = controller;
-    ScriptableControllerAPI::this_ = this;
 
     // Haven't found a shorter way yet to write that...
-    LuaTB<ScriptableControllerAPI, decltype(&ScriptableControllerAPI::testOutput)>::registerFunction<&ScriptableControllerAPI::testOutput>(this, lua, "testOutput");
     LuaTB<ScriptableControllerAPI, decltype(&ScriptableControllerAPI::registerAfterTimeout)>::registerFunction<&ScriptableControllerAPI::registerAfterTimeout>(this, lua, "registerAfterTimeout");
     LuaTB<ScriptableControllerAPI, decltype(&ScriptableControllerAPI::registerAtNearObject)>::registerFunction<&ScriptableControllerAPI::registerAtNearObject>(this, lua, "registerAtNearObject");
@@ -32 +28 @@
 }
 
-void ScriptableControllerAPI::testOutput()
+void ScriptableControllerAPI::registerAfterTimeout(std::function<void (void)> callback, double timeout)
 {
-    orxout(user_info) << "Wheee!!!" << std::endl;
-}
-
-void ScriptableControllerAPI::registerAfterTimeout(std::function<void (void)> callback, int timeout_ms)
-{
-
+    this->controller_->registerTimeout(callback, timeout);
 }
 
 int ScriptableControllerAPI::registerAtNearObject(std::function<void (int, int)> callback, int obj1, int obj2, double distance)
 {
-
+    orxout(user_warning) << "Working!" << std::endl;
 }
 

code/branches/ScriptableController_HS17/src/orxonox/scriptablecontroller/scriptable_controller_api.h

@@ -20 +20 @@
     ~ScriptableControllerAPI();
 
-    void testOutput(void);
+    void testOutput(std::function<void(std::string)> callback);
 
-    void registerAfterTimeout(std::function<void (void)> callback, int timeout_ms);
+    void registerAfterTimeout(std::function<void (void)> callback, double timeout);
     int registerAtNearObject(std::function<void(int, int)> callback, int obj1, int obj2, double distance);
     int registerAtAreaEnter(std::function<void (int)> callback, int obj, int x, int y, int z, int dx, int dy, int dz);
@@ -33 +33 @@
     int setObjectPosition(int obj, double x, double y, double z);
 
-    static ScriptableControllerAPI *this_;
-
 private:
     lua_State *lua_;