simplify script exporting, fix invalid indenting

scripts/native/skill/ActionSprint.cpp

@@ -12,4 +12,4 @@ public:
    }
 };
 
-EXPORT_ACTIONSCRIPT( ActionSprint )
+EXPORT_SCRIPTOBJECT( ActionSprint )

scripts/native/statuseffect/StatusSprint.cpp

@@ -26,4 +26,4 @@ public:
 
 };
 
-EXPORT_STATUSEFFECTSCRIPT( StatusSprint )
+EXPORT_SCRIPTOBJECT( StatusSprint )

src/servers/Server_Zone/Script/NativeScript.cpp

@@ -1,139 +1,148 @@
 #include "NativeScript.h"
 
 namespace Core {
-    namespace Scripting {
+   namespace Scripting {
 
-        NativeScript::NativeScript( )
+   NativeScript::NativeScript( )
-        { }
+   { }
 
-        StatusEffectScript* NativeScript::getStatusEffectScript( uint32_t statusId )
+   StatusEffectScript* NativeScript::getStatusEffectScript( uint32_t statusId )
-        {
+   {
-           auto script = m_statusEffectScripts.find( statusId );
+   auto script = m_statusEffectScripts.find( statusId );
-           if( script == m_statusEffectScripts.end() )
+   if( script == m_statusEffectScripts.end() )
-              return nullptr;
+      return nullptr;
 
-           return script->second;
+   return script->second;
-        }
+   }
 
-        ActionScript* NativeScript::getActionScript(uint32_t abilityId)
+   ActionScript* NativeScript::getActionScript( uint32_t actionId )
-        {
+   {
-           auto script = m_actionScripts.find( abilityId );
+      auto script = m_actionScripts.find( actionId );
-           if( script == m_actionScripts.end() )
+      if( script == m_actionScripts.end() )
-              return nullptr;
+         return nullptr;
 
-           return script->second;
+      return script->second;
-        }
+   }
 
-        QuestScript* NativeScript::getQuestScript( uint32_t questId )
+   QuestScript* NativeScript::getQuestScript( uint32_t questId )
-        {
+   {
-           auto script = m_questScripts.find( questId );
+      auto script = m_questScripts.find( questId );
-           if( script == m_questScripts.end() )
+      if( script == m_questScripts.end() )
-              return nullptr;
+         return nullptr;
 
-           return script->second;
+      return script->second;
-        }
+   }
 
-        BattleNpcScript* NativeScript::getBattleNpcScript( uint32_t npcId )
+   BattleNpcScript* NativeScript::getBattleNpcScript( uint32_t npcId )
-        {
+   {
-           auto script = m_battleNpcScripts.find( npcId );
+      auto script = m_battleNpcScripts.find( npcId );
-           if( script == m_battleNpcScripts.end() )
+      if( script == m_battleNpcScripts.end() )
-              return nullptr;
+         return nullptr;
 
-           return script->second;
+      return script->second;
-        }
+   }
 
-        ZoneScript* NativeScript::getZoneScript( uint32_t zoneId )
+   ZoneScript* NativeScript::getZoneScript( uint32_t zoneId )
-        {
+   {
-           auto script = m_zoneScripts.find( zoneId );
+      auto script = m_zoneScripts.find( zoneId );
-           if( script == m_zoneScripts.end() )
+      if( script == m_zoneScripts.end() )
-              return nullptr;
+         return nullptr;
 
-           return script->second;
+      return script->second;
-        }
+   }
 
-        bool NativeScript::loadScript( std::string path )
+   bool NativeScript::loadScript( const std::string& path )
-        {
+   {
-           auto info = m_loader.loadModule( path );
+      auto module = m_loader.loadModule( path );
-           if( info )
+      if( module )
-           {
+      {
-              // todo: this is shit
+         auto script = m_loader.getScriptObject( module->handle );
-              if( auto script = m_loader.getScriptObject< StatusEffectScript >( info->handle, "StatusEffectScript" ) )
+         if( script )
-              {
+         {
-                 // todo: make this a define or something
+            module->script = script;
-                 info->script = script;
+            module->script_name = script->getName();
-                 info->script_name = script->getName();
+            module->type = script->getType();
-                 m_statusEffectScripts[ script->getId() ] = script;
-              }
-              else if( auto script = m_loader.getScriptObject< ActionScript >( info->handle, "ActionScript" ) )
-              {
-                 info->script = script;
-                 info->script_name = script->getName();
-                 m_actionScripts[ script->getId() ] = script;
-              }
-              else if( auto script = m_loader.getScriptObject< QuestScript >( info->handle, "QuestScript" ) )
-              {
-                 info->script = script;
-                 info->script_name = script->getName();
-                 m_questScripts[ script->getId() ] = script;
-              }
-              else if( auto script = m_loader.getScriptObject< BattleNpcScript >( info->handle, "BattleNpcScript" ) )
-              {
-                 info->script = script;
-                 info->script_name = script->getName();
-                 m_battleNpcScripts[ script->getId() ] = script;
-              }
-              else if( auto script = m_loader.getScriptObject< ZoneScript >( info->handle, "ZoneScript" ) )
-              {
-                 info->script = script;
-                 info->script_name = script->getName();
-                 m_zoneScripts[ script->getId() ] = script;
-              }
-              else
-              {
-                 // unload anything which doesn't have a suitable export
-                 m_loader.unloadScript( info->handle );
 
-                 return false;
+            switch( script->getType() )
-              }
+            {
-           }
+               case ScriptType::StatusEffect:
-           else
+                  m_statusEffectScripts[ script->getId() ] = dynamic_cast< StatusEffectScript* >( script );
-              return false;
+                  break;
+               case ScriptType::Action:
+                  m_actionScripts[ script->getId() ] = dynamic_cast< ActionScript* >( script );
+                  break;
+               case ScriptType::Quest:
+                  m_questScripts[ script->getId() ] = dynamic_cast< QuestScript* >( script );
+                  break;
+               case ScriptType::BattleNpc:
+                  m_battleNpcScripts[ script->getId() ] = dynamic_cast< BattleNpcScript* >( script );
+                  break;
+               case ScriptType::Zone:
+                  m_zoneScripts[ script->getId() ] = dynamic_cast< ZoneScript* >( script );
+                  break;
 
-           return true;
+               default:
-        }
+                  m_loader.unloadScript( module );
+                  return false;
+            }
+         }
+         else
+         {
+            m_loader.unloadScript( module );
+            return false;
+         }
 
-        const std::string NativeScript::getModuleExtension()
+      }
-        {
+      else
-           return m_loader.getModuleExtension();
+         return false;
-        }
 
-        bool NativeScript::unloadScript( std::string name )
+      return true;
-        {
+   }
-           auto info = m_loader.getScriptInfo( name );
-           if( info )
-           {
-              auto ptr = info->script;
 
-              if( removeValueFromMap< uint32_t, StatusEffectScript* >( ptr, m_statusEffectScripts ) )
+   const std::string NativeScript::getModuleExtension()
-                 return m_loader.unloadScript( info );
+   {
-              else if( removeValueFromMap< uint32_t, ActionScript* >( ptr, m_actionScripts ) )
+      return m_loader.getModuleExtension();
-                 return m_loader.unloadScript( info );
+   }
-              else if( removeValueFromMap< uint32_t, QuestScript* >( ptr, m_questScripts ) )
-                 return m_loader.unloadScript( info );
-              else if( removeValueFromMap< uint32_t, BattleNpcScript* >( ptr, m_battleNpcScripts ) )
-                 return m_loader.unloadScript( info );
-              else if( removeValueFromMap< uint32_t, ZoneScript* >( ptr, m_zoneScripts ) )
-                 return m_loader.unloadScript( info );
 
-           }
+   bool NativeScript::unloadScript( const std::string& name )
+   {
+      auto info = m_loader.getScriptInfo( name );
+      if( info )
+      {
+         auto ptr = info->script;
 
-           return false;
+         switch( info->type )
-        }
+         {
+            case ScriptType::StatusEffect:
+               removeValueFromMap< uint32_t, StatusEffectScript* >( ptr, m_statusEffectScripts );
+               break;
+            case ScriptType::Action:
+               removeValueFromMap< uint32_t, ActionScript* >( ptr, m_actionScripts );
+               break;
+            case ScriptType::Quest:
+               removeValueFromMap< uint32_t, QuestScript* >( ptr, m_questScripts );
+               break;
+            case ScriptType::BattleNpc:
+               removeValueFromMap< uint32_t, BattleNpcScript* >( ptr, m_battleNpcScripts );
+               break;
+            case ScriptType::Zone:
+               removeValueFromMap< uint32_t, ZoneScript* >( ptr, m_zoneScripts );
+               break;
+
+            default:
+               return false;
+         }
+
+         return m_loader.unloadScript( info );
+      }
+
+      return false;
+   }
 
 
-        boost::shared_ptr< NativeScript > create_script_engine( )
+   boost::shared_ptr< NativeScript > create_script_engine( )
-        {
+   {
-           return boost::make_shared< NativeScript >();
+      return boost::make_shared< NativeScript >();
-        }
+   }
-    }
+}
 }

