#include "Internal.h"

#include "modules/World.h"

#include "df/block_square_event_world_constructionst.h"

#include "df/map_block.h"

#include "df/plotinfost.h"

#include "df/world.h"

using std::string;

using namespace DFHack;

using namespace df::enums;

using df::global::plotinfo;

using df::global::world;

bool World::ReadPauseState()

{

return DF_GLOBAL_VALUE(pause_state, false);

}

void World::SetPauseState(bool paused)

}

uint32_t World::ReadCurrentYear()

{

return DF_GLOBAL_VALUE(cur_year, 0);

}

uint32_t World::ReadCurrentTick()

}

bool World::ReadGameMode(t_gamemodes& rd)

}

bool World::WriteGameMode(const t_gamemodes & wr)

}

uint32_t World::ReadCurrentMonth()

{

return ReadCurrentTick() / 1200 / 28;

}

uint32_t World::ReadCurrentDay()

{

return ((ReadCurrentTick() / 1200) % 28) + 1;

}

uint8_t World::ReadCurrentWeather()

}

void World::SetCurrentWeather(uint8_t weather)

}

string World::ReadWorldFolder()

{

return world->cur_savegame.save_dir;

}

bool World::isFortressMode(df::game_type t)

}

bool World::isAdventureMode(df::game_type t)

}

bool World::isArena(df::game_type t)

}

bool World::isLegends(df::game_type t)

}

int32_t World::GetCurrentSiteId() {

}

bool World::IsSiteLoaded() {

return GetCurrentSiteId() != -1;

}

PersistentDataItem World::AddPersistentEntityData(int entity_id, const std::string &key) {

return Persistence::addItem(entity_id, key);

}

PersistentDataItem World::AddPersistentWorldData(const std::string &key) {

return AddPersistentEntityData(Persistence::WORLD_ENTITY_ID, key);

}

PersistentDataItem World::AddPersistentSiteData(const std::string &key) {

return AddPersistentEntityData(GetCurrentSiteId(), key);

}

PersistentDataItem World::GetPersistentEntityData(int entity_id, const std::string &key, bool create) {

bool added = false;

return create ? Persistence::getByKey(entity_id, key, &added) : Persistence::getByKey(entity_id, key);

}

PersistentDataItem World::GetPersistentWorldData(const std::string &key, bool create) {

return GetPersistentEntityData(Persistence::WORLD_ENTITY_ID, key, create);

}

PersistentDataItem World::GetPersistentSiteData(const std::string &key, bool create) {

return GetPersistentEntityData(GetCurrentSiteId(), key, create);

}

void World::GetPersistentEntityData(std::vector<PersistentDataItem> *vec, int entity_id, const std::string &key, bool prefix) {

}

void World::GetPersistentWorldData(std::vector<PersistentDataItem> *vec, const std::string &key, bool prefix) {

GetPersistentEntityData(vec, Persistence::WORLD_ENTITY_ID, key, prefix);

}

void World::GetPersistentSiteData(std::vector<PersistentDataItem> *vec, const std::string &key, bool prefix) {

GetPersistentEntityData(vec, GetCurrentSiteId(), key, prefix);

}

bool World::DeletePersistentData(const PersistentDataItem &item) {

return Persistence::deleteItem(item);

}

df::tile_bitmask *World::getPersistentTilemask(PersistentDataItem &item, df::map_block *block, bool create) {

if (!block)

return NULL;

int id = item.fake_df_id();

if (id > -100)

return NULL;

for (size_t i = 0; i < block->block_events.size(); i++)

{

auto ev = block->block_events[i];

if (ev->getType() != block_square_event_type::world_construction)

continue;

auto wcsev = strict_virtual_cast<df::block_square_event_world_constructionst>(ev);

if (!wcsev || wcsev->construction_id != id)

continue;

return &wcsev->tile_bitmask;

}

if (!create)

return NULL;

auto ev = df::allocate<df::block_square_event_world_constructionst>();

if (!ev)

return NULL;

ev->construction_id = id;

ev->tile_bitmask.clear();

vector_insert_at(block->block_events, 0, (df::block_square_event*)ev);

return &ev->tile_bitmask;

}

bool World::deletePersistentTilemask(PersistentDataItem &item, df::map_block *block) {

}