void World::DeleteOperation(const Operation & op, OpVector & res)
{
//A delete operation with an argument sent to the world indicates that an
//entity should be deleted forcefully (whereas a Delete operation sent to
//an entity directly, which is the norm, always can be overridden by the entity).
auto& args = op->getArgs();
if (!args.empty()) {
auto arg = args.front();
if (!arg->isDefaultId()) {
auto entity = BaseWorld::instance().getEntity(arg->getId());
if (entity) {
if (entity == this) {
Atlas::Message::Element force;
if (arg->copyAttr("force", force) == 0 && force.isInt() && force.asInt() == 1) {
clearWorld(res);
} else {
log(ERROR, "World::DeleteOperation cannot delete world unless 'force' flag is set.");
}
} else {
BaseWorld::instance().delEntity(entity.get());
}
} else {
log(NOTICE, String::compose("Tried to delete non existent entity with id %1", arg->getId()));
}
} else {
log(ERROR, "World::DeleteOperation got delete op with arg but no id.");
}
} else {
assert(m_location.m_parent == nullptr);
// Deleting has no effect.
}
}
void OutfitMatch::testAttribute(const Atlas::Message::Element& attribute, bool triggerEvaluation)
{
if (attribute.isMap()) {
Eris::Entity* entity(nullptr);
const auto& tmap = attribute.asMap();
auto I = tmap.find(mOutfitName);
std::string entityId;
if (I != tmap.end() && Eris::Entity::extractEntityId(I->second, entityId)) {
entity = mView->getEntity(entityId);
//the entity might not be available yet, so we need to create an observer for it
if (!entity) {
if (mEntityObserver.get()) {
mEntityObserver->observeCreation(mView, entityId);
}
} else {
testEntity(entity);
}
} else {
testEntity(entity);
}
}
if (triggerEvaluation) {
evaluateChanges();
}
}
void ProvidersTest::test_OutfitProviders()
{
Atlas::Message::Element value;
//Check if we get the right entity in outfit query
auto provider = CreateProvider( { "entity", "outfit", "hands" });
provider->value(value, QueryContext { *m_ch1 });
assert(value.Ptr() == m_glovesEntity);
//Check for outfit's property query
provider = CreateProvider( { "entity", "outfit", "hands", "color" });
provider->value(value, QueryContext { *m_ch1 });
assert(value.String() == "brown");
//Check if we get the right entity in nested outfit query
provider = CreateProvider(
{ "entity", "outfit", "hands", "outfit", "thumb" });
provider->value(value, QueryContext { *m_ch1 });
assert(value.Ptr() == m_cloth);
//Check for nested outfit's property
provider = CreateProvider( { "entity", "outfit", "hands", "outfit", "thumb",
"color" });
provider->value(value, QueryContext { *m_ch1 });
assert(value.String() == "green");
}
void TasksProperty::set(const Atlas::Message::Element & val)
{
if (!val.isList())
{
log(ERROR, "Task property must be a list.");
return;
}
if (m_task == 0) {
log(ERROR, "No task in ::set");
return;
}
ListType tasks = val.asList();
ListType::const_iterator I = tasks.begin();
ListType::const_iterator Iend = tasks.end();
for (; I != Iend; ++I) {
if (!I->isMap()) {
log(ERROR, "Task must be a map.");
return;
}
const MapType & task = I->asMap();
MapType::const_iterator J = task.begin();
MapType::const_iterator Jend = task.end();
for (J = task.begin(); J != Jend; ++J) {
m_task->setAttr(J->first, J->second);
}
}
}
void Tasktest::test_sequence()
{
m_task->nextTick(1.5);
Atlas::Message::Element val;
m_task->getAttr("foo", val);
assert(val.isNone());
m_task->setAttr("foo", 1);
m_task->getAttr("foo", val);
assert(val.isInt());
assert(!m_task->obsolete());
OpVector res;
assert(res.empty());
Atlas::Objects::Operation::Generic c;
c->setParents(std::list<std::string>(1, "generic"));
m_task->initTask(c, res);
Operation op;
m_task->operation(op, res);
m_task->irrelevant();
assert(m_task->obsolete());
}
void EntityEditor::submitChanges()
{
if (mRootAdapter->hasChanges()) {
Atlas::Message::Element rootElement = mRootAdapter->getSelectedChangedElements();
if (rootElement.isMap()) {
std::map<std::string, ::Atlas::Message::Element> attributes(rootElement.asMap());
if (attributes.size()) {
std::stringstream ss;
Atlas::Message::QueuedDecoder decoder;
Atlas::Codecs::XML codec(ss, decoder);
Atlas::Formatter formatter(ss, codec);
Atlas::Message::Encoder encoder(formatter);
formatter.streamBegin();
encoder.streamMessageElement(attributes);
formatter.streamEnd();
S_LOG_VERBOSE("Sending attribute update to server:\n" << ss.str());
EmberServices::getSingleton().getServerService().setAttributes(&mEntity, attributes);
}
}
}
}
void TerrainModAdapter::updateGui(const ::Atlas::Message::Element& element)
{
mPositioningsBinder.sync();
mTerrainModsBinder.sync();
if (element.isMap()) {
const ::Atlas::Message::MapType& mapElement = element.asMap();
::Atlas::Message::MapType::const_iterator I = mapElement.find("height");
float height = 0;
if (I != mapElement.end()) {
mPositioningsBinder.select("height");
if (I->second.isNum()) {
height = I->second.asNum();
}
} else {
I = mapElement.find("heightoffset");
if (I != mapElement.end()) {
mPositioningsBinder.select("heightoffset");
if (I->second.isNum()) {
height = I->second.asNum();
}
}
}
std::stringstream ss;
ss << height;
mHeightTextbox->setText(ss.str());
I = mapElement.find("type");
if (I != mapElement.end() && I->second.isString()) {
mTerrainModsBinder.select(I->second.asString());
}
}
}
TerrainModAdapter::TerrainModAdapter(const ::Atlas::Message::Element& element, CEGUI::PushButton* showButton, EmberEntity* entity, CEGUI::Combobox* posTypeCombobox, CEGUI::Combobox* modTypeCombobox, CEGUI::Editbox* heightTextbox)
: AdapterBase(element), mEntity(entity), mPolygonAdapter(0), mHeightTextbox(heightTextbox), mTerrainModsBinder(modTypeCombobox), mPositioningsBinder(posTypeCombobox)
{
if (element.isMap()) {
const ::Atlas::Message::MapType& areaData(element.asMap());
::Atlas::Message::MapType::const_iterator I = areaData.find("shape");
if (I != areaData.end()) {
mPolygonAdapter = std::auto_ptr<PolygonAdapter>(new PolygonAdapter(I->second, showButton, entity));
} else {
mPolygonAdapter = std::auto_ptr<PolygonAdapter>(new PolygonAdapter(::Atlas::Message::Element(), showButton, entity));
}
} else {
mPolygonAdapter = std::auto_ptr<PolygonAdapter>(new PolygonAdapter(::Atlas::Message::Element(), showButton, entity));
}
if (heightTextbox) {
addGuiEventConnection(heightTextbox->subscribeEvent(CEGUI::Window::EventTextChanged, CEGUI::Event::Subscriber(&TerrainModAdapter::heightTextbox_TextChanged, this)));
}
mTerrainModsBinder.addType("levelmod", "Level", LevelTerrainMod());
mTerrainModsBinder.addType("adjustmod", "Adjust", AdjustTerrainMod());
mPositioningsBinder.addType("height", "Fixed", FixedPositioning());
mPositioningsBinder.addType("heightoffset", "Relative", RelativePositioning());
updateGui(element);
}
bool NumericComparerWrapper::testAttribute(const Atlas::Message::Element& attribute)
{
if (attribute.isNum()) {
return mNumericComparer->test(attribute.asNum());
}
return false;
}
AreaAdapter::AreaAdapter(const ::Atlas::Message::Element& element, CEGUI::PushButton* showButton, CEGUI::Combobox* layerWindow, EmberEntity* entity) :
AdapterBase(element), mLayer(0), mLayerWindow(layerWindow), mEntity(entity), mPolygonAdapter(nullptr)
{
if (element.isMap()) {
const ::Atlas::Message::MapType& areaData(element.asMap());
::Atlas::Message::MapType::const_iterator shapeI = areaData.find("shape");
if (shapeI != areaData.end()) {
mPolygonAdapter = std::unique_ptr<PolygonAdapter>(new PolygonAdapter(shapeI->second, showButton, entity));
} else {
::Atlas::Message::MapType defaultShape;
mPolygonAdapter = std::unique_ptr<PolygonAdapter>(new PolygonAdapter(getDefaultPolygon().toAtlas(), showButton, entity));
}
WFMath::Polygon<2> poly;
Terrain::TerrainAreaParser parser;
parser.parseArea(areaData, poly, mLayer);
} else {
mPolygonAdapter = std::unique_ptr<PolygonAdapter>(new PolygonAdapter(getDefaultPolygon().toAtlas(), showButton, entity));
}
if (mLayerWindow) {
addGuiEventConnection(mLayerWindow->subscribeEvent(CEGUI::Combobox::EventListSelectionChanged, CEGUI::Event::Subscriber(&AreaAdapter::layerWindow_ListSelectionChanged, this)));
}
updateGui(mOriginalValue);
}
TerrainDefPointStore TerrainParser::parseTerrain(const Atlas::Message::Element& terrain, const WFMath::Point<3>& offset) const
{
//_fpreset();
if (!terrain.isMap()) {
S_LOG_FAILURE("Terrain is not a map");
}
const Atlas::Message::MapType & tmap = terrain.asMap();
Atlas::Message::MapType::const_iterator I = tmap.find("points");
if (I == tmap.end()) {
S_LOG_FAILURE("No terrain points");
}
Terrain::TerrainDefPointStore pointStore;
if (I->second.isList()) {
// Legacy support for old list format.
const Atlas::Message::ListType& plist = I->second.asList();
Atlas::Message::ListType::const_iterator J = plist.begin();
for (; J != plist.end(); ++J) {
if (!J->isList()) {
S_LOG_INFO("Non list in points");
continue;
}
const Atlas::Message::ListType & point = J->asList();
if (point.size() != 3) {
S_LOG_INFO("Point without 3 nums.");
continue;
}
Terrain::TerrainDefPoint defPoint(static_cast<int> (point[0].asNum() + offset.x()), static_cast<int> (point[1].asNum() + offset.y()), static_cast<float> (point[3].asNum() + offset.z()));
pointStore.push_back(defPoint);
}
} else if (I->second.isMap()) {
const Atlas::Message::MapType& plist = I->second.asMap();
Atlas::Message::MapType::const_iterator J = plist.begin();
for (; J != plist.end(); ++J) {
if (!J->second.isList()) {
S_LOG_INFO("Non list in points.");
continue;
}
const Atlas::Message::ListType & point = J->second.asList();
if (point.size() != 3) {
S_LOG_INFO("Point without 3 nums.");
continue;
}
int x = static_cast<int> (point[0].asNum());
int y = static_cast<int> (point[1].asNum());
float z = point[2].asNum();
Terrain::TerrainDefPoint defPoint(x + offset.x(), y + offset.y(), z + offset.z());
pointStore.push_back(defPoint);
}
} else {
S_LOG_FAILURE("Terrain is the wrong type");
}
return pointStore;
}
void TerrainEntityManager::entityTerrainModAttrChanged(EmberEntity& entity, const Atlas::Message::Element& value)
{
if (value.isMap() && mTerrainMods.find(&entity) == mTerrainMods.end()) {
Terrain::TerrainMod* mod = new Terrain::TerrainMod(entity, value.Map());
mod->init();
mTerrainMods.insert(std::make_pair(&entity, mod));
mTerrainHandler.addTerrainMod(mod);
entity.BeingDeleted.connect(sigc::bind(sigc::mem_fun(*this, &TerrainEntityManager::entityBeingDeletedTerrainMod), &entity));
}
}
void StdContainer::addToEntity(const std::string & key,
const Atlas::Objects::Entity::RootEntity & ent) const
{
Atlas::Message::Element v = Atlas::Message::ListType();
Atlas::Message::ListType & contlist = v.asList();
EntitySet::const_iterator Iend = m_entities.end();
for (EntitySet::const_iterator I = m_entities.begin(); I != Iend; ++I) {
contlist.push_back((*I)->getId());
}
ent->setAttr(key, v);
}
void ContainsRecursiveFunctionProvider::value(Atlas::Message::Element& value,
const QueryContext& context) const
{
Atlas::Message::Element container;
m_consumer->value(container, context);
if (container.isPtr()) {
value = checkContainer((LocatedEntitySet*)container.Ptr());
}
else{
value = false;
}
}
void RuleTreeAdapter::extractChildren(const Root& op, std::list<std::string>& children)
{
Atlas::Message::Element childElem;
if (op->copyAttr("children", childElem) == 0) {
if (childElem.isList()) {
for (auto child : childElem.asList()) {
if (child.isString()) {
children.push_back(child.asString());
}
}
}
}
}
int main()
{
int ret = 0;
Operation op;
{
Task * task;
OpVector res;
if (0) {
task->TickOperation(op, res);
}
}
Entity ent1("1", 1), ent2("2", 2);
Character chr("3", 3);
{
Fell fell(chr, ent1, ent2);
fell.nextTick(1.5);
Atlas::Message::Element val;
fell.getAttr("foo", val);
assert(val.isNone());
fell.setAttr("foo", 1);
fell.getAttr("foo", val);
assert(val.isInt());
assert(!fell.obsolete());
OpVector res;
assert(res.empty());
Atlas::Objects::Operation::Generic c;
fell.initTask(c, res);
assert(!res.empty());
fell.TickOperation(op, res);
fell.irrelevant();
assert(fell.obsolete());
}
return ret;
}
void TerrainShaderParser::createShaders(const Atlas::Message::Element& surfaces)
{
Terrain::TerrainLayerDefinitionManager& terrainManager = Terrain::TerrainLayerDefinitionManager::getSingleton();
bool isValid = false;
if (surfaces.isList()) {
const Atlas::Message::ListType & slist(surfaces.asList());
for (Atlas::Message::ListType::const_iterator I = slist.begin(); I != slist.end(); ++I) {
if (I->isMap()) {
std::string name;
std::string pattern;
const Atlas::Message::MapType& surfaceMap(I->asMap());
Mercator::Shader::Parameters params;
if (surfaceMap.count("params")) {
const Atlas::Message::Element& paramsElem(surfaceMap.find("params")->second);
if (paramsElem.isMap()) {
for (Atlas::Message::MapType::const_iterator J = paramsElem.asMap().begin(); J != paramsElem.asMap().end(); ++J) {
if (J->second.isNum()) {
params[J->first] = J->second.asNum();
}
}
}
}
if (surfaceMap.count("name")) {
const Atlas::Message::Element& nameElem(surfaceMap.find("name")->second);
if (nameElem.isString()) {
const std::string& name = nameElem.asString();
Terrain::TerrainLayerDefinition* def(terrainManager.getDefinitionForShader(name));
if (def) {
if (surfaceMap.count("pattern")) {
const Atlas::Message::Element& patternElem(surfaceMap.find("pattern")->second);
if (patternElem.isString()) {
const std::string& pattern = patternElem.asString();
Mercator::Shader* shader = Mercator::ShaderFactories::instance().newShader(pattern, params);
if (shader) {
isValid = true;
mTerrainHandler.createShader(def, shader);
}
}
}
}
}
}
}
}
}
if (!isValid) {
createDefaultShaders();
}
}
void StaticAdapter::updateGui(const ::Atlas::Message::Element& element)
{
SelfUpdateContext context(*this);
if (mTextWindow) {
if (element.isString()) {
mTextWindow->setText(element.asString());
} else if (element.isNum()) {
std::stringstream ss;
ss << element.asNum();
mTextWindow->setText(ss.str());
}
}
}
void EmberEntity::onImaginary(const Atlas::Objects::Root& act)
{
Atlas::Message::Element attr;
if (act->copyAttr("description", attr) && attr.isString()) {
std::string message = getName() + " " + attr.asString() + ".";
ConsoleBackend::getSingletonPtr()->pushMessage(message, "info");
S_LOG_VERBOSE("Entity: " << this->getId() << " (" << this->getName() << ") imaginary: " << attr.String());
}
Entity::onImaginary(act);
}
void EntityProperty::set(const Atlas::Message::Element & val)
{
// INT id?
if (val.isString()) {
const std::string & id = val.String();
if (m_data.get() == 0 || m_data->getId() != id) {
debug(std::cout << "Assigning " << id << std::endl << std::flush;);
if (id.empty()) {
m_data = EntityRef(0);
} else {
LocatedEntity * e = BaseWorld::instance().getEntity(id);
if (e != 0) {
debug(std::cout << "Assigned" << std::endl << std::flush;);
m_data = EntityRef(e);
}
void MapProvider::value(Atlas::Message::Element& value, const Atlas::Message::Element& parent_element) const
{
if (!parent_element.isMap()) {
return;
}
auto I = parent_element.Map().find(m_attribute_name);
if (I == parent_element.Map().end()) {
return;
}
if (m_consumer) {
m_consumer->value(value, I->second);
} else {
value = I->second;
}
}
void SizeAdapter::updateGui(const ::Atlas::Message::Element& element)
{
SelfUpdateContext context(*this);
WFMath::AxisBox<3> axisBox;
try {
axisBox.fromAtlas(element.asList());
} catch (...) {
axisBox = WFMath::AxisBox<3>(WFMath::Point<3>(-0.5, -0.5, -0.5), WFMath::Point<3>(0.5, 0.5, 0.5));
}
if (mWidgets.lowerXWindow) {
mWidgets.lowerXWindow->setText(ValueTypeHelper<float, std::string>::convert(axisBox.lowCorner().x()));
}
if (mWidgets.lowerYWindow) {
mWidgets.lowerYWindow->setText(ValueTypeHelper<float, std::string>::convert(axisBox.lowCorner().y()));
}
if (mWidgets.lowerZWindow) {
mWidgets.lowerZWindow->setText(ValueTypeHelper<float, std::string>::convert(axisBox.lowCorner().z()));
}
if (mWidgets.upperXWindow) {
mWidgets.upperXWindow->setText(ValueTypeHelper<float, std::string>::convert(axisBox.highCorner().x()));
}
if (mWidgets.upperYWindow) {
mWidgets.upperYWindow->setText(ValueTypeHelper<float, std::string>::convert(axisBox.highCorner().y()));
}
if (mWidgets.upperZWindow) {
mWidgets.upperZWindow->setText(ValueTypeHelper<float, std::string>::convert(axisBox.highCorner().z()));
}
updateInfo();
}
Py::Object CyPy_Element::wrap(Atlas::Message::Element value)
{
if (value.isNone()) {
return Py::None();
} else if (value.isString()) {
return Py::String(value.String());
} else if (value.isInt()) {
return Py::Long(value.Int());
} else if (value.isFloat()) {
return Py::Float(value.Float());
} else if (value.isList()) {
return CyPy_ElementList::wrap(value.List());
} else {
return CyPy_ElementMap::wrap(value.Map());
}
}
void SizeAdapter::updateGui(const ::Atlas::Message::Element& element)
{
AdapterSelfUpdateContext context(*this);
WFMath::AxisBox<3> axisBox;
try {
axisBox.fromAtlas(element.asList());
} catch (...) {
axisBox = WFMath::AxisBox<3>(WFMath::Point<3>(-0.5, -0.5, -0.5), WFMath::Point<3>(0.5, 0.5, 0.5));
}
if (mLowerXWindow) {
mLowerXWindow->setText(toString(axisBox.lowCorner().x()));
}
if (mLowerYWindow) {
mLowerYWindow->setText(toString(axisBox.lowCorner().y()));
}
if (mLowerZWindow) {
mLowerZWindow->setText(toString(axisBox.lowCorner().z()));
}
if (mUpperXWindow) {
mUpperXWindow->setText(toString(axisBox.highCorner().x()));
}
if (mUpperYWindow) {
mUpperYWindow->setText(toString(axisBox.highCorner().y()));
}
if (mUpperZWindow) {
mUpperZWindow->setText(toString(axisBox.highCorner().z()));
}
updateInfo();
}
bool TerrainArea::parseArea()
{
if (!mEntity.hasAttr("area")) {
S_LOG_FAILURE("TerrainArea created for entity with no area attribute");
return false;
}
const Atlas::Message::Element areaElem(mEntity.valueOfAttr("area"));
if (!areaElem.isMap()) {
S_LOG_FAILURE("TerrainArea element ('area') must be of map type.");
return false;
}
const Atlas::Message::MapType& areaData(areaElem.asMap());
int layer = 0;
WFMath::Polygon<2> poly;
TerrainAreaParser parser;
if (parser.parseArea(areaData, poly, layer)) {
if (!mArea) {
mArea = new Mercator::Area(layer, false);
} else {
//A bit of an ugly hack here since the Mercator system doesn't support changing the layer. We need to swap the old area for a new one if the layer has changed.
if (mArea->getLayer() != layer) {
mOldArea = mArea;
mArea = new Mercator::Area(layer, false);
}
}
// transform polygon into terrain coords
WFMath::Vector<3> xVec = WFMath::Vector<3>(1.0, 0.0, 0.0).rotate(mEntity.getOrientation());
double theta = atan2(xVec.y(), xVec.x()); // rotation about Z
WFMath::RotMatrix<2> rm;
poly.rotatePoint(rm.rotation(theta), WFMath::Point<2>(0, 0));
poly.shift(WFMath::Vector<2>(mEntity.getPosition().x(), mEntity.getPosition().y()));
mArea->setShape(poly);
return true;
} else {
return false;
}
}
void NumberAdapter::updateGui(const ::Atlas::Message::Element& element)
{
SelfUpdateContext context(*this);
if (mTextWindow) {
std::stringstream ss;
ss << element.asNum();
mTextWindow->setText(ss.str());
}
}
void ProvidersTest::test_EntityProperty()
{
Atlas::Message::Element value;
auto provider = CreateProvider( { "entity" });
provider->value(value, QueryContext { *m_b1 });
assert(value.Ptr() == m_b1);
//entity.type
provider = CreateProvider( { "entity", "type" });
provider->value(value, QueryContext { *m_b1 });
assert(value.Ptr() == m_barrelType);
//entity.id
provider = CreateProvider( { "entity", "id" });
provider->value(value, QueryContext { *m_b1 });
assert(value.Int() == 1);
//entity.mass
provider = CreateProvider( { "entity", "mass" });
provider->value(value, QueryContext { *m_b1 });
assert(value.Int() == 30);
//entity.burn_speed
provider = CreateProvider( { "entity", "burn_speed" });
provider->value(value, QueryContext { *m_b1 });
assert(value.Float() == 0.3);
}
void ProvidersTest::test_BBoxProviders()
{
Atlas::Message::Element value;
//entity.bbox.volume
auto provider = CreateProvider( { "entity", "bbox", "volume" });
provider->value(value, QueryContext { *m_b1 });
assert(value.Float() == 48.0);
//entity.bbox.height
provider = CreateProvider( { "entity", "bbox", "height" });
provider->value(value, QueryContext { *m_b1 });
assert(value.Float() == 6.0);
//entity.bbox.width
provider = CreateProvider( { "entity", "bbox", "width" });
provider->value(value, QueryContext { *m_b1 });
assert(value.Float() == 2.0);
//entity.bbox.depth
provider = CreateProvider( { "entity", "bbox", "depth" });
provider->value(value, QueryContext { *m_b1 });
assert(value.Float() == 4.0);
//entity.bbox.area
provider = CreateProvider( { "entity", "bbox", "area" });
provider->value(value, QueryContext { *m_b1 });
assert(value.Float() == 8.0);
}
void TerrainArea::parse(const Atlas::Message::Element& value, Mercator::Area** area)
{
if (!value.isMap()) {
S_LOG_FAILURE("TerrainArea element ('area') must be of map type.");
return;
}
const Atlas::Message::MapType& areaData = value.Map();
TerrainAreaParser parser;
if (!parser.parseArea(areaData, mParsedPoly, mParsedLayer)) {
return;
} else {
WFMath::Polygon<2> poly = mParsedPoly;
if (!placeArea(poly)) {
return;
}
//TODO: handle holes
*area = new Mercator::Area(mParsedLayer, false);
(*area)->setShape(poly);
}
}
int OutfitProperty::get(Atlas::Message::Element & val) const
{
val = MapType();
MapType & val_map = val.Map();
EntityRefMap::const_iterator I = m_data.begin();
EntityRefMap::const_iterator Iend = m_data.end();
for (; I != Iend; ++I) {
const EntityRef & item = I->second;
if (item.get() == 0) {
val_map[I->first] = "";
} else {
val_map[I->first] = item->getId();
}
}
return 0;
}
