void
CompoundBagComponent::load(const StorageContainer& storage)
{
Component::load(storage);
StorageContainer amounts = storage.get<StorageContainer>("amounts");
StorageContainer prices = storage.get<StorageContainer>("prices");
StorageContainer uninflatedPrices = storage.get<StorageContainer>("uninflatedPrices");
StorageContainer demand = storage.get<StorageContainer>("demand");
for (const std::string& id : amounts.keys())
{
CompoundId compoundId = std::atoi(id.c_str());
this->compounds[compoundId].amount = amounts.get<double>(id);
this->compounds[compoundId].price = prices.get<double>(id);
this->compounds[compoundId].uninflatedPrice = uninflatedPrices.get<double>(id);
this->compounds[compoundId].demand = demand.get<double>(id);
}
this->storageSpace = storage.get<float>("storageSpace");
this->speciesName = storage.get<std::string>("speciesName");
this->processor = static_cast<ProcessorComponent*>(Entity(this->speciesName,
Game::instance().engine().getCurrentGameStateFromLua()).
getComponent(ProcessorComponent::TYPE_ID));
}
void
saveSavegame() {
StorageContainer savegame;
savegame.set("currentGameState", m_currentGameState->name());
StorageContainer gameStates;
for (const auto& pair : m_gameStates) {
gameStates.set(pair.first, pair.second->storage());
}
savegame.set("gameStates", std::move(gameStates));
std::ofstream stream(
m_serialization.saveFile,
std::ofstream::trunc | std::ofstream::binary
);
m_serialization.saveFile = "";
stream.exceptions(std::ofstream::failbit | std::ofstream::badbit);
if (stream) {
try {
stream << savegame;
stream.flush();
stream.close();
}
catch (const std::ofstream::failure& e) {
std::cerr << "Error saving file: " << e.what() << std::endl;
throw;
}
}
else {
std::perror("Could not open file for saving");
}
}
StorageContainer
PowerupComponent::storage() const {
StorageContainer storage = Component::storage();
storage.set("effect", effectName);
return storage;
}
void
ProcessorComponent::load(const StorageContainer& storage)
{
Component::load(storage);
StorageContainer processes = storage.get<StorageContainer>("processes");
for (const std::string& id : processes.keys())
{
this->process_capacities[std::atoi(id.c_str())] = processes.get<double>(id);
}
}
StorageContainer
OgreCameraComponent::storage() const {
StorageContainer storage = Component::storage();
storage.set("name", m_name);
storage.set<Ogre::Real>("farClipDistance", m_properties.farClipDistance);
storage.set<Ogre::Degree>("fovY", m_properties.fovY);
storage.set<Ogre::Real>("nearClipDistance", m_properties.nearClipDistance);
storage.set<int16_t>("polygonMode", m_properties.polygonMode);
return storage;
}
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
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
CompoundBagComponent::storage() const
{
StorageContainer storage = Component::storage();
StorageContainer amounts;
StorageContainer prices;
StorageContainer uninflatedPrices;
StorageContainer demand;
for (auto entry : this->compounds) {
CompoundId id = entry.first;
CompoundData data = entry.second;
amounts.set<double>(""+id, data.amount);
amounts.set<double>(""+id, data.price);
amounts.set<double>(""+id, data.uninflatedPrice);
amounts.set<double>(""+id, data.demand);
}
storage.set("amounts", std::move(amounts));
storage.set("prices", std::move(prices));
storage.set("uninflatedPrices", std::move(uninflatedPrices));
storage.set("demand", std::move(demand));
storage.set("speciesName", this->speciesName);
storage.set("storageSpace", this->storageSpace);
return storage;
}
StorageContainer
Sound::storage() const {
StorageContainer storage;
storage.set("filename", m_filename);
storage.set("name", m_name);
storage.set<int16_t>("playState", m_properties.playState);
storage.set("loop", m_properties.loop);
storage.set("volume", m_properties.volume);
storage.set("maxDistance", m_properties.maxDistance);
storage.set("rolloffFactor", m_properties.rolloffFactor);
storage.set("referenceDistance", m_properties.referenceDistance);
storage.set("priority", m_properties.priority);
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;
}
void
EntityManager::restore(
const StorageContainer& storage,
const ComponentFactory& factory
) {
this->clear();
// Current Id
m_impl->m_currentId = storage.get<EntityId>("currentId");
// Named entities
StorageList namedIds = storage.get<StorageList>("namedIds");
for (const auto& entry : namedIds) {
std::string name = entry.get<std::string>("name");
EntityId id = entry.get<EntityId>("entityId");
m_impl->m_namedIds[name] = id;
}
// Collections
StorageContainer collections = storage.get<StorageContainer>("collections");
auto typeNames = collections.keys();
for (const std::string& typeName : typeNames) {
StorageList componentList = collections.get<StorageList>(typeName);
for (const StorageContainer& componentStorage : componentList) {
auto component = factory.load(typeName, componentStorage);
EntityId owner = component->owner();
if (owner == NULL_ENTITY) {
std::cerr << "Component with no entity: " << typeName << std::endl;
}
this->addComponent(owner, std::move(component));
}
}
// Components to remove
StorageList componentsToRemove = storage.get<StorageList>("componentsToRemove");
for (const StorageContainer& entry : componentsToRemove) {
EntityId entityId = entry.get<EntityId>("entityId");
std::string typeName = entry.get<std::string>("componentTypeName");
ComponentTypeId typeId = factory.getTypeId(typeName);
this->removeComponent(entityId, typeId);
}
// Entities to remove
StorageList entitiesToRemove = storage.get<StorageList>("entitiesToRemove");
for (const auto& entry : entitiesToRemove) {
EntityId entityId = entry.get<EntityId>("id");
this->removeEntity(entityId);
}
}
StorageContainer
OgreViewportComponent::storage() const {
StorageContainer storage = Component::storage();
storage.set("backgroundColour", m_properties.backgroundColour);
storage.set("cameraEntity", m_properties.cameraEntity);
storage.set("height", m_properties.height);
storage.set("left", m_properties.left);
storage.set("top", m_properties.top);
storage.set("width", m_properties.width);
storage.set("zOrder", m_zOrder);
return storage;
}
void
SaveSystem::update(int) {
StorageContainer entities;
try {
entities = this->engine()->entityManager().storage(
this->engine()->componentFactory()
);
}
catch (const luabind::error& e) {
luabind::object error_msg(luabind::from_stack(
e.state(),
-1
));
// TODO: Log error
std::cerr << error_msg << std::endl;
throw;
}
StorageContainer savegame;
savegame.set("entities", std::move(entities));
std::ofstream stream(m_impl->m_filename, std::ofstream::trunc | std::ofstream::binary);
stream.exceptions(std::ofstream::failbit | std::ofstream::badbit);
if (stream) {
try {
stream << savegame;
stream.flush();
stream.close();
}
catch (const std::ofstream::failure& e) {
std::cerr << "Error saving file: " << e.what() << std::endl;
throw;
}
}
else {
std::perror("Could not open file for saving");
}
this->setActive(false);
}
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;
}
