Index: branches/mountain_lake/src/lib/graphics/effects/cloud_effect.cc
===================================================================
--- branches/mountain_lake/src/lib/graphics/effects/cloud_effect.cc	(revision 8946)
+++ branches/mountain_lake/src/lib/graphics/effects/cloud_effect.cc	(revision 8947)
@@ -27,4 +27,5 @@
 #include "shell_command.h"
 #include "t_animation.h"
+#include "script_class.h"
 
 #include "parser/tinyxml/tinyxml.h"
@@ -48,4 +49,11 @@
 SHELL_COMMAND(skyColor, CloudEffect, shellSkyColor);
 SHELL_COMMAND(cloudColor, CloudEffect, shellCloudColor);
+
+
+CREATE_SCRIPTABLE_CLASS(CloudEffect, CL_CLOUD_EFFECT,
+                        addMethod("shellSkyColor", ExecutorLua4<CloudEffect,float,float,float,float>(&CloudEffect::shellSkyColor))
+                      ->addMethod("shellCloudColor", ExecutorLua4<CloudEffect,float,float,float,float>(&CloudEffect::shellCloudColor))
+                       );
+
 
 CREATE_FACTORY(CloudEffect, CL_CLOUD_EFFECT);
Index: branches/mountain_lake/src/lib/graphics/effects/cloud_effect.h
===================================================================
--- branches/mountain_lake/src/lib/graphics/effects/cloud_effect.h	(revision 8946)
+++ branches/mountain_lake/src/lib/graphics/effects/cloud_effect.h	(revision 8947)
@@ -50,42 +50,41 @@
     virtual void deactivate();
 
