void EmberEntity::onLocationChanged(Eris::Entity *oldLocation)
{
//Get the new location. We use getEmberLocation() since we always know that all entities are of type EmberEntity.
EmberEntity* newLocationEntity = getEmberLocation();
if (newLocationEntity && newLocationEntity->getAttachment()) {
try {
IEntityAttachment* newAttachment = newLocationEntity->getAttachment()->attachEntity(*this);
setAttachment(newAttachment);
if (newAttachment) {
newAttachment->updateScale();
}
} catch (const std::exception& ex) {
S_LOG_WARNING("Problem when creating new attachment for entity." << ex);
}
} else {
try {
setAttachment(0);
} catch (const std::exception& ex) {
S_LOG_WARNING("Problem when setting attachment for entity." << ex);
}
}
Eris::Entity::onLocationChanged(oldLocation);
}
bool GUICEGUIAdapter::injectMouseButtonDown(const Input::MouseButton& button)
{
CEGUI::MouseButton ceguiButton(CEGUI::LeftButton);
if (button == Input::MouseButtonLeft) {
ceguiButton = CEGUI::LeftButton;
} else if(button == Input::MouseButtonRight) {
ceguiButton = CEGUI::RightButton;
} else if(button == Input::MouseButtonMiddle) {
ceguiButton = CEGUI::MiddleButton;
} else if(button == Input::MouseWheelDown) {
try {
mGuiContext.injectMouseWheelChange(-1.0);
} catch (const CEGUI::Exception& ex) {
S_LOG_WARNING("Error in CEGUI." << ex);
}
return false;
} else if(button == Input::MouseWheelUp) {
try {
mGuiContext.injectMouseWheelChange(1.0);
} catch (const CEGUI::Exception& ex) {
S_LOG_WARNING("Error in CEGUI." << ex);
}
return false;
} else {
return true;
}
try {
mGuiContext.injectMouseButtonDown(ceguiButton);
return false;
} catch (const CEGUI::Exception& ex) {
S_LOG_WARNING("Error in CEGUI." << ex);
}
return true;
}
void ConnectedAdapter::wield(Eris::Entity* entity, const std::string& outfitSlot)
{
try {
if (entity->getLocation() != mAvatar.getEntity()) {
S_LOG_WARNING("Can't wield an Entity which is not located in the avatar.");
return;
}
Atlas::Objects::Entity::Anonymous arguments;
arguments->setId(entity->getId());
if (outfitSlot != "") {
arguments->setAttr("outfit", outfitSlot);
}
Atlas::Objects::Operation::Wield wield;
wield->setFrom(mAvatar.getEntity()->getId());
wield->setArgs1(arguments);
mConnection.send(wield);
} catch (const std::exception& ex) {
S_LOG_WARNING("Got error on wielding." << ex);
}
}
void EntityEditor::operationGetThoughtResult(const Atlas::Objects::Operation::RootOperation& op)
{
//What we receive here has been relayed from the mind of the entity. That means that this op
//is potentially unsafe, as it could be of any type (Set, Logout etc.), all depending on what the
//mind client decided to send (i.e. someone might want to try to hack). We should therefore treat it
//very carefully.
if (op->getClassNo() == Atlas::Objects::Operation::ROOT_OPERATION_NO) {
//An empty root operation signals a timeout; we never got any answer from the entity.
return;
}
//Since we'll just be iterating over the args we only need to do an extra check that what we got is a
//"think" operation.
if (op->getParents().empty()) {
S_LOG_WARNING("Got think operation without any parent set.");
return;
}
if (op->getParents().front() != "think") {
S_LOG_WARNING("Got think operation with wrong type set.");
return;
}
if (!op->getArgs().empty()) {
auto thoughts = op->getArgsAsList();
for (auto thought : thoughts) {
EventGotThought(thought);
}
} else {
S_LOG_VERBOSE("Got thought op without any thoughts.");
}
}
bool LoggedInState::createCharacter(const std::string& name, const std::string& sex, const std::string& type, const std::string& description, const std::string& spawnName, const Atlas::Message::MapType& extraProperties)
{
ConsoleBackend::getSingleton().pushMessage("Creating char...", "important");
std::string msg;
msg = "Creating character of type '" + type + "' with name '" + name + "' and sex '" + sex + "'.";
ConsoleBackend::getSingleton().pushMessage(msg, "info");
S_LOG_INFO("Creating character.");
Atlas::Objects::Entity::RootEntity character;
for (auto& property : extraProperties) {
character->setAttr(property.first, property.second);
}
character->setParentsAsList(Atlas::Message::ListType(1, type));
character->setName(name);
character->setAttr("sex", sex);
character->setAttr("description", description);
if (spawnName != "") {
character->setAttr("spawn_name", spawnName);
}
try {
mAccount.createCharacter(character);
} catch (const std::exception& except) {
S_LOG_WARNING("Got Eris error on character creation." << except);
return false;
} catch (...) {
S_LOG_WARNING("Got unknown error on character creation.");
return false;
}
S_LOG_INFO("Done creating character.");
return true;
}
Ogre::Root* OgreSetup::createOgreSystem() {
ConfigService& configSrv(EmberServices::getSingleton().getConfigService());
if (!configSrv.getPrefix().empty()) {
//We need to set the current directory to the prefix before trying to load Ogre.
//The reason for this is that Ogre loads a lot of dynamic modules, and in some build configuration
//(like AppImage) the lookup path for some of these are based on the installation directory of Ember.
if (chdir(configSrv.getPrefix().c_str())) {
S_LOG_WARNING("Failed to change to the prefix directory '" << configSrv.getPrefix() << "'. Ogre loading might fail.");
}
}
std::string pluginExtension = ".so";
mRoot = new Ogre::Root("", configSrv.getHomeDirectory(BaseDirType_CONFIG) + "/ogre.cfg", "");
//Ownership of the queue instance is passed to Root.
mRoot->setWorkQueue(OGRE_NEW EmberWorkQueue(MainLoopController::getSingleton().getEventService()));
mOverlaySystem = new Ogre::OverlaySystem();
mPluginLoader.loadPlugin("Plugin_ParticleFX");
mPluginLoader.loadPlugin("RenderSystem_GL"); //We'll use OpenGL on Windows too, to make it easier to develop
if (chdir(configSrv.getEmberDataDirectory().c_str())) {
S_LOG_WARNING("Failed to change to the data directory '" << configSrv.getEmberDataDirectory() << "'.");
}
return mRoot;
}
bool GUIManager::frameStarted(const Ogre::FrameEvent& evt)
{
try {
CEGUI::System::getSingleton().injectTimePulse(evt.timeSinceLastFrame);
CEGUI::System::getSingleton().getDefaultGUIContext().injectTimePulse(evt.timeSinceLastFrame);
} catch (const CEGUI::Exception& ex) {
S_LOG_WARNING("Error in CEGUI." << ex);
}
//iterate over all widgets and send them a frameStarted event
WidgetStore::iterator I = mWidgets.begin();
WidgetStore::iterator I_end = mWidgets.end();
for (; I != I_end; ++I) {
Widget* aWidget = *I;
try {
aWidget->frameStarted(evt);
} catch (const CEGUI::Exception& ex) {
S_LOG_WARNING("Error in CEGUI." << ex);
}
}
EventFrameStarted.emit(evt.timeSinceLastFrame);
return true;
}
void EmberEntity::updateAttachment()
{
//Get the new location. We use getEmberLocation() since we always know that all entities are of type EmberEntity.
EmberEntity* newLocationEntity = getEmberLocation();
if (newLocationEntity && newLocationEntity->getAttachment()) {
try {
IEntityAttachment* newAttachment = newLocationEntity->getAttachment()->attachEntity(*this);
setAttachment(newAttachment);
if (newAttachment) {
newAttachment->updateScale();
}
} catch (const std::exception& ex) {
S_LOG_WARNING("Problem when creating new attachment for entity." << ex);
}
//If we're the top level entity the attachment has been set from the outside and shouldn't be changed.
//FIXME This is a little hackish; how can we improve it to not require special cases?
} else if (m_view->getTopLevel() == this) {
return;
} else {
try {
setAttachment(nullptr);
} catch (const std::exception& ex) {
S_LOG_WARNING("Problem when setting attachment for entity." << ex);
}
}
}
void AuthoringHandler::createVisualizationForEntity(EmberEntity* entity)
{
VisualizationStore::iterator I = mVisualizations.find(entity);
if (I == mVisualizations.end()) {
entity->BeingDeleted.connect(sigc::bind(sigc::mem_fun(*this, &AuthoringHandler::view_EntityDeleted), entity));
entity->LocationChanged.connect(sigc::bind(sigc::mem_fun(*this, &AuthoringHandler::view_EntityLocationChanged), entity));
AuthoringVisualization* parentVis(0);
Ogre::SceneNode* parentNode(0);
if (entity->getLocation()) {
VisualizationStore::iterator parentVisIterator = mVisualizations.find(static_cast<EmberEntity*> (entity->getLocation()));
if (parentVisIterator != mVisualizations.end()) {
parentVis = parentVisIterator->second;
parentNode = parentVis->getSceneNode();
} else {
S_LOG_WARNING("Could not find parent visualization for entity.");
parentNode = mWorld.getScene().getSceneManager().getRootSceneNode();
}
} else {
parentNode = mWorld.getScene().getSceneManager().getRootSceneNode();
}
Ogre::SceneNode* sceneNode = parentNode->createChildSceneNode();
AuthoringVisualization* visualization = new AuthoringVisualization(*entity, sceneNode);
mVisualizations.insert(VisualizationStore::value_type(entity, visualization));
} else {
S_LOG_WARNING("Got create signal for entity which already has an authoring visualization. This should not happen.");
}
}
void ConnectedState::disconnect()
{
try {
mConnection.disconnect();
} catch (const std::exception& e) {
S_LOG_WARNING("Got error on disconnect." << e);
} catch (...) {
S_LOG_WARNING("Got unknown error on disconnect");
}
}
void WebEmberManager::sendMessage(const std::string& msg)
{
try {
boost::interprocess::message_queue mq(boost::interprocess::open_only, "WEBEMBER_PLUGIN");
mq.send(msg.c_str(), msg.size() + 1, 0);
} catch (const std::exception& ex) {
S_LOG_WARNING("Failed to send a message to the plugin. " << ex);
} catch (...) {
S_LOG_WARNING("Failed to send a message to the plugin.");
}
}
void AtlasMessageLoader::objectArrived(const Root & obj)
{
if (obj->isDefaultId()) {
S_LOG_WARNING("Object without ID read from file.");
return;
}
const std::string & id = obj->getId();
if (mMessages.find(id) != mMessages.end()) {
S_LOG_WARNING("Duplicate object ID '"<< id << "' loaded.");
}
mMessages[id] = obj;
++mCount;
}
void
AccountAvailableState::runCommand(const std::string &command,
const std::string &args)
{
if (CreateAcc == command)
{
Tokeniser tokeniser = Tokeniser();
tokeniser.initTokens(args);
std::string uname = tokeniser.nextToken();
std::string password = tokeniser.nextToken();
std::string realname = tokeniser.remainingTokens();
std::string msg;
msg = "Creating account: Name: [" + uname + "], Password: [" + password
+ "], Real Name: [" + realname + "]";
try
{
mAccount.createAccount(uname, realname, password);
}
catch (const std::exception& except)
{
S_LOG_WARNING("Got error on account creation." << except);
return;
}
catch (...)
{
S_LOG_WARNING("Got unknown error on account creation.");
return;
}
}
else if (Login == command)
{
// Split string into userid / password pair
Tokeniser tokeniser = Tokeniser();
tokeniser.initTokens(args);
std::string userid = tokeniser.nextToken();
std::string password = tokeniser.remainingTokens();
mAccount.login(userid, password);
std::string msg;
msg = "Login: [" + userid + "," + password + "]";
ConsoleBackend::getSingleton().pushMessage(msg, "info");
}
}
void ActiveWidgetHandler::Input_InputModeChanged(Input::InputMode mode)
{
if (mode != Input::IM_GUI && mLastMode == Input::IM_GUI) {
//save the current active widget
CEGUI::Window* window = mGuiManager.getMainSheet()->getActiveChild();
if (window) {
mLastActiveWindow = window;
mLastActiveWindowDestructionStartedConnection = window->subscribeEvent(CEGUI::Window::EventDestructionStarted, CEGUI::Event::Subscriber(&ActiveWidgetHandler::lastActiveWindowDestructionStarted, this));
window->deactivate();
//deactivate all parents
while ((window = window->getParent())) {
window->deactivate();
}
} else {
mLastActiveWindow = nullptr;
}
mLastMode = mode;
} else if (mode == Input::IM_GUI) {
if (mLastActiveWindow) {
//restore the previously active widget
try {
mLastActiveWindow->activate();
} catch (...)
{
S_LOG_WARNING("Error when trying to restore previously captured window.");
}
mLastActiveWindow = 0;
mLastActiveWindowDestructionStartedConnection->disconnect();
}
mLastMode = mode;
}
}
TexturePair AssetsManager::showTexture(const std::string textureName)
{
// if (!mOgreCEGUITexture) {
// S_LOG_WARNING("You must first create a valid OgreCEGUITexture instance.");
// return;
// }
if (Ogre::TextureManager::getSingleton().resourceExists(textureName)) {
Ogre::TexturePtr texturePtr = static_cast<Ogre::TexturePtr>(Ogre::TextureManager::getSingleton().getByName(textureName));
if (!texturePtr.isNull()) {
if (!texturePtr->isLoaded()) {
try {
texturePtr->load();
} catch (...) {
S_LOG_WARNING("Error when loading " << textureName << ". This texture will not be shown.");
return TexturePair();
}
}
std::string textureName(texturePtr->getName());
std::string imageSetName(textureName + "_AssetsManager");
return createTextureImage(texturePtr, imageSetName);
// mOgreCEGUITexture->setOgreTexture(texturePtr);
}
}
return TexturePair();
}
void SimpleRenderContext::createImage(const std::string& prefix)
{
if (mWidth == 0 || mHeight == 0) {
throw Exception("Height and width of the image can't be 0.");
}
Ogre::Real aspectRatio = static_cast<float>(mWidth) / static_cast<float>(mHeight);
S_LOG_VERBOSE("Setting aspect ratio of camera to " << aspectRatio);
mCamera->setAspectRatio(aspectRatio);
//the width and height needs to be multipes of 2
mWidth = Ogre::Bitwise::firstPO2From(mWidth);
mHeight = Ogre::Bitwise::firstPO2From(mHeight);
//first, create a RenderTexture to which the Ogre renderer should render the image
S_LOG_VERBOSE("Creating new rendertexture " << (prefix + "_SimpleRenderContextRenderTexture") << " with w:" << mWidth << " h:" << mHeight);
Ogre::TexturePtr texture = Ogre::TextureManager::getSingleton().createManual(prefix + "_SimpleRenderContextRenderTexture", "Gui", Ogre::TEX_TYPE_2D, mWidth, mHeight, 0, Ogre::PF_A8R8G8B8, Ogre::TU_RENDERTARGET, &mResourceLoader);
if (texture.isNull()) {
S_LOG_WARNING("Could not create a texture.");
return;
}
setTexture(texture);
}
void XMLModelDefinitionSerializer::readActivations(TiXmlElement* activationsNode, ActionDefinition* action)
{
const char* tmp = 0;
for (TiXmlElement* activationElem = activationsNode->FirstChildElement();
activationElem != 0; activationElem = activationElem->NextSiblingElement())
{
tmp = activationElem->Attribute("type");
if (tmp)
{
std::string typeString(tmp);
ActivationDefinition::Type type;
if (typeString == "movement") {
type = ActivationDefinition::MOVEMENT;
} else if (typeString == "action") {
type = ActivationDefinition::ACTION;
} else if (typeString == "task") {
type = ActivationDefinition::TASK;
} else {
S_LOG_WARNING("No recognized activation type: " << typeString);
continue;
}
std::string trigger = activationElem->GetText();
action->createActivationDefinition(type, trigger);
S_LOG_VERBOSE( " Add activation: " << typeString << " : " << trigger);
}
}
}
void ConnectedAdapter::actuate(Eris::Entity* entity, const std::string& action)
{
try {
Atlas::Objects::Entity::Anonymous what;
what->setId(entity->getId());
// what->setObjtype("obj");
Atlas::Objects::Operation::RootOperation actionOp;
actionOp->setObjtype("op");
actionOp->setArgs1(what);
std::list<std::string> actionParents;
actionParents.push_back(action);
actionOp->setParents(actionParents);
Atlas::Objects::Operation::RootOperation actuateOp;
actuateOp->setObjtype("op");
actuateOp->setArgs1(actionOp);
std::list<std::string> actuateParents;
actuateParents.push_back("actuate");
actuateOp->setParents(actuateParents);
actuateOp->setFrom(mAvatar.getEntity()->getId());
S_LOG_INFO("Actuating entity with id " << entity->getId() << ", named " << entity->getName() << " with action '" << action << "'.");
mConnection.send(actuateOp);
} catch (const std::exception& ex) {
S_LOG_WARNING("Got error on actuating." << ex);
}
}
void TerrainModChangeTask::executeTaskInBackgroundThread(Tasks::TaskExecutionContext& context)
{
TerrainModMap::iterator I = mTerrainMods.find(mEntityId);
if (I != mTerrainMods.end()) {
Eris::TerrainModTranslator* terrainMod = I->second;
Mercator::TerrainMod* oldMercTerrainMod = terrainMod->getModifier();
if (mModData.isMap()) {
Atlas::Message::MapType mapData = mModData.asMap();
bool success = terrainMod->parseData(mPosition, mOrientation, mapData);
if (success && terrainMod->getModifier()) {
Mercator::Terrain::Rect oldRect = mTerrain.updateMod(terrainMod->getModifier());
if (oldRect.isValid()) {
mUpdatedAreas.push_back(oldRect);
}
if (terrainMod->getModifier()->bbox() != oldRect) {
mUpdatedAreas.push_back(terrainMod->getModifier()->bbox());
}
} else {
mTerrain.removeMod(oldMercTerrainMod);
}
} else {
mTerrain.removeMod(oldMercTerrainMod);
}
} else {
S_LOG_WARNING("Got a change signal for a terrain mod which isn't registered with the terrain handler. This shouldn't happen.");
}
}
EntityIcon* EntityIconManager::createIcon(Gui::Icons::Icon* icon, EmberEntity* entity, unsigned int pixelSize)
{
if (!icon) {
S_LOG_WARNING("Trying to create an EntityIcon with an invalid Icon.");
return 0;
}
std::stringstream ss;
ss << "entityIcon" << mIconsCounter++;
CEGUI::DragContainer* item = static_cast<CEGUI::DragContainer*>(mGuiManager.createWindow("DragContainer", ss.str()));
if (item) {
item->setSize(CEGUI::USize(CEGUI::UDim(0, pixelSize), CEGUI::UDim(0, pixelSize)));
//item->setTooltipText(name);
ss << "Image" ;
CEGUI::Window* iconWindow = mGuiManager.createWindow("EmberLook/StaticImage", ss.str());
if (iconWindow) {
iconWindow->setProperty("BackgroundEnabled", "false");
iconWindow->setProperty("FrameEnabled", "false");
iconWindow->setProperty("InheritsAlpha", "true");
iconWindow->disable();
// iconWindow->setProperty("FrameEnabled", "false");
iconWindow->setProperty("Image", CEGUI::PropertyHelper<CEGUI::Image*>::toString(icon->getImage()));
item->addChild(iconWindow);
EntityIcon* entityIcon = new EntityIcon(*this, item, iconWindow, icon, entity);
mIcons.push_back(entityIcon);
return entityIcon;
}
}
return 0;
}
bool Simple::compileMaterial(Ogre::MaterialPtr material, std::set<std::string>& managedTextures) const
{
material->removeAllTechniques();
Ogre::Technique* technique = material->createTechnique();
if (!mTerrainPageSurfaces.empty()) {
//First add a base pass
auto surfaceLayer = mTerrainPageSurfaces.begin()->second;
Ogre::Pass* pass = technique->createPass();
pass->setLightingEnabled(false);
Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState();
textureUnitState->setTextureScale(1.0f / surfaceLayer->getScale(), 1.0f / surfaceLayer->getScale());
textureUnitState->setTextureName(surfaceLayer->getDiffuseTextureName());
textureUnitState->setTextureCoordSet(0);
for (auto& layer : mLayers) {
addPassToTechnique(*mGeometry, technique, layer, managedTextures);
}
}
if (mTerrainPageShadow) {
addShadow(technique, mTerrainPageShadow, material, managedTextures);
}
// addLightingPass(technique, managedTextures);
material->load();
if (material->getNumSupportedTechniques() == 0) {
S_LOG_WARNING("The material '" << material->getName() << "' has no supported techniques. The reason for this is: \n" << material->getUnsupportedTechniquesExplanation());
return false;
}
return true;
}
void ConnectedAdapter::setAttributes(Eris::Entity* entity, Atlas::Message::MapType& elements)
{
try {
Atlas::Objects::Entity::Anonymous what;
what->setId(entity->getId());
//We'll use this flag to make sure that nothing gets sent in the case that the only thing changed was immutable attributes (like "pos").
bool areAttributesToSend = false;
for (Atlas::Message::MapType::iterator I = elements.begin(); I != elements.end(); ++I) {
//The "pos" attribute is immutable and cannot be altered by a "set" op. Instead we must use a "move" op.
if (I->first == "pos") {
place(entity, entity->getLocation(), WFMath::Point<3>(I->second));
} else {
what->setAttr(I->first, I->second);
areAttributesToSend = true;
}
}
if (areAttributesToSend) {
Atlas::Objects::Operation::Set setOp;
setOp->setFrom(mAvatar.getEntity()->getId());
//setOp->setTo(entity->getId());
setOp->setArgs1(what);
S_LOG_INFO("Setting attributes of entity with id " << entity->getId() << ", named " << entity->getName());
mConnection.send(setOp);
}
} catch (const std::exception& ex) {
S_LOG_WARNING("Got error on setting attributes on entity." << ex);
}
}
/* Interface method for stopping this service */
void SoundService::stop()
{
for (SoundInstanceStore::iterator I = mInstances.begin(); I != mInstances.end(); ++I) {
S_LOG_WARNING("Found a still registered SoundInstance when shutting down sound service. This shouldn't normally happen, since all instances should be handled by their proper owners and removed well in advance of the SoundService shutting down. We'll now delete the instance, which might lead to a segfault or similar problem as the instance owner might still expect it to be existing.");
delete *I;
}
mInstances.clear();
for (SoundSampleStore::iterator I = mBaseSamples.begin(); I != mBaseSamples.end(); ++I) {
delete I->second;
}
mBaseSamples.clear();
if (isEnabled()) {
#ifndef __WIN32__
alutExit();
#else
alcMakeContextCurrent(nullptr);
alcDestroyContext(mContext);
alcCloseDevice(mDevice);
mDevice = 0;
mContext = 0;
#endif
}
mEnabled = false;
Service::stop();
}
bool Simple::compileMaterial(Ogre::MaterialPtr material)
{
material->removeAllTechniques();
Ogre::Technique* technique = material->createTechnique();
for (SurfaceLayerStore::const_iterator I = mTerrainPageSurfaces.begin(); I != mTerrainPageSurfaces.end(); ++I) {
const TerrainPageSurfaceLayer* surfaceLayer = I->second;
if (I == mTerrainPageSurfaces.begin()) {
Ogre::Pass* pass = technique->createPass();
pass->setLightingEnabled(false);
//add the first layer of the terrain, no alpha or anything
Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState();
textureUnitState->setTextureScale(1.0f / surfaceLayer->getScale(), 1.0f / surfaceLayer->getScale());
textureUnitState->setTextureName(surfaceLayer->getDiffuseTextureName());
textureUnitState->setTextureCoordSet(0);
} else {
if (surfaceLayer->intersects(*mGeometry)) {
addPassToTechnique(*mGeometry, technique, surfaceLayer);
}
}
}
if (mTerrainPageShadow) {
addShadow(technique, mTerrainPageShadow, material);
}
material->load();
if (material->getNumSupportedTechniques() == 0) {
S_LOG_WARNING("The material '" << material->getName() << "' has no supported techniques. The reason for this is: \n" << material->getUnsupportedTechniquesExplanation());
return false;
}
return true;
}
Connector* Connector::connect(lua_Object luaMethod, lua_Object selfIndex)
{
if (!mConnector) {
S_LOG_WARNING("Tried to connect lua method to a non existent signal.");
} else {
setSelf(selfIndex);
//we need to get the correct lua function
int luaType = lua_type(getState(), -1);
if (luaType == LUA_TFUNCTION) {
int index = luaL_ref(getState(), LUA_REGISTRYINDEX);
mConnector->connect(index);
} else {
S_LOG_WARNING("No valid lua function sent as argument to Connector::connect");
}
}
return this;
}
void ConnectedAdapter::attack(Eris::Entity* entity)
{
try {
mAvatar.attack(entity);
} catch (const std::exception& ex) {
S_LOG_WARNING("Got error on attack." << ex);
}
}
void ConnectedAdapter::emote(const std::string& emote)
{
try {
mAvatar.emote(emote);
} catch (const std::exception& ex) {
S_LOG_WARNING("Got error on emoting." << ex);
}
}
void ConnectedAdapter::touch(Eris::Entity* entity)
{
try {
mAvatar.touch(entity);
} catch (const std::exception& ex) {
S_LOG_WARNING("Got error on touching." << ex);
}
}
void ConnectedAdapter::moveInDirection(const WFMath::Vector<3>& velocity)
{
try {
mAvatar.moveInDirection(velocity);
} catch (const std::exception& ex) {
S_LOG_WARNING("Got error on moving." << ex);
}
}
void ConnectedAdapter::moveToPoint(const WFMath::Point<3>& dest)
{
try {
mAvatar.moveToPoint(dest);
} catch (const std::exception& ex) {
S_LOG_WARNING( "Got error on moving." << ex);
}
}