src/servers/Server_Zone/Script/NativeScript.h

@@ -12,53 +12,53 @@
 #include "ScriptLoader.h"
 
 namespace Core {
-    namespace Scripting {
+namespace Scripting {
 
-        class NativeScript
+   class NativeScript
-        {
+   {
-        protected:
+   protected:
-            std::unordered_map< uint32_t, StatusEffectScript* > m_statusEffectScripts;
+      std::unordered_map< uint32_t, StatusEffectScript* > m_statusEffectScripts;
-            std::unordered_map< uint32_t, ActionScript* > m_actionScripts;
+      std::unordered_map< uint32_t, ActionScript* > m_actionScripts;
-            std::unordered_map< uint32_t, QuestScript* > m_questScripts;
+      std::unordered_map< uint32_t, QuestScript* > m_questScripts;
-            std::unordered_map< uint32_t, BattleNpcScript* > m_battleNpcScripts;
+      std::unordered_map< uint32_t, BattleNpcScript* > m_battleNpcScripts;
-            std::unordered_map< uint32_t, ZoneScript* > m_zoneScripts;
+      std::unordered_map< uint32_t, ZoneScript* > m_zoneScripts;
 
-            ScriptLoader m_loader;
+      ScriptLoader m_loader;
 
-        public:
+   public:
-            NativeScript( );
+      NativeScript( );
 
-            StatusEffectScript* getStatusEffectScript( uint32_t statusId );
+      StatusEffectScript* getStatusEffectScript( uint32_t statusId );
-            ActionScript* getActionScript(uint32_t abilityId);
+      ActionScript* getActionScript( uint32_t actionId );
-            QuestScript* getQuestScript( uint32_t questId );
+      QuestScript* getQuestScript( uint32_t questId );
-            BattleNpcScript* getBattleNpcScript( uint32_t npcId );
+      BattleNpcScript* getBattleNpcScript( uint32_t npcId );
-            ZoneScript* getZoneScript( uint32_t zoneId );
+      ZoneScript* getZoneScript( uint32_t zoneId );
 
-            bool loadScript( std::string );
+      bool loadScript( const std::string& path );
-            bool unloadScript( std::string );
+      bool unloadScript( const std::string& name );
 
-            const std::string getModuleExtension();
+      const std::string getModuleExtension();
 
-            template< typename key, typename val >
+      template< typename key, typename val >
-            bool removeValueFromMap( ScriptObject* ptr, std::unordered_map< key, val >& map )
+      bool removeValueFromMap( ScriptObject* ptr, std::unordered_map< key, val >& map )
+      {
+         for( typename std::unordered_map< key, val >::iterator it = map.begin(); it != map.end(); ++it )
+         {
+            if( ptr == static_cast< ScriptObject* >( it->second ) )
             {
-               for( typename std::unordered_map< key, val >::iterator it = map.begin(); it != map.end(); ++it )
+               map.erase( it );
-               {
+               return true;
-                  if( ptr == static_cast< ScriptObject* >( it->second ) )
-                  {
-                     map.erase( it );
-                     return true;
-                  }
-               }
-
-               return false;
             }
-        };
+         }
+
+         return false;
+      }
+   };
 
 
 
-        boost::shared_ptr< NativeScript > create_script_engine( );
+   boost::shared_ptr< NativeScript > create_script_engine( );
-    } }
+} }
 
 
 #endif

