mirrors/sapphire
1
Fork 0
mirror of https://github.com/SapphireServer/Sapphire.git synced 2025-04-25 14:07:46 +00:00
Code Activity

simplify script exporting, fix invalid indenting

Browse source
This commit is contained in:
GokuWeedLord 2017-12-12 14:57:13 +11:00
parent 010d09239d
commit ed8958fb43
8 changed files with 193 additions and 182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
scripts/native/skill/ActionSprint.cpp
View file

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

2
scripts/native/statuseffect/StatusSprint.cpp
View file

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

237
src/servers/Server_Zone/Script/NativeScript.cpp
View file

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

70
src/servers/Server_Zone/Script/NativeScript.h
View file

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

42
src/servers/Server_Zone/Script/NativeScriptApi.h
View file

@ -12,28 +12,33 @@
#define EXPORT __attribute__((visibility("default")))
#endif
#define EXPORT_SCRIPTOBJECT( type, base ) \
extern "C" EXPORT base* get##base() \
{ return static_cast< base* >( 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 )
#define EXPORT_SCRIPTOBJECT( type ) \
extern "C" EXPORT ScriptObject* getScript() \
{ return static_cast< ScriptObject* >( new type ); }
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() { }

1
src/servers/Server_Zone/Script/ScriptInfo.h
View file

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

11
src/servers/Server_Zone/Script/ScriptLoader.cpp
View file

@ -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 )

10
src/servers/Server_Zone/Script/ScriptLoader.h
View file

@ -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 ) );
}
};
}