STDMETHODIMP ScriptThread::put_FileName(BSTR newVal)
{
getScript()->put_FileName(newVal);
return S_OK;
}
OctreeElement::AppendState EntityItem::appendEntityData(OctreePacketData* packetData, EncodeBitstreamParams& params,
EntityTreeElementExtraEncodeData* entityTreeElementExtraEncodeData) const {
// ALL this fits...
// object ID [16 bytes]
// ByteCountCoded(type code) [~1 byte]
// last edited [8 bytes]
// ByteCountCoded(last_edited to last_updated delta) [~1-8 bytes]
// PropertyFlags<>( everything ) [1-2 bytes]
// ~27-35 bytes...
OctreeElement::AppendState appendState = OctreeElement::COMPLETED; // assume the best
// encode our ID as a byte count coded byte stream
QByteArray encodedID = getID().toRfc4122();
// encode our type as a byte count coded byte stream
ByteCountCoded<quint32> typeCoder = getType();
QByteArray encodedType = typeCoder;
quint64 updateDelta = getLastUpdated() <= getLastEdited() ? 0 : getLastUpdated() - getLastEdited();
ByteCountCoded<quint64> updateDeltaCoder = updateDelta;
QByteArray encodedUpdateDelta = updateDeltaCoder;
EntityPropertyFlags propertyFlags(PROP_LAST_ITEM);
EntityPropertyFlags requestedProperties = getEntityProperties(params);
EntityPropertyFlags propertiesDidntFit = requestedProperties;
// If we are being called for a subsequent pass at appendEntityData() that failed to completely encode this item,
// then our entityTreeElementExtraEncodeData should include data about which properties we need to append.
if (entityTreeElementExtraEncodeData && entityTreeElementExtraEncodeData->entities.contains(getEntityItemID())) {
requestedProperties = entityTreeElementExtraEncodeData->entities.value(getEntityItemID());
}
LevelDetails entityLevel = packetData->startLevel();
quint64 lastEdited = getLastEdited();
const bool wantDebug = false;
if (wantDebug) {
float editedAgo = getEditedAgo();
QString agoAsString = formatSecondsElapsed(editedAgo);
qDebug() << "Writing entity " << getEntityItemID() << " to buffer, lastEdited =" << lastEdited
<< " ago=" << editedAgo << "seconds - " << agoAsString;
}
bool successIDFits = false;
bool successTypeFits = false;
bool successCreatedFits = false;
bool successLastEditedFits = false;
bool successLastUpdatedFits = false;
bool successPropertyFlagsFits = false;
int propertyFlagsOffset = 0;
int oldPropertyFlagsLength = 0;
QByteArray encodedPropertyFlags;
int propertyCount = 0;
successIDFits = packetData->appendValue(encodedID);
if (successIDFits) {
successTypeFits = packetData->appendValue(encodedType);
}
if (successTypeFits) {
successCreatedFits = packetData->appendValue(_created);
}
if (successCreatedFits) {
successLastEditedFits = packetData->appendValue(lastEdited);
}
if (successLastEditedFits) {
successLastUpdatedFits = packetData->appendValue(encodedUpdateDelta);
}
if (successLastUpdatedFits) {
propertyFlagsOffset = packetData->getUncompressedByteOffset();
encodedPropertyFlags = propertyFlags;
oldPropertyFlagsLength = encodedPropertyFlags.length();
successPropertyFlagsFits = packetData->appendValue(encodedPropertyFlags);
}
bool headerFits = successIDFits && successTypeFits && successCreatedFits && successLastEditedFits
&& successLastUpdatedFits && successPropertyFlagsFits;
int startOfEntityItemData = packetData->getUncompressedByteOffset();
if (headerFits) {
bool successPropertyFits;
propertyFlags -= PROP_LAST_ITEM; // clear the last item for now, we may or may not set it as the actual item
// These items would go here once supported....
// PROP_PAGED_PROPERTY,
// PROP_CUSTOM_PROPERTIES_INCLUDED,
APPEND_ENTITY_PROPERTY(PROP_POSITION, appendPosition, getPosition());
APPEND_ENTITY_PROPERTY(PROP_DIMENSIONS, appendValue, getDimensions()); // NOTE: PROP_RADIUS obsolete
if (wantDebug) {
qDebug() << " APPEND_ENTITY_PROPERTY() PROP_DIMENSIONS:" << getDimensions();
}
APPEND_ENTITY_PROPERTY(PROP_ROTATION, appendValue, getRotation());
APPEND_ENTITY_PROPERTY(PROP_MASS, appendValue, getMass());
APPEND_ENTITY_PROPERTY(PROP_VELOCITY, appendValue, getVelocity());
APPEND_ENTITY_PROPERTY(PROP_GRAVITY, appendValue, getGravity());
APPEND_ENTITY_PROPERTY(PROP_DAMPING, appendValue, getDamping());
APPEND_ENTITY_PROPERTY(PROP_LIFETIME, appendValue, getLifetime());
APPEND_ENTITY_PROPERTY(PROP_SCRIPT, appendValue, getScript());
APPEND_ENTITY_PROPERTY(PROP_REGISTRATION_POINT, appendValue, getRegistrationPoint());
APPEND_ENTITY_PROPERTY(PROP_ANGULAR_VELOCITY, appendValue, getAngularVelocity());
APPEND_ENTITY_PROPERTY(PROP_ANGULAR_DAMPING, appendValue, getAngularDamping());
APPEND_ENTITY_PROPERTY(PROP_VISIBLE, appendValue, getVisible());
APPEND_ENTITY_PROPERTY(PROP_IGNORE_FOR_COLLISIONS, appendValue, getIgnoreForCollisions());
APPEND_ENTITY_PROPERTY(PROP_COLLISIONS_WILL_MOVE, appendValue, getCollisionsWillMove());
APPEND_ENTITY_PROPERTY(PROP_LOCKED, appendValue, getLocked());
APPEND_ENTITY_PROPERTY(PROP_USER_DATA, appendValue, getUserData());
appendSubclassData(packetData, params, entityTreeElementExtraEncodeData,
requestedProperties,
propertyFlags,
propertiesDidntFit,
propertyCount,
appendState);
}
if (propertyCount > 0) {
int endOfEntityItemData = packetData->getUncompressedByteOffset();
encodedPropertyFlags = propertyFlags;
int newPropertyFlagsLength = encodedPropertyFlags.length();
packetData->updatePriorBytes(propertyFlagsOffset,
(const unsigned char*)encodedPropertyFlags.constData(), encodedPropertyFlags.length());
// if the size of the PropertyFlags shrunk, we need to shift everything down to front of packet.
if (newPropertyFlagsLength < oldPropertyFlagsLength) {
int oldSize = packetData->getUncompressedSize();
const unsigned char* modelItemData = packetData->getUncompressedData(propertyFlagsOffset + oldPropertyFlagsLength);
int modelItemDataLength = endOfEntityItemData - startOfEntityItemData;
int newEntityItemDataStart = propertyFlagsOffset + newPropertyFlagsLength;
packetData->updatePriorBytes(newEntityItemDataStart, modelItemData, modelItemDataLength);
int newSize = oldSize - (oldPropertyFlagsLength - newPropertyFlagsLength);
packetData->setUncompressedSize(newSize);
} else {
assert(newPropertyFlagsLength == oldPropertyFlagsLength); // should not have grown
}
packetData->endLevel(entityLevel);
} else {
packetData->discardLevel(entityLevel);
appendState = OctreeElement::NONE; // if we got here, then we didn't include the item
}
// If any part of the model items didn't fit, then the element is considered partial
if (appendState != OctreeElement::COMPLETED) {
// add this item into our list for the next appendElementData() pass
entityTreeElementExtraEncodeData->entities.insert(getEntityItemID(), propertiesDidntFit);
}
return appendState;
}
STDMETHODIMP ScriptThread::get_FileName(BSTR *pRet)
{
getScript()->get_FileName(pRet);
return S_OK;
}
//-------------------------------------------------------------------------------------
int ClientApp::unregisterPyObjectToScript(const char* attrName)
{
return getScript().unregisterToModule(attrName);
}
//-------------------------------------------------------------------------------------
bool ClientApp::installEntityDef()
{
if(!EntityDef::installScript(getScript().getModule()))
return false;
// 初始化所有扩展模块
// assets/scripts/
if(!EntityDef::initialize(scriptBaseTypes_, g_componentType)){
return false;
}
// 注册一些接口到kbengine
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), publish, __py_getAppPublish, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), fireEvent, __py_fireEvent, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), player, __py_getPlayer, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getSpaceData, __py_GetSpaceData, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), callback, __py_callback, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), cancelCallback, __py_cancelCallback, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getWatcher, __py_getWatcher, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getWatcherDir, __py_getWatcherDir, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), disconnect, __py_disconnect, METH_VARARGS, 0)
// 获得资源全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getResFullPath, __py_getResFullPath, METH_VARARGS, 0)
// 是否存在某个资源
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), hasRes, __py_hasRes, METH_VARARGS, 0)
// 打开一个文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), open, __py_kbeOpen, METH_VARARGS, 0)
// 列出目录下所有文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), listPathRes, __py_listPathRes, METH_VARARGS, 0)
// 匹配相对路径获得全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), matchPath, __py_matchPath, METH_VARARGS, 0)
return true;
}
//-------------------------------------------------------------------------------------
bool PythonApp::uninstallPyScript()
{
script::PyMemoryStream::uninstallScript();
return uninstallPyModules() && getScript().uninstall();
}
//-------------------------------------------------------------------------------------
int ClientApp::registerPyObjectToScript(const char* attrName, PyObject* pyObj)
{
return getScript().registerToModule(attrName, pyObj);
}
void ScriptSelectorDlg::CreateControls()
{
////@begin ScriptSelectorDlg content construction
ScriptSelectorDlg* dlg = this;
wxBoxSizer* mainSizer = XGC_NEW wxBoxSizer(wxVERTICAL);
dlg->SetSizer(mainSizer);
mListCtrl = XGC_NEW wxListCtrl( dlg, ID_LISTCTRL, wxDefaultPosition, wxDefaultSize, wxLC_REPORT|wxLC_SINGLE_SEL );
mainSizer->Add(mListCtrl, 1, wxGROW|wxALL, 5);
wxBoxSizer* btnSizer = XGC_NEW wxBoxSizer(wxHORIZONTAL);
mainSizer->Add(btnSizer, 0, wxALIGN_RIGHT|wxALL, 5);
wxButton* btnConfirm = XGC_NEW wxButton( dlg, ID_BUTTON_OK, _("&OK"), wxDefaultPosition, wxDefaultSize, 0 );
btnSizer->Add(btnConfirm, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxButton* btnCancel = XGC_NEW wxButton( dlg, ID_BUTTON_CANCEL, _("&Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
btnSizer->Add(btnCancel, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
// Connect events and objects
mListCtrl->Connect(ID_LISTCTRL, wxEVT_LEFT_DCLICK, wxMouseEventHandler(ScriptSelectorDlg::OnLeftDClick), NULL, this);
////@end ScriptSelectorDlg content construction
mListCtrl->AppendColumn( "Name", wxLIST_FORMAT_LEFT, 80 );
mListCtrl->AppendColumn( "Path", wxLIST_FORMAT_LEFT, 400 );
mListCtrl->AppendColumn( "Version", wxLIST_FORMAT_LEFT, 100 );
auto &loader_path = getConfig().GetLoaderPath();
auto &module_path = getConfig().GetModulePath();
if( !fs::exists( loader_path ) )
return;
if( !fs::exists( module_path ) )
return;
int i = 0;
xgc_string version;
for( const auto &entry : fs::directory_iterator { module_path } )
{
if( fs::is_directory( entry ) )
{
if( entry.path() == fs::path(loader_path) )
continue;
if( !fs::exists( entry.path() / "version.py" ) )
continue;
if( !getScript().GetModuleVersion( entry.path().filename().string(), version ) )
continue;
int item = mListCtrl->InsertItem( i++, entry.path().filename().string(), -1 );
if( item != -1 )
{
mListCtrl->SetItem( item, 1, entry.path().string() );
mListCtrl->SetItem( item, 2, version );
}
}
}
}
//-------------------------------------------------------------------------------------
bool Bots::installPyModules()
{
ClientObject::installScript(NULL);
PyBots::installScript(NULL);
pPyBots_ = new PyBots();
registerPyObjectToScript("bots", pPyBots_);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), addBots, __py_addBots, METH_VARARGS, 0);
// 注册设置脚本输出类型
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), scriptLogType, __py_setScriptLogType, METH_VARARGS, 0)
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_NORMAL", log4cxx::ScriptLevel::SCRIPT_INT))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_NORMAL.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_INFO", log4cxx::ScriptLevel::SCRIPT_INFO))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_INFO.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_ERR", log4cxx::ScriptLevel::SCRIPT_ERR))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_ERR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_DBG", log4cxx::ScriptLevel::SCRIPT_DBG))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_DBG.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_WAR", log4cxx::ScriptLevel::SCRIPT_WAR))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_WAR.\n");
}
registerScript(client::Entity::getScriptType());
// 安装入口模块
PyObject *entryScriptFileName = PyUnicode_FromString(g_kbeSrvConfig.getBots().entryScriptFile);
if(entryScriptFileName != NULL)
{
entryScript_ = PyImport_Import(entryScriptFileName);
if (PyErr_Occurred())
{
INFO_MSG(fmt::format("EntityApp::installPyModules: importing scripts/bots/{}.py...\n",
g_kbeSrvConfig.getBots().entryScriptFile));
PyErr_PrintEx(0);
}
S_RELEASE(entryScriptFileName);
if(entryScript_.get() == NULL)
{
return false;
}
}
onInstallPyModules();
return true;
}
void ManageSieveCommand::execute()
{
if ( d->done )
return;
bool ok = true;
switch ( d->cmd ) {
case Logout:
log( "Received LOGOUT command", Log::Debug );
d->sieve->Connection::setState( Connection::Closing );
break;
case Capability:
end();
if ( d->no.isEmpty() )
d->sieve->capabilities();
break;
case StartTls:
ok = startTls();
break;
case Authenticate:
ok = authenticate();
break;
case HaveSpace:
ok = haveSpace();
break;
case PutScript:
ok = putScript();
break;
case ListScripts:
ok = listScripts();
break;
case SetActive:
ok = setActive();
break;
case GetScript:
ok = getScript();
break;
case DeleteScript:
ok = deleteScript();
break;
case RenameScript:
ok = renameScript();
break;
case Noop:
ok = noop();
break;
case XAoxExplain:
ok = explain();
break;
case Unknown:
no( "Unknown command" );
break;
}
if ( d->query && d->query->failed() && d->no.isEmpty() )
no( "Database failed: " + d->query->error() );
else if ( d->t && d->t->failed() && d->no.isEmpty() )
no( "Database failed: " + d->t->error() ); // XXX need to rollback?
if ( !d->no.isEmpty() )
ok = true;
if ( !ok )
return;
d->done = true;
if ( d->no.isEmpty() ) {
d->sieve->enqueue( "OK" );
if ( !d->ok.isEmpty() ) {
d->sieve->enqueue( " " );
d->sieve->enqueue( encoded( d->ok ) );
}
d->sieve->enqueue( "\r\n" );
}
else {
d->sieve->enqueue( "NO" );
if ( !d->no.isEmpty() ) {
d->sieve->enqueue( " " );
d->sieve->enqueue( encoded( d->no ) );
}
d->sieve->enqueue( "\r\n" );
};
d->sieve->runCommands();
}
void Mechanoid::enterBuilding(detail::MapBuilding *bld)
{
if (!bld)
return;
auto mmb = bld->getModificationMapBuilding();
if (!mmb)
return;
building = mmb;
if (!isPlayer())
{
// handle bot's building visit
return;
}
// player is now officially in the building
// we need to run scripts, setup texts etc.
auto e = getEngine();
// set building, mechanoid
auto bm = e->getBuildingMenu();
bm->setCurrentBuilding(mmb);
bm->setCurrentMechanoid(this);
bm->clearText();
// now run scripts
auto se = mmb->map->modification->getScriptEngine();
path script_file = path("maps") / mmb->map->script_dir.toString() / mmb->script_name.toString();
auto s = se->getScript(script_file.string());
// set player visit
auto iter = player->buildings.find_if([mmb](const auto &vb)
{
return vb->building.get() == mmb;
});
if (iter == player->buildings.end())
{
auto vb = e->getStorage()->modificationPlayerBuildings.createAtEnd();
vb->player = player;
vb->building = mmb;
vb->know_location = true;
vb->visited = true;
player->buildings.insert(vb);
}
else
{
(*iter)->know_location = true;
(*iter)->visited = true;
}
// set script data
s->data.script = s;
s->data.player = player;
s->data.building = mmb;
// set script for possible callbacks from building menu
bm->setCurrentScriptCallback([s](const auto &fn, const auto ¶ms) mutable { s->call(fn, params); });
// register available building quests
s->RegisterQuests();
// main script call
s->OnEnterBuilding();
// update building menu
bm->refresh();
e->ShowBuildingMenu();
// workaround
{
static Executor e;
getExecutor(&e);
}
// do async save to not freeze the game
// the ideal algorithm here is:
// 1. freeze the game
// 2. async({ save(); unfreeze(); });
getExecutor().push([e]()
{
e->saveAuto();
});
}
bool ScriptContainer::runScript(Script script, Aurora::NWScript::Object *owner,
Aurora::NWScript::Object *triggerer) {
return runScript(getScript(script), owner, triggerer);
}
bool ScriptContainer::hasScript(Script script) const {
return !getScript(script).empty();
}
//-------------------------------------------------------------------------------------
bool PythonApp::installPyModules()
{
// 安装入口模块
PyObject *entryScriptFileName = NULL;
if(componentType() == BASEAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getBaseApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if(componentType() == CELLAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getCellApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if(componentType() == INTERFACES_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getInterfaces();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if (componentType() == LOGINAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getLoginApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if (componentType() == DBMGR_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getDBMgr();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if (componentType() == LOGGER_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getLogger();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else
{
ERROR_MSG("PythonApp::installPyModules: Unsupported script!\n");
}
PyObject * module = getScript().getModule();
APPEND_SCRIPT_MODULE_METHOD(module, MemoryStream, script::PyMemoryStream::py_new, METH_VARARGS, 0);
// 注册创建entity的方法到py
// 向脚本注册app发布状态
APPEND_SCRIPT_MODULE_METHOD(module, publish, __py_getAppPublish, METH_VARARGS, 0);
// 注册设置脚本输出类型
APPEND_SCRIPT_MODULE_METHOD(module, scriptLogType, __py_setScriptLogType, METH_VARARGS, 0);
// 获得资源全路径
APPEND_SCRIPT_MODULE_METHOD(module, getResFullPath, __py_getResFullPath, METH_VARARGS, 0);
// 是否存在某个资源
APPEND_SCRIPT_MODULE_METHOD(module, hasRes, __py_hasRes, METH_VARARGS, 0);
// 打开一个文件
APPEND_SCRIPT_MODULE_METHOD(module, open, __py_kbeOpen, METH_VARARGS, 0);
// 列出目录下所有文件
APPEND_SCRIPT_MODULE_METHOD(module, listPathRes, __py_listPathRes, METH_VARARGS, 0);
// 匹配相对路径获得全路径
APPEND_SCRIPT_MODULE_METHOD(module, matchPath, __py_matchPath, METH_VARARGS, 0);
// debug追踪kbe封装的py对象计数
APPEND_SCRIPT_MODULE_METHOD(module, debugTracing, script::PyGC::__py_debugTracing, METH_VARARGS, 0);
if (PyModule_AddIntConstant(module, "LOG_TYPE_NORMAL", log4cxx::ScriptLevel::SCRIPT_INT))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_NORMAL.\n");
}
if (PyModule_AddIntConstant(module, "LOG_TYPE_INFO", log4cxx::ScriptLevel::SCRIPT_INFO))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_INFO.\n");
}
if (PyModule_AddIntConstant(module, "LOG_TYPE_ERR", log4cxx::ScriptLevel::SCRIPT_ERR))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_ERR.\n");
}
if (PyModule_AddIntConstant(module, "LOG_TYPE_DBG", log4cxx::ScriptLevel::SCRIPT_DBG))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_DBG.\n");
}
if (PyModule_AddIntConstant(module, "LOG_TYPE_WAR", log4cxx::ScriptLevel::SCRIPT_WAR))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_WAR.\n");
}
if (PyModule_AddIntConstant(module, "NEXT_ONLY", KBE_NEXT_ONLY))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.NEXT_ONLY.\n");
}
// 注册所有pythonApp都要用到的通用接口
APPEND_SCRIPT_MODULE_METHOD(module, addTimer, __py_addTimer, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, delTimer, __py_delTimer, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, registerReadFileDescriptor, PyFileDescriptor::__py_registerReadFileDescriptor, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, registerWriteFileDescriptor, PyFileDescriptor::__py_registerWriteFileDescriptor, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, deregisterReadFileDescriptor, PyFileDescriptor::__py_deregisterReadFileDescriptor, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, deregisterWriteFileDescriptor, PyFileDescriptor::__py_deregisterWriteFileDescriptor, METH_VARARGS, 0);
onInstallPyModules();
if (entryScriptFileName != NULL)
{
entryScript_ = PyImport_Import(entryScriptFileName);
SCRIPT_ERROR_CHECK();
S_RELEASE(entryScriptFileName);
if(entryScript_.get() == NULL)
{
return false;
}
}
return true;
}
STDMETHODIMP ScriptThread::Configure(IObserver * observer, IMeterHome * meters, LONG hDlg)
{
getScript()->Configure(NULL, NULL, (long)hWnd);
return S_OK;
}
bool GadgetScript::usable( Noun * pTarget, bool shift ) const
{
if ( getScript() != NULL )
return true;
return false;
}
STDMETHODIMP ScriptThread::ShowConsole(VARIANT_BOOL show)
{
getScript()->ShowConsole(show);
return S_OK;
}
//-------------------------------------------------------------------------------------
bool PythonApp::installPyScript()
{
if(Resmgr::getSingleton().respaths().size() <= 0 ||
Resmgr::getSingleton().getPyUserResPath().size() == 0 ||
Resmgr::getSingleton().getPySysResPath().size() == 0 ||
Resmgr::getSingleton().getPyUserScriptsPath().size() == 0)
{
KBE_ASSERT(false && "PythonApp::installPyScript: KBE_RES_PATH error!\n");
return false;
}
std::wstring user_scripts_path = L"";
wchar_t* tbuf = KBEngine::strutil::char2wchar(const_cast<char*>(Resmgr::getSingleton().getPyUserScriptsPath().c_str()));
if(tbuf != NULL)
{
user_scripts_path += tbuf;
free(tbuf);
}
else
{
KBE_ASSERT(false && "PythonApp::installPyScript: KBE_RES_PATH error[char2wchar]!\n");
return false;
}
std::wstring pyPaths = user_scripts_path + L"common;";
pyPaths += user_scripts_path + L"data;";
pyPaths += user_scripts_path + L"user_type;";
switch(componentType_)
{
case BASEAPP_TYPE:
pyPaths += user_scripts_path + L"server_common;";
pyPaths += user_scripts_path + L"base;";
break;
case CELLAPP_TYPE:
pyPaths += user_scripts_path + L"server_common;";
pyPaths += user_scripts_path + L"cell;";
break;
case DBMGR_TYPE:
pyPaths += user_scripts_path + L"server_common;";
pyPaths += user_scripts_path + L"db;";
break;
case INTERFACES_TYPE:
pyPaths += user_scripts_path + L"server_common;";
pyPaths += user_scripts_path + L"interface;";
break;
case LOGINAPP_TYPE:
pyPaths += user_scripts_path + L"server_common;";
pyPaths += user_scripts_path + L"login;";
break;
case LOGGER_TYPE:
pyPaths += user_scripts_path + L"server_common;";
pyPaths += user_scripts_path + L"logger;";
break;
default:
pyPaths += user_scripts_path + L"client;";
break;
};
std::string kbe_res_path = Resmgr::getSingleton().getPySysResPath();
kbe_res_path += "scripts/common";
tbuf = KBEngine::strutil::char2wchar(const_cast<char*>(kbe_res_path.c_str()));
bool ret = getScript().install(tbuf, pyPaths, "KBEngine", componentType_);
free(tbuf);
if (ret)
script::PyMemoryStream::installScript(NULL);
return ret;
}