void
CollisionComponent::load(
const StorageContainer& storage
) {
Component::load(storage);
StorageList collisionGroups = storage.get<StorageList>("collisionGroups");
m_collisionGroups.reserve(collisionGroups.size());
for (const StorageContainer& container : collisionGroups) {
std::string collisionGroup = container.get<std::string>("collisionGroup");
m_collisionGroups.push_back(collisionGroup);
}
}
StorageContainer
SoundSourceComponent::storage() const {
StorageContainer storage = Component::storage();
storage.set("ambientSoundSource", m_ambientSoundSource.get());
storage.set("autoLoop", m_autoLoop.get());
StorageList sounds;
sounds.reserve(m_sounds.size());
for (const auto& pair : m_sounds) {
sounds.push_back(pair.second->storage());
}
storage.set<StorageList>("sounds", sounds);
return storage;
}
StorageContainer
LockedMapComponent::storage() const {
StorageContainer storage = Component::storage();
StorageList locks;
locks.reserve(m_locks.size());
for (const auto& name : m_locks) {
StorageContainer container;
container.set<std::string>("name", name);
locks.append(container);
}
storage.set<StorageList>("locks", locks);
return storage;
}
StorageContainer
CollisionComponent::storage() const {
StorageContainer storage = Component::storage();
StorageList collisionGroups;
collisionGroups.reserve(m_collisionGroups.size());
for (std::string collisionGroup : m_collisionGroups) {
StorageContainer container;
container.set<std::string>("collisionGroup", collisionGroup);
collisionGroups.append(container);
}
storage.set<StorageList>("collisionGroups", collisionGroups);
return storage;
}
StorageContainer
AgentAbsorberComponent::storage() const {
StorageContainer storage = Component::storage();
StorageList agents;
agents.reserve(m_canAbsorbAgent.size());
for (AgentId agentId : m_canAbsorbAgent) {
StorageContainer container;
container.set<AgentId>("agentId", agentId);
container.set<float>("amount", this->absorbedAgentAmount(agentId));
agents.append(container);
}
storage.set<StorageList>("agents", agents);
return storage;
}
StorageContainer
CompoundAbsorberComponent::storage() const {
StorageContainer storage = Component::storage();
StorageList compounds;
compounds.reserve(m_canAbsorbCompound.size());
for (CompoundId compoundId : m_canAbsorbCompound) {
StorageContainer container;
container.set<CompoundId>("compoundId", compoundId);
container.set<float>("amount", this->absorbedCompoundAmount(compoundId));
compounds.append(container);
}
storage.set<StorageList>("compounds", compounds);
storage.set<bool>("enabled", m_enabled);
return storage;
}
StorageContainer
PlayerData::storage() const {
StorageContainer storage;
storage.set("playerName", m_impl->m_playerName);
StorageList boolValues;
boolValues.reserve(m_impl->m_boolSet.size());
for(auto key : m_impl->m_boolSet) {
StorageContainer container;
container.set<std::string>("boolKey", key);
boolValues.append(container);
}
storage.set<StorageList>("boolValues", boolValues);
storage.set("lockedMap", m_impl->m_lockedMap.storage());
return storage;
}
StorageContainer
EntityManager::storeEntity(
EntityId entityId
) const {
StorageContainer entityStorage;
StorageList componentList;
for (const auto& pair : m_impl->m_collections) {
Component* component = pair.second->get(entityId);
if (component != nullptr){
StorageContainer componentStorage = component->storage();
componentStorage.set("typename", component->typeName());
componentList.append(componentStorage);
}
}
entityStorage.set("components", std::move(componentList));
return entityStorage;
}
StorageContainer
EntityManager::storage(
const ComponentFactory& factory
) const {
StorageContainer storage;
// Current Id
storage.set("currentId", m_impl->m_currentId);
// Collections
StorageContainer collections;
for (const auto& item : m_impl->m_collections) {
const auto& components = item.second->components();
StorageList componentList;
componentList.reserve(components.size());
for (const auto& pair : components) {
EntityId entityId = pair.first;
const std::unique_ptr<Component>& component = pair.second;
if (component->isVolatile() or
m_impl->m_volatileEntities.count(entityId) > 0
) {
continue;
}
componentList.append(component->storage());
}
if (not componentList.empty()) {
std::string typeName = factory.getTypeName(item.first);
collections.set(typeName, std::move(componentList));
}
}
storage.set("collections", std::move(collections));
// Components to remove
StorageList componentsToRemove;
componentsToRemove.reserve(m_impl->m_componentsToRemove.size());
for (const auto& pair : m_impl->m_componentsToRemove) {
StorageContainer pairStorage;
pairStorage.set("entityId", pair.first);
std::string typeName = factory.getTypeName(pair.second);
pairStorage.set("componentTypeName", typeName);
componentsToRemove.append(std::move(pairStorage));
}
storage.set("componentsToRemove", std::move(componentsToRemove));
// Entities to remove
StorageList entitiesToRemove;
entitiesToRemove.reserve(m_impl->m_entitiesToRemove.size());
for (EntityId entityId : m_impl->m_entitiesToRemove) {
StorageContainer idStorage;
idStorage.set("id", entityId);
entitiesToRemove.append(std::move(idStorage));
}
storage.set("entitiesToRemove", std::move(entitiesToRemove));
// Named entities
StorageList namedIds;
namedIds.reserve(m_impl->m_namedIds.size());
for (const auto& item : m_impl->m_namedIds) {
StorageContainer itemStorage;
itemStorage.set("name", item.first);
itemStorage.set("entityId", item.second);
namedIds.append(std::move(itemStorage));
}
storage.set("namedIds", std::move(namedIds));
return storage;
}