src/servers/Server_Zone/Script/NativeScriptApi.h

@@ -12,28 +12,33 @@
 #define EXPORT __attribute__((visibility("default")))
 #endif
 
-#define EXPORT_SCRIPTOBJECT( type, base ) \
+#define EXPORT_SCRIPTOBJECT( type ) \
-extern "C" EXPORT base* get##base() \
+extern "C" EXPORT ScriptObject* getScript() \
-{ return static_cast< base* >( new type ); }
+{ return static_cast< ScriptObject* >( new type ); }
-
-#define EXPORT_STATUSEFFECTSCRIPT( type ) EXPORT_SCRIPTOBJECT( type, StatusEffectScript )
-#define EXPORT_ACTIONSCRIPT( type ) EXPORT_SCRIPTOBJECT( type, ActionScript )
-#define EXPORT_QUESTSCRIPT( type ) EXPORT_SCRIPTOBJECT( type, QuestScript )
-#define EXPORT_BATTLENPCSCRIPT( type ) EXPORT_SCRIPTOBJECT( type, BattleNpcScript )
-#define EXPORT_ZONESCRIPT( type ) EXPORT_SCRIPTOBJECT( type, ZoneScript )
 
 using namespace Core;
 
+enum ScriptType
+{
+    StatusEffect,
+    Action,
+    Quest,
+    BattleNpc,
+    Zone
+};
+
 class ScriptObject
 {
 protected:
    std::string m_scriptName;
    uint32_t m_id;
+   ScriptType m_type;
 
 public:
-   ScriptObject( std::string name, uint32_t id ) :
+   ScriptObject( std::string name, uint32_t id, ScriptType type ) :
       m_scriptName( name ),
-      m_id( id )
+      m_id( id ),
+      m_type( type )
    { }
 
    virtual const std::string& getName() const
@@ -45,6 +50,11 @@ public:
    {
       return m_id;
    }
+
+   virtual ScriptType getType() const
+   {
+      return m_type;
+   }
 };
 
 
