static void funserv_cmd_requestbot(sourceinfo_t *si, int parc, char *parv[])
{
char *name = parv[0];
mychan_t *mc;
if (!name)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "REQUESTBOT");
command_fail(si, fault_needmoreparams, _("Syntax: REQUESTBOT <#channel>"));
}
if (*name != '#')
{
command_fail(si, fault_needmoreparams, STR_INVALID_PARAMS, "REQUESTBOT");
command_fail(si, fault_needmoreparams, _("Syntax: REQUESTBOT <#channel>"));
}
if (!(mc = mychan_find(name)))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), name);
return;
}
if (!is_founder(mc, entity(si->smu)))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this operation."));
return;
}
myuser_notice(funserv->nick, myuser_find_ext(BOTNAME), "JOIN %s", name);
command_success_nodata(si, "The bot should now be in %s.", name);
}
bool SearchTreeNode::UnSerializeString(const wxString& s,wxString& result)
{
result.Clear();
size_t i;
int mode = 0;
wxString entity(_T(""));
unsigned int u;
for (i = 0;mode >=0 && i<s.length();i++)
{
wxChar ch = s[i];
if (ch==_T('"') || ch==_T('>') || ch==_T('<'))
{
mode = -1; // Error
break;
}
switch(mode)
{
case 0: // normal
if (ch==_T('&'))
{
mode = 1;
entity.Clear();
}
else
result << ch;
case 1: // escaped
if (ch==_T('&'))
{
mode = -1; // Error
break;
}
else if (ch==_T(';'))
{
mode = 0;
if (entity==_T("quot"))
ch = _T('"');
else if (entity==_T("amp"))
ch = _T('&');
else if (entity==_T("apos"))
ch = _T('\'');
else if (entity==_T("lt"))
ch = _T('<');
else if (entity==_T("gt"))
ch = _T('>');
else if (entity[0]==_T('#') && S2U(entity.substr(1),u))
ch = u;
else
{
mode = -1; // Error: Unrecognized entity
break;
}
result << ch;
}
break;
}
}
if (mode < 0)
result.Clear();
return (mode >= 0);
}
//------------------------------------------------------------------------------
void ParticleSystem::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
#ifdef ZN_DEBUG
if(r_texture == nullptr)
log.err() << "ParticleSystem::draw: no atlas defined !" << log.endl();
#endif
// apply texture
states.texture = r_texture;
AbstractTransform * t = entity().transform();
if(t && t->matrix())
{
states.transform = *(t->matrix());
}
// draw the vertex array
target.draw(m_vertices, states);
// Test debug
// sf::RectangleShape s(sf::Vector2f(32,32));
// for(u32 i = 0; i < m_particles.size(); ++i)
// {
// s.setPosition(m_particles[i].pos);
// target.draw(s);
// }
}
static void check_hidehost(user_t *u)
{
static bool warned = false;
char buf[HOSTLEN + 1];
/* do they qualify? */
if (!(u->flags & UF_HIDEHOSTREQ) || u->myuser == NULL || (u->myuser->flags & MU_WAITAUTH))
return;
/* don't use this if they have some other kind of vhost */
if (strcmp(u->host, u->vhost))
{
slog(LG_DEBUG, "check_hidehost(): +x overruled by other vhost for %s", u->nick);
return;
}
if (me.hidehostsuffix == NULL)
{
if (!warned)
{
wallops("Misconfiguration: serverinfo::hidehostsuffix not set");
warned = true;
}
return;
}
snprintf(buf, sizeof buf, "%s.%s", entity(u->myuser)->name, me.hidehostsuffix);
strshare_unref(u->vhost);
u->vhost = strshare_get(buf);
slog(LG_DEBUG, "check_hidehost(): %s -> %s", u->nick, u->vhost);
}
Entity EntityManager::CreateEntity(
std::vector<std::shared_ptr<ComponentCreatorBase>> && componentCreators)
{
Entity entity(&context, context.Create(std::move(componentCreators)));
entities.push_back(entity.GetID());
return std::move(entity);
}
TEST( EntityHandlerTest, AddAndRemoveComponentsDynamic )
{
SystemHandler system;
EntityHandler entity( &system );
Entity ent1 = entity.CreateEntity();
Entity ent2 = entity.CreateEntity();
entity.AddComponentsAspect( ent1, 1ULL << 1 | 1ULL << 2 );
entity.AddComponentsAspect( ent2, 1ULL << 0 | 1ULL << 2 );
ASSERT_EQ( (Aspect)(entity.GenerateAspect<Component2,Component3>()), entity.GetEntityAspect( ent1 ) );
ASSERT_EQ( (Aspect)(1ULL << 0 | 1ULL << 2), entity.GetEntityAspect( ent2 ) );
entity.RemoveComponentsAspect( ent1, 1ULL << 1 );
entity.RemoveComponentsAspect( ent2, 1ULL << 2 );
ASSERT_EQ( (Aspect)(entity.GenerateAspect<Component3>()), entity.GetEntityAspect( ent1 ) );
ASSERT_EQ( (Aspect)(1ULL << 0), entity.GetEntityAspect( ent2 ) );
entity.RemoveComponentsAspect( ent1, 1ULL << 2 );
entity.RemoveComponentsAspect( ent2, 1ULL << 0 );
ASSERT_EQ( (Aspect)(0ULL), entity.GetEntityAspect( ent1 ) );
ASSERT_EQ( (Aspect)(0ULL), entity.GetEntityAspect( ent2 ) );
}
TEST( EntityHandlerTest, AddAndRemoveComponentsTemplate )
{
SystemHandler system;
EntityHandler entity( &system );
Entity ent1 = entity.CreateEntity();
Entity ent2 = entity.CreateEntity();
entity.AddComponents<Component2,Component3>( ent1, Component2(), Component3() );
entity.AddComponents<Component1,Component3>( ent2, Component1(), Component3() );
ASSERT_EQ( (Aspect)(entity.GenerateAspect<Component2,Component3>()), entity.GetEntityAspect( ent1 ) );
ASSERT_EQ( (Aspect)(1ULL << 0 | 1ULL << 2), entity.GetEntityAspect( ent2 ) );
entity.RemoveComponents<Component2>( ent1 );
entity.RemoveComponents<Component3>( ent2 );
ASSERT_EQ( (Aspect)(entity.GenerateAspect<Component3>()), entity.GetEntityAspect( ent1 ) );
ASSERT_EQ( (Aspect)(1ULL << 0), entity.GetEntityAspect( ent2 ) );
entity.RemoveComponents<Component3>( ent1 );
entity.RemoveComponents<Component1>( ent2 );
ASSERT_EQ( (Aspect)(0ULL), entity.GetEntityAspect( ent1 ) );
ASSERT_EQ( (Aspect)(0ULL), entity.GetEntityAspect( ent2 ) );
}
static void show_setpass(hook_user_req_t *hdata)
{
if (has_priv(hdata->si, PRIV_USER_AUSPEX))
{
if (get_setpass_key(hdata->mu) != NULL)
{
metadata_t *md;
char strfbuf[BUFSIZE];
char buf[BUFSIZE];
size_t buflen = 0;
buf[0] = '\0';
if ((md = metadata_find(hdata->mu, "private:sendpass:sender")) != NULL)
buflen += snprintf(buf + buflen, sizeof(buf) - buflen, " by %s", md->value);
if ((md = metadata_find(hdata->mu, "private:sendpass:timestamp")) != NULL)
{
time_t ts;
struct tm tm;
ts = atoi(md->value);
tm = *localtime(&ts);
strftime(strfbuf, sizeof strfbuf, TIME_FORMAT, &tm);
buflen += snprintf(buf + buflen, sizeof(buf) - buflen, " on %s (%s ago)", strfbuf, time_ago(ts));
}
if (buf[0] != '\0')
command_success_nodata(hdata->si, _("%s has an active \2SETPASS\2 key (sent%s)"), entity(hdata->mu)->name, buf);
else
command_success_nodata(hdata->si, _("%s has an active \2SETPASS\2 key"), entity(hdata->mu)->name);
}
}
}
ApplicationVersion ApplicationVersionRepository::findOneByFields(
Texsample::ClientType clienType, BeQt::OSType os, BeQt::ProcessorArchitecture arch, bool portable, bool *ok)
{
ApplicationVersion entity(this);
if (!isValid() || Texsample::UnknownClient == clienType || BeQt::UnknownOS == os
|| BeQt::UnknownArchitecture == arch) {
return bRet(ok, false, entity);
}
QString ws = "client_type = :client_type AND os_type = :os_type AND portable = :portable "
"AND processor_architecture_type = :processor_architecture_type";
QVariantMap values;
values.insert(":client_type", int(clienType));
values.insert(":os_type", int(os));
values.insert(":portable", int(portable));
values.insert(":processor_architecture_type", int(arch));
BSqlResult result = Source->select("application_versions", QStringList() << "download_url" << "version",
BSqlWhere(ws, values));
if (!result.success())
return bRet(ok, false, entity);
if (result.values().isEmpty())
return bRet(ok, true, entity);
entity.mclienType = clienType;
entity.mdownloadUrl = QUrl(result.value("download_url").toString());
entity.mos = os;
entity.mportable = portable;
entity.mprocessorArchitecture = arch;
entity.mversion = BVersion(result.value("version").toString());
entity.valid = true;
return bRet(ok, true, entity);
}
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();
}
}
entity table::getEntityWith(vector<attribute> primary_key){
for(unsigned int i = 0; i < entity_list.size(); i++){
entity current_entity = entity_list[i];
bool check = false;
for(unsigned int j = 0; j < primary_keys.size(); j++){
int key = primary_keys[j];
attribute attr = current_entity.getAttribute(key);
if(column_types[key] == INTEGER){
check = (attr.get_int_value() == primary_key[j].get_int_value());
}
else if(column_types[key] == STRING){
check = (attr.get_string_value() == primary_key[j].get_string_value());
}
if(!check){ break; }
}
if(check){
return current_entity;
}
}
return entity();
}
EntityPtr EntityFactory::createTexturedEntity(const string& assetTag, float tx, float ty, float w, float h) {
EntitySystemPtr entitySystem = makeShared(mSystemManager->getSystemByType<EntitySystem>(SystemType::ENTITY));
EntityPtr entity(GCC_NEW Entity());
entitySystem->addEntity(entity);
PhysicsSystemPtr physicsSystem = makeShared(mSystemManager->getSystemByType<PhysicsSystem>(SystemType::PHYSICS));
BodyPtr blockBody(GCC_NEW Body(0.0f, 0.0f, w, h));
physicsSystem->registerBody(entity->id, blockBody);
PhysicsComponentPtr physicsComponent(GCC_NEW PhysicsComponent(entity->id, blockBody));
GraphicsSystemPtr graphicsSystem = makeShared(mSystemManager->getSystemByType<GraphicsSystem>(SystemType::GRAPHICS));
TexturePtr texture(GCC_NEW Texture(assetTag, tx, ty, w, h));
DrawablePtr textureDrawable(GCC_NEW TextureDrawable(texture));
graphicsSystem->registerDrawable(entity->id, textureDrawable);
DrawableComponentPtr drawableComponent(GCC_NEW DrawableComponent(entity->id, textureDrawable));
InputSystemPtr inputSystem = makeShared(mSystemManager->getSystemByType<InputSystem>(SystemType::INPUT));
InputListenerPtr inputListener(GCC_NEW InputListener(entity->id));
inputSystem->registerEventListener(inputListener);
InputComponentPtr inputComponent(GCC_NEW InputComponent(entity->id, inputListener));
entity->addComponent(ComponentPtr(physicsComponent));
entity->addComponent(ComponentPtr(drawableComponent));
entity->addComponent(ComponentPtr(inputComponent));
return entity;
}
static void gs_cmd_fdrop(sourceinfo_t *si, int parc, char *parv[])
{
mygroup_t *mg;
char *name = parv[0];
if (!name)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "DROP");
command_fail(si, fault_needmoreparams, _("Syntax: DROP <!group>"));
return;
}
if (*name != '!')
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "DROP");
command_fail(si, fault_badparams, _("Syntax: DROP <!group>"));
return;
}
if (!(mg = mygroup_find(name)))
{
command_fail(si, fault_nosuch_target, _("Group \2%s\2 does not exist."), name);
return;
}
remove_group_chanacs(mg);
logcommand(si, CMDLOG_ADMIN | LG_REGISTER, "FDROP: \2%s\2", entity(mg)->name);
wallops("%s dropped the group \2%s\2", get_oper_name(si), name);
object_unref(mg);
command_success_nodata(si, _("The group \2%s\2 has been dropped."), name);
return;
}
bool onLoad()
{
// Create the off-screen surface
if (!m_surface.create(800, 600))
return false;
m_surface.setSmooth(true);
// Load the textures
if (!m_backgroundTexture.loadFromFile("resources/sfml.png"))
return false;
m_backgroundTexture.setSmooth(true);
if (!m_entityTexture.loadFromFile("resources/devices.png"))
return false;
m_entityTexture.setSmooth(true);
// Initialize the background sprite
m_backgroundSprite.setTexture(m_backgroundTexture);
m_backgroundSprite.setPosition(135, 100);
// Load the moving entities
for (int i = 0; i < 6; ++i)
{
sf::Sprite entity(m_entityTexture, sf::IntRect(96 * i, 0, 96, 96));
m_entities.push_back(entity);
}
// Load the shader
if (!m_shader.loadFromFile("resources/edge.frag", sf::Shader::Fragment))
return false;
m_shader.setParameter("texture", sf::Shader::CurrentTexture);
return true;
}
static duk_ret_t EntityReference_Set_EntityPtr(duk_context* ctx)
{
EntityReference* thisObj = GetThisValueObject<EntityReference>(ctx, EntityReference_ID);
SharedPtr<Entity> entity(GetWeakObject<Entity>(ctx, 0));
thisObj->Set(entity);
return 0;
}
void
SnatchComponent::update(TIME)
{
if (m_registered)
return;
if (!m_layer) {
Game::WeakSceneLayer l_layer = entity().layer().scene().getLayerType("SnatcherLayer");
m_layer = l_layer.cast<SnatcherLayer>();
}
if (m_layer) {
m_layer->registerEntity(entity());
m_registered = true;
}
}
/* ircd allows forwards to existing channels; the target channel must be
* +F or the setter must have ops in it */
static bool check_forward(const char *value, channel_t *c, mychan_t *mc, user_t *u, myuser_t *mu)
{
channel_t *target_c;
mychan_t *target_mc;
chanuser_t *target_cu;
if (!VALID_GLOBAL_CHANNEL_PFX(value) || strlen(value) > 50)
return false;
if (u == NULL && mu == NULL)
return true;
target_c = channel_find(value);
target_mc = mychan_from(target_c);
if (target_c == NULL && target_mc == NULL)
return false;
if (target_c != NULL && target_c->modes & CMODE_FTARGET)
return true;
if (target_mc != NULL && target_mc->mlock_on & CMODE_FTARGET)
return true;
if (u != NULL)
{
target_cu = chanuser_find(target_c, u);
if (target_cu != NULL && target_cu->modes & CSTATUS_OP)
return true;
if (chanacs_user_flags(target_mc, u) & CA_SET)
return true;
}
else if (mu != NULL)
if (chanacs_entity_has_flag(target_mc, entity(mu), CA_SET))
return true;
return false;
}
void EntityCreatorTypeHelper::updatePreview() {
if (mModelPreviewRenderer && mRuleTreeAdapter) {
auto typeData = mRuleTreeAdapter->getSelectedRule();
if (typeData.isValid()) {
//check if the type is bound
mCurrentType = typeData->getId();
auto type = mConnection.getTypeService()->getTypeByName(typeData->getId());
if (type && type->isBound()) {
Authoring::DetachedEntity entity("0", type, mConnection.getTypeService());
showPreview(entity);
mCreateButton->setEnabled(true);
auto modeElement = type->getAttribute("mode");
if (modeElement && modeElement->isString()) {
mDefaultModeWindow.setText("(" + modeElement->String() + ")");
} else {
mModeCombobox.setText("");
}
} else {
mModelPreviewRenderer->showModel("");
mCreateButton->setEnabled(false);
}
} else {
mModelPreviewRenderer->showModel("");
mCreateButton->setEnabled(false);
}
}
}
void copy_entities(const EntityProcVec & keys_to_copy, const std::string & transfer_name)
{
m_bulk_data.modification_begin();
{
mesh::EntityProcVec new_entities_to_copy(keys_to_copy.size());
for (size_t i=0; i<keys_to_copy.size(); ++i) {
// convert from EntityProc based on EntityKey to EntityProc based on raw Entity.
const EntityProc key_proc = keys_to_copy[i];
const EntityKey key = key_proc.id();
const unsigned proc = key_proc.proc();
const Entity e = entity(key);
const mesh::EntityProc ep( e, proc);
new_entities_to_copy[i] = ep;
}
m_entities_currently_ghosted.insert(m_entities_currently_ghosted.end(),
new_entities_to_copy.begin(),
new_entities_to_copy.end());
std::sort(m_entities_currently_ghosted.begin(), m_entities_currently_ghosted.end());
mesh::EntityProcVec::iterator del = std::unique(m_entities_currently_ghosted.begin(), m_entities_currently_ghosted.end());
m_entities_currently_ghosted.resize(std::distance(m_entities_currently_ghosted.begin(), del));
}
{
m_bulk_data.change_ghosting(*m_transfer_entity_ghosting,
m_entities_currently_ghosted);
std::vector<mesh::EntityKey> receive;
std::vector<mesh::EntityProc> send;
m_transfer_entity_ghosting->receive_list( receive );
m_transfer_entity_ghosting->send_list( send );
}
m_mesh_modified = true;
m_bulk_data.modification_end();
}
/* ****************************************************************************
*
* mapGetIndividualContextEntityAttributes -
*/
HttpStatusCode mapGetIndividualContextEntityAttributes(const std::string& entityId, ContextElementResponse* response, ConnectionInfo* ciP)
{
HttpStatusCode ms;
QueryContextRequest qcRequest;
QueryContextResponse qcResponse;
EntityId entity(entityId, "", "false");
// Here I fill in the 'query' entityId for the response
response->contextElement.entityId.fill(entityId, "", "false");
qcRequest.entityIdVector.push_back(&entity);
ms = mongoQueryContext(&qcRequest, &qcResponse, ciP->tenant, ciP->servicePathV, ciP->uriParam);
if ((ms != SccOk) || (qcResponse.contextElementResponseVector.size() == 0))
{
// Here I fill in statusCode for the response
response->statusCode.fill(SccContextElementNotFound, std::string("Entity id: '") + entityId + "'");
LM_RE(ms, ("entityId '%s' not found", entityId.c_str()));
}
std::vector<ContextAttribute*> attrV = qcResponse.contextElementResponseVector.get(0)->contextElement.contextAttributeVector.vec;
for (unsigned int ix = 0; ix < attrV.size() ; ++ix) {
ContextAttribute* ca = new ContextAttribute(attrV[ix]);
response->contextElement.contextAttributeVector.push_back(ca);
}
response->statusCode.fill(&qcResponse.contextElementResponseVector.get(0)->statusCode);
return ms;
}
void add (CEntity* b)
{
entity_list.push_back(entity(b));
polycount = 0;
}
EntityPtr EntityFactory::createAnimatedEntity(const string& path, float width, float height) {
EntitySystemPtr entitySystem = makeShared(mSystemManager->getSystemByType<EntitySystem>(SystemType::ENTITY));
EntityPtr entity(GCC_NEW Entity());
entitySystem->addEntity(entity);
PhysicsSystemPtr physicsSystem = makeShared(mSystemManager->getSystemByType<PhysicsSystem>(SystemType::PHYSICS));
BodyPtr blockBody(GCC_NEW Body(0.0f, 0.0f, width, height));
physicsSystem->registerBody(entity->id, blockBody);
PhysicsComponentPtr physicsComponent(GCC_NEW PhysicsComponent(entity->id, blockBody));
GraphicsSystemPtr graphicsSystem = makeShared(mSystemManager->getSystemByType<GraphicsSystem>(SystemType::GRAPHICS));
TexturePtr texture(GCC_NEW Texture(""));
shared_ptr<TextureDrawable> textureDrawable(GCC_NEW TextureDrawable(texture));
graphicsSystem->registerDrawable(entity->id, textureDrawable);
DrawableComponentPtr drawableComponent(GCC_NEW DrawableComponent(entity->id, textureDrawable));
AnimationSystemPtr animationSystem = makeShared(mSystemManager->getSystemByType<AnimationSystem>(SystemType::ANIMATION));
AnimationSetPtr animationSet = animationSystem->createAnimationSet(path);
AnimationHandlerPtr animationHandler(GCC_NEW AnimationHandler(textureDrawable, animationSet, animationSet->fps));
animationSystem->registerAnimation(entity->id, animationHandler);
AnimationComponentPtr animationComponent(GCC_NEW AnimationComponent(entity->id, animationHandler));
InputSystemPtr inputSystem(makeShared(mSystemManager->getSystemByType<InputSystem>(SystemType::INPUT)));
InputListenerPtr inputListener(GCC_NEW InputListener(entity->id));
inputSystem->registerEventListener(inputListener);
InputComponentPtr inputComponent(GCC_NEW InputComponent(entity->id, inputListener));
entity->addComponent(ComponentPtr(physicsComponent));
entity->addComponent(ComponentPtr(drawableComponent));
entity->addComponent(ComponentPtr(animationComponent));
entity->addComponent(ComponentPtr(inputComponent));
return entity;
}
EntityPtr EntityFactory::createDefault() {
EntitySystemPtr entitySystem = makeShared(mSystemManager->getSystemByType<EntitySystem>(SystemType::ENTITY));
EntityPtr entity(GCC_NEW Entity());
entitySystem->addEntity(entity);
PhysicsSystemPtr physicsSystem = makeShared(mSystemManager->getSystemByType<PhysicsSystem>(SystemType::PHYSICS));
BodyPtr blockBody(GCC_NEW Body(0, 0, 16, 16));
physicsSystem->registerBody(entity->id, blockBody);
PhysicsComponentPtr physicsComponent(GCC_NEW PhysicsComponent(entity->id, blockBody));
physicsComponent->setCollider(GCC_NEW Collider(0, 0, 16, 16));
GraphicsSystemPtr graphicsSystem = makeShared(mSystemManager->getSystemByType<GraphicsSystem>(SystemType::GRAPHICS));
DrawablePtr blockDrawable(GCC_NEW BlockDrawable(16, 16, 255, 0, 0, 255));
graphicsSystem->registerDrawable(entity->id, blockDrawable);
DrawableComponentPtr drawableComponent(GCC_NEW DrawableComponent(entity->id, blockDrawable));
InputSystemPtr inputSystem = makeShared(mSystemManager->getSystemByType<InputSystem>(SystemType::INPUT));
InputListenerPtr inputListener(GCC_NEW InputListener(entity->id));
inputSystem->registerEventListener(inputListener);
InputComponentPtr inputComponent(GCC_NEW InputComponent(entity->id, inputListener));
entity->addComponent(ComponentPtr(physicsComponent));
entity->addComponent(ComponentPtr(drawableComponent));
entity->addComponent(ComponentPtr(inputComponent));
return entity;
}
// Creates a serializable object from the given parameters.
lean::scoped_ptr<Entity, lean::critical_ref> EntitySerializer::Create(const beCore::Parameters &creationParameters, const beCore::ParameterSet ¶meters) const
{
lean::scoped_ptr<Entity> entity( GetEntities(parameters)->AddEntity() );
entity->SetName( creationParameters.GetValueDefault<beCore::Exchange::utf8_string>("Name") );
return entity.transfer();
}
void Map_Read (scene::Node& root, Tokeniser& tokeniser, EntityCreator& entityTable, const PrimitiveParser& parser)
{
// Create an info display panel to track load progress
gtkutil::ModalProgressDialog dialog(GlobalRadiant().getMainWindow(), _("Loading map"));
// Read each entity in the map, until EOF is reached
for (int entCount = 0; ; entCount++) {
// Update the dialog text
dialog.setText("Loading entity " + string::toString(entCount));
// Check for end of file
if (tokeniser.getToken().empty())
break;
// Create an entity node by parsing from the stream
NodeSmartReference entity(Entity_parseTokens(tokeniser, entityTable, parser, entCount));
if (entity == g_nullNode) {
globalErrorStream() << "entity " << entCount << ": parse error\n";
return;
}
// Insert the new entity into the scene graph
Node_getTraversable(root)->insert(entity);
}
}
void movement_system::update(const double ms) {
// If the octree is empty, fill it
if (entity_octree.total_nodes == 0) {
each<position_t>([] (entity_t &e, position_t &pos) {
entity_octree.add_node(octree_location_t{pos.x, pos.y, pos.z, e.id});
});
}
std::queue<entity_wants_to_move_message> * movers = mbox<entity_wants_to_move_message>();
while (!movers->empty()) {
entity_wants_to_move_message msg = movers->front();
movers->pop();
if (!entity(msg.entity_id)) break;
auto epos = entity(msg.entity_id)->component<position_t>();
position_t origin{epos->x, epos->y, epos->z};
// Bounds check
if (msg.destination.x < 1 || msg.destination.x > REGION_WIDTH-1 || msg.destination.y < 1 || msg.destination.y > REGION_HEIGHT-1
|| msg.destination.z < 1 || msg.destination.z > REGION_DEPTH-1) break;
// Move
epos->x = msg.destination.x;
epos->y = msg.destination.y;
epos->z = msg.destination.z;
// Do vegetation damage
const auto idx = mapidx(msg.destination.x, msg.destination.y, msg.destination.z);
if (current_region->tile_vegetation_type[idx] > 0) {
emit_deferred(vegetation_damage_message{idx, 1});
}
emit(entity_moved_message{msg.entity_id, origin, msg.destination});
emit(renderables_changed_message{});
}
std::queue<entity_moved_message> * moved = mbox<entity_moved_message>();
while (!moved->empty()) {
entity_moved_message msg = moved->front();
moved->pop();
octree_location_t start = octree_location_t{msg.origin.x, msg.origin.y, msg.origin.z, msg.entity_id};
octree_location_t end = octree_location_t{msg.destination.x, msg.destination.y, msg.destination.z, msg.entity_id};
entity_octree.remove_node(start);
entity_octree.add_node(end);
}
}
OutputPortMirror *VertexMirror::output(
m3bp::identifier_type id, const std::string &name,
bool has_key) {
auto port = new OutputPortMirror(m_engine, this, id, name);
m_outputs.insert(m_outputs.begin() + id, port);
port->entity().has_key(has_key);
return port;
}
static NodeSmartReference Entity_create (EntityCreator& entityTable, EntityClass* entityClass, const KeyValues& keyValues)
{
scene::Node& entity(entityTable.createEntity(entityClass));
for (KeyValues::const_iterator i = keyValues.begin(); i != keyValues.end(); ++i) {
Node_getEntity(entity)->setKeyValue((*i).first, (*i).second);
}
return NodeSmartReference(entity);
}
shared_ptr<Entity> EntityEngine::createEntity()
{
entity_ptr entity(new Entity(nextEntityUUID(), componentOperationHandler));
auto operation = shared_ptr<EntityOperation>(new EntityOperation(entity, EntityOperation::EntityOperationType::ADD));
entityOperations.push_back(operation);
return entity;
}
GameEntity* GameSystem::createEntity()
{
assert(GameEntity::Max > mEntities.size());
std::unique_ptr<GameEntity> entity(new GameEntity());
GameEntity* entityPtr = entity.get();
mEntities.push_back(std::move(entity));
return entityPtr;
}