-    inline void activateCloud() {
+    void activateCloud() {
         this->activate();
     }
-
-    inline void deactivateCloud() {
+    void deactivateCloud() {
         this->deactivate();
     }
 
-    inline void setCloudOption(const std::string& option) {
+    void setCloudOption(const std::string& option) {
         if (option == "activate")
             this->cloudActivate = true;
     }
 
-    inline void setAnimationSpeed(float speed) {
+    void setAnimationSpeed(float speed) {
         this->animationSpeed = speed;
     }
 
-    inline void setCloudScale(float scale) {
+    void setCloudScale(float scale) {
         this->scale = scale;
     }
 
-    inline void setCloudColor(float colorX, float colorY, float colorZ) {
+    void setCloudColor(float colorX, float colorY, float colorZ) {
         this->cloudColor = Vector(colorX, colorY, colorZ);
     }
 
-    inline void setSkyColor(float colorX, float colorY, float colorZ) {
+    void setSkyColor(float colorX, float colorY, float colorZ) {
         this->skyColor = Vector(colorX, colorY, colorZ);
     }
 
-    inline void setPlanetRadius(float planetRadius) {
+    void setPlanetRadius(float planetRadius) {
         this->planetRadius = planetRadius;
     }
 
-    inline void setAtmosphericRadius(float atmosphericRadius) {
+    void setAtmosphericRadius(float atmosphericRadius) {
         this->atmosphericRadius = atmosphericRadius;
     }
 
-    inline void setDivisions(int divs) {
+    void setDivisions(int divs) {
         this->divs = divs;
     }
Index: branches/mountain_lake/src/lib/util/executor/executor_lua.h
===================================================================
--- branches/mountain_lake/src/lib/util/executor/executor_lua.h	(revision 8946)
+++ branches/mountain_lake/src/lib/util/executor/executor_lua.h	(revision 8947)
@@ -44,9 +44,9 @@
   public:
     /**
-     * @brief Constructor of a ExecutorXML
-     * @param function a Function to call
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
      */
     ExecutorLua0(void(T::*function)())
-        : Executor()
+  : Executor()
     {
       this->functionPointer = function;
@@ -91,18 +91,18 @@
   public:
     /**
-     * @brief Constructor of a ExecutorXML
-     * @param function a Function to call
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
      */
     ExecutorLua1(void(T::*function)(type0))
-        : Executor(ExecutorParamType<type0>())
-    {
-      this->functionPointer = function;
-      this->functorType = Executor_Objective | Executor_NoLoadString;
-    }
-
-    /**
-       * @brief executes the Command on BaseObject
-       * @param object the BaseObject to execute this Executor on
-       * @param loadString ignored in this case
+  : Executor(ExecutorParamType<type0>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
      */
     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
@@ -120,5 +120,5 @@
 
     /**
-       * @returns a _new_ Copy of this Executor
+     * @returns a _new_ Copy of this Executor
      */
     virtual Executor* clone () const
@@ -140,9 +140,9 @@
   public:
     /**
-     * @brief Constructor of a ExecutorXML
-     * @param function a Function to call
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
      */
     ExecutorLua2(void(T::*function)(type0, type1))
-        : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
     {
       this->functionPointer = function;
@@ -166,6 +166,6 @@
 
       (dynamic_cast<T*>(object)->*(functionPointer))(
-        fromLua<type0>(state, 1),
-        fromLua<type1>(state, 2) );
+          fromLua<type0>(state, 1),
+      fromLua<type1>(state, 2) );
     }
 
@@ -217,6 +217,6 @@
       (dynamic_cast<T*>(object)->*(functionPointer))(
           fromLua<type0>(state, 1),
-          fromLua<type1>(state, 2),
-          fromLua<type2>(state, 3) );
+      fromLua<type1>(state, 2),
+      fromLua<type2>(state, 3) );
     }
 
@@ -233,4 +233,54 @@
 
 
+///////////
+//// 4 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4 : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua4(void(T::*function)(type0, type1, type2, type3))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 0;
+
+      (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+      fromLua<type1>(state, 2),
+      fromLua<type2>(state, 3),
+      fromLua<type3>(state, 4) );
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua4<T, type0, type1, type2, type3>(this->functionPointer);
+    }
+  private:
+    void          (T::*functionPointer)(type0, type1, type2, type3);
+};
 
 
@@ -250,9 +300,9 @@
   public:
     /**
-     * @brief Constructor of a ExecutorXML
-     * @param function a Function to call
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
      */
     ExecutorLua0ret(ret (T::*function)())
-        : Executor()
+  : Executor()
     {
       this->functionPointer = function;
@@ -279,5 +329,5 @@
 
     /**
-                       * @returns a _new_ Copy of this Executor
+     * @returns a _new_ Copy of this Executor
      */
     virtual Executor* clone () const
@@ -299,9 +349,9 @@
   public:
     /**
-     * @brief Constructor of a ExecutorXML
-     * @param function a Function to call
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
      */
     ExecutorLua1ret(ret (T::*function)(type0))
-        : Executor(ExecutorParamType<type0>())
+  : Executor(ExecutorParamType<type0>())
     {
       this->functionPointer = function;
@@ -325,5 +375,5 @@
 
       toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
-                   fromLua<type0>(state, 1)));
+          fromLua<type0>(state, 1)));
     }
 
@@ -347,9 +397,9 @@
   public:
     /**
-     * @brief Constructor of a ExecutorXML
-     * @param function a Function to call
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
      */
     ExecutorLua2ret(ret (T::*function)(type0, type1))
-        : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
     {
       this->functionPointer = function;
@@ -373,18 +423,286 @@
 
       toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua2ret<T, ret, type0, type1>(this->functionPointer);
+    }
+  private:
+    ret           (T::*functionPointer)(type0, type1);
+};
+
+
+///////////
+//// 3 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2> class ExecutorLua3ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua3ret(ret (T::*function)(type0, type1, type2))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua3ret<T, ret, type0, type1, type2>(this->functionPointer);
+    }
+  private:
+    ret          (T::*functionPointer)(type0, type1, type2);
+};
+
+
+///////////
+//// 4 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua4ret(ret (T::*function)(type0, type1, type2, type3))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3),
+          fromLua<type3>(state, 4) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua4ret<T, ret, type0, type1, type2, type3>(this->functionPointer);
+    }
+  private:
+    ret          (T::*functionPointer)(type0, type1, type2, type3);
+};
+
+///////////
+//// 5 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4> class ExecutorLua5ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua5ret(ret (T::*function)(type0, type1, type2, type3, type4))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3),
+          fromLua<type3>(state, 4),
+          fromLua<type4>(state, 5) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua5ret<T, ret, type0, type1, type2, type3, type4>(this->functionPointer);
+    }
+  private:
+    ret          (T::*functionPointer)(type0, type1, type2, type3, type4);
+};
+
+///////////
+//// 6 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5> class ExecutorLua6ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua6ret(ret (T::*function)(type0, type1, type2, type3, type4, type5))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
+             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
+             ExecutorParamType<type4>(), ExecutorParamType<type5>())
+             {
+               this->functionPointer = function;
+               this->functorType = Executor_Objective | Executor_NoLoadString;
+             }
+
+    /**
+              * @brief executes the Command on BaseObject
+              * @param object the BaseObject to execute this Executor on
+              * @param loadString ignored in this case
+     */
+             virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+             {
+               PRINTF(1)("no usefull executor\n");
+             }
+
+             virtual void operator()(BaseObject* object, int& count, void* values) const
+             {
+               lua_State* state = (lua_State*)values;
+               count = 1;
+
+               toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
                    fromLua<type0>(state, 1),
-                   fromLua<type1>(state, 2) ));
-    }
-
-    /**
-     * @returns a _new_ Copy of this Executor
-     */
-    virtual Executor* clone () const
-    {
-      return new ExecutorLua2ret<T, ret, type0, type1>(this->functionPointer);
-    }
-  private:
-    ret           (T::*functionPointer)(type0, type1);
-};
+                   fromLua<type1>(state, 2),
+                   fromLua<type2>(state, 3),
+                   fromLua<type3>(state, 4),
+                   fromLua<type4>(state, 5),
+                   fromLua<type5>(state, 6) ));
+             }
+
+    /**
+              * @returns a _new_ Copy of this Executor
+     */
+             virtual Executor* clone () const
+             {
+               return new ExecutorLua6ret<T, ret, type0, type1, type2, type3, type4, type5>(this->functionPointer);
+             }
+  private:
+    ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5);
+};
+
+///////////
+//// 7 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5, typename type6> class ExecutorLua7ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua7ret(ret (T::*function)(type0, type1, type2, type3, type4, type5, type6))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
+             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
+             ExecutorParamType<type4>(), ExecutorParamType<type5>(),
+             ExecutorParamType<type6>())
+             {
+               this->functionPointer = function;
+               this->functorType = Executor_Objective | Executor_NoLoadString;
+             }
+
+    /**
+              * @brief executes the Command on BaseObject
+              * @param object the BaseObject to execute this Executor on
+              * @param loadString ignored in this case
+     */
+             virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+             {
+               PRINTF(1)("no usefull executor\n");
+             }
+
+             virtual void operator()(BaseObject* object, int& count, void* values) const
+             {
+               lua_State* state = (lua_State*)values;
+               count = 1;
+
+               toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+                   fromLua<type0>(state, 1),
+                   fromLua<type1>(state, 2),
+                   fromLua<type2>(state, 3),
+                   fromLua<type3>(state, 4),
+                   fromLua<type4>(state, 5),
+                   fromLua<type5>(state, 6),
+                   fromLua<type6>(state, 7) ));
+             }
+
+    /**
+              * @returns a _new_ Copy of this Executor
+     */
+             virtual Executor* clone () const
+             {
+               return new ExecutorLua7ret<T, ret, type0, type1, type2, type3, type4, type5, type6>(this->functionPointer);
+             }
+  private:
+    ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5, type6);
+};
+
 
 #endif /* _EXECUTOR_LUA_H */