@@ -52,7 +62,7 @@ class StatusEffectScript : public ScriptObject
 {
 public:
    StatusEffectScript( std::string name, uint32_t effectId ) :
-      ScriptObject( name, effectId )
+      ScriptObject( name, effectId, ScriptType::StatusEffect )
    { }
 
    virtual void onTick( Entity::Actor& actor ) { }
@@ -70,7 +80,7 @@ class ActionScript : public ScriptObject
 {
 public:
     ActionScript( std::string name, uint32_t abilityId ) :
-      ScriptObject( name, abilityId )
+      ScriptObject( name, abilityId, ScriptType::Action )
    { }
 
    virtual void onStart( Entity::Actor& sourceActor, Entity::Actor& targetActor ) { }
@@ -83,7 +93,7 @@ class QuestScript : public ScriptObject
 {
 public:
    QuestScript( std::string name, uint32_t questId ) :
-      ScriptObject( name, questId )
+      ScriptObject( name, questId, ScriptType::Quest )
    { }
 
    virtual void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) { }
@@ -96,7 +106,7 @@ class BattleNpcScript : public ScriptObject
 {
 public:
    BattleNpcScript( std::string name, uint32_t npcId ) :
-      ScriptObject( name, npcId )
+      ScriptObject( name, npcId, ScriptType::BattleNpc )
    { }
 };
 
@@ -104,7 +114,7 @@ class ZoneScript : public ScriptObject
 {
 public:
    ZoneScript( std::string name, uint32_t zoneId ) :
-      ScriptObject( name, zoneId )
+      ScriptObject( name, zoneId, ScriptType::Zone )
    { }
 
    virtual void onZoneInit() { }

src/servers/Server_Zone/Script/ScriptInfo.h

@@ -22,6 +22,7 @@ namespace Scripting {
         std::string script_name;
         ModuleHandle handle;
         ScriptObject* script;
+        ScriptType type;
     };
 }
 }

src/servers/Server_Zone/Script/ScriptLoader.cpp

@@ -41,7 +41,7 @@ bool Core::Scripting::ScriptLoader::unloadModule( ModuleHandle handle )
    return true;
 }
 
-Core::Scripting::ScriptInfo* Core::Scripting::ScriptLoader::loadModule( std::string path )
+Core::Scripting::ScriptInfo* Core::Scripting::ScriptLoader::loadModule( const std::string& path )
 {
    boost::filesystem::path f( path );
 
@@ -76,17 +76,14 @@ Core::Scripting::ScriptInfo* Core::Scripting::ScriptLoader::loadModule( std::str
    return info;
 }
 
-ScriptObject* Core::Scripting::ScriptLoader::getScriptObjectExport( ModuleHandle handle, std::string name )
+ScriptObject* Core::Scripting::ScriptLoader::getScriptObject( ModuleHandle handle )
 {
    typedef ScriptObject* (*getScriptObjectType)();
-   auto fn = boost::str( boost::format( "get%1%" ) % name );
-
-   g_log.debug( "getting symbol: " + fn  );
 
 #ifdef _WIN32
-   getScriptObjectType func = reinterpret_cast< getScriptObjectType >( GetProcAddress( handle, fn.c_str() ) );
+   getScriptObjectType func = reinterpret_cast< getScriptObjectType >( GetProcAddress( handle, "getScript" ) );
 #else
-   getScriptObjectType func = reinterpret_cast< getScriptObjectType >( dlsym( handle, fn.c_str() ) );
+   getScriptObjectType func = reinterpret_cast< getScriptObjectType >( dlsym( handle, "getScript" ) );
 #endif
 
    if( func )

src/servers/Server_Zone/Script/ScriptLoader.h

@@ -27,18 +27,12 @@ namespace Scripting {
        ScriptLoader();
 
        const std::string getModuleExtension();
-       ScriptInfo* loadModule( std::string );
+       ScriptInfo* loadModule( const std::string& );
        bool unloadScript( ScriptInfo* );
        bool unloadScript( ModuleHandle );
        ScriptInfo* getScriptInfo( std::string name );
-       ScriptObject* getScriptObjectExport( ModuleHandle handle, std::string name );
+       ScriptObject* getScriptObject(ModuleHandle handle);
        bool isModuleLoaded( std::string name );
-
-       template< typename T >
-       T* getScriptObject( ModuleHandle handle, std::string name )
-       {
-          return static_cast< T* >( getScriptObjectExport( handle, name ) );
-       }
    };
 
 }