void Game::load(std::string filename)
{
StringHelper::debug( 0xff, "Load game begin" );
_d->empire->initialize( GameSettings::rcpath( GameSettings::citiesModel ) );
GameLoader loader;
_d->loadOk = loader.load( filename, *this);
if( !_d->loadOk )
{
StringHelper::debug( 0xff, "LOADING ERROR: can't load game from %s", filename.c_str() );
return;
}
_d->empire->initPlayerCity( _d->city.as<EmpireCity>() );
LandOverlayList& llo = _d->city->getOverlayList();
foreach( LandOverlayPtr overlay, llo )
{
ConstructionPtr construction = overlay.as<Construction>();
if( construction.isValid() )
{
construction->computeAccessRoads();
}
}
void Build::drawTile( const RenderInfo& rinfo, Tile& tile )
{
__D_IMPL(_d,Build);
ConstructionPtr cntr = tile.overlay<Construction>();
city::AreaInfo info( _city(), tile.epos(), &_d->buildTiles );
const Picture* picBasic = 0;
const Picture* picOver = 0;
if( cntr.isValid() && info.tiles().size() > 0 )
{
picBasic = &cntr->picture();
picOver = &cntr->picture( info );
}
if( picOver && picBasic != picOver )
{
Point screenPos = tile.mappos() + rinfo.offset;
drawLandTile( rinfo, tile );
rinfo.engine.draw( *picOver, screenPos );
drawPass( rinfo, tile, Renderer::overlayAnimation );
}
else if( _d->lastLayer.isValid() )
{
_d->lastLayer->drawTile( rinfo, tile );
}
else
{
Layer::drawTile( rinfo, tile );
}
if( !_d->overdrawBuilding )
_tryDrawBuildTile( rinfo, tile );
}
void ShowTileInfo::_exec(Game& game, unsigned int time)
{
switch( _mode )
{
case current:
break;
case next:
case prew:
{
city::Helper helper( game.city() );
ConstructionPtr c = ptr_cast<Construction>( game.city()->getOverlay( _pos ) );
c = (_mode == next ? helper.next( c ) : helper.prew( c ));
if( c.isValid() )
{
_pos = c->pos();
GameEventPtr e = MoveCamera::create( _pos );
e->dispatch();
}
}
break;
default:
break;
}
gui::infobox::Manager::getInstance().showHelp( game.city(), game.gui(), _pos );
}
void Build::_buildAll()
{
__D_REF(d,Build);
auto command = d.renderer->mode().as<BuildMode>();
if( command.isNull() )
return;
ConstructionPtr construction = command->contruction();
if( !construction.isValid() )
{
Logger::warning( "LayerBuild: No construction for build" );
return;
}
if( !_city()->treasury().haveMoneyForAction( 1 ) )
{
events::dispatch<WarningMessage>( "##out_of_credit##", 2 );
return;
}
bool buildOk = false;
bool tileBusyBuilding = false;
city::AreaInfo areaInfo( _city(), TilePos() );
for( auto tile : d.buildTiles )
{
areaInfo.pos = tile->epos();
tileBusyBuilding |= tile->overlay().is<Building>();
if( construction->canBuild( areaInfo ) && tile->isMaster())
{
events::dispatch<BuildAny>( tile->epos(), construction->type() );
buildOk = true;
events::dispatch<UndoAction>( UndoAction::built, construction->type(),
tile->epos(), construction->info().cost() );
}
}
d.startTilePos = d.lastTilePos;
if( !buildOk )
{
std::string errorStr = construction->errorDesc();
std::string busyText = tileBusyBuilding
? "##need_build_on_free_area##"
: "##need_build_on_cleared_area##";
events::dispatch<WarningMessage>( errorStr.empty() ? busyText : errorStr,
WarningMessage::neitral );
}
d.needUpdateTiles = true;
}
void Build::_drawBuildTile( const RenderInfo& rinfo, Tile* tile)
{
if( tile == nullptr )
return;
__D_IMPL(_d,Build);
city::AreaInfo areaInfo( _city(), TilePos(), &_d->buildTiles );
Tile* postTile = tile;
postTile->resetRendered();
if( postTile->master() )
postTile = postTile->master();
ConstructionPtr construction = postTile->overlay<Construction>();
rinfo.engine.resetColorMask();
areaInfo.pos = postTile->epos();
bool maskSet = false;
Size size(1,1);
if( construction.isValid() && construction->canBuild( areaInfo ) )
{
rinfo.engine.setColorMask( 0x00000000, 0x0000ff00, 0, 0xff000000 );
maskSet = true;
size = construction->size();
}
if( postTile == tile && maskSet )
{
TilesArray area = _city()->tilemap().area( areaInfo.pos, size );
for( auto gtile : area )
drawLandTile( rinfo, *gtile );
}
drawLandTile( rinfo, *postTile );
if( maskSet )
{
const Picture& picOver = construction->picture( areaInfo );
rinfo.engine.draw( picOver, postTile->mappos() + rinfo.offset );
drawPass( rinfo, *postTile, Renderer::overlayAnimation );
rinfo.engine.resetColorMask();
}
}
void BuildAny::_exec( Game& game, unsigned int )
{
if( _overlay.isNull() )
return;
TileOverlayPtr ctOv = game.city()->getOverlay( _pos );
bool mayBuild = true;
if( ctOv.isValid() )
{
mayBuild = ctOv->isDestructible();
}
city::Helper helper( game.city() );
TilePos offset(10, 10);
EnemySoldierList enemies = helper.find<EnemySoldier>( walker::any, _pos - offset, _pos + offset );
if( !enemies.empty() && _overlay->group() != objects::disasterGroup )
{
GameEventPtr e = WarningMessage::create( "##too_close_to_enemy_troops##" );
e->dispatch();
return;
}
if( !_overlay->isDeleted() && mayBuild )
{
CityAreaInfo info = { game.city(), _pos, TilesArray() };
bool buildOk = _overlay->build( info );
if( !buildOk )
return;
helper.updateDesirability( _overlay, city::Helper::onDesirability );
game.city()->addOverlay( _overlay );
ConstructionPtr construction = ptr_cast<Construction>( _overlay );
if( construction.isValid() )
{
const MetaData& buildingData = MetaDataHolder::getData( _overlay->type() );
game.city()->funds().resolveIssue( FundIssue( city::Funds::buildConstruction,
-(int)buildingData.getOption( MetaDataOptions::cost ) ) );
if( construction->group() != objects::disasterGroup )
{
GameEventPtr e = PlaySound::create( "buildok", 1, 100 );
e->dispatch();
}
if( construction->isNeedRoadAccess() && construction->getAccessRoads().empty() )
{
GameEventPtr e = WarningMessage::create( "##building_need_road_access##" );
e->dispatch();
}
std::string error = construction->errorDesc();
if( !error.empty() )
{
GameEventPtr e = WarningMessage::create( error );
e->dispatch();
}
WorkingBuildingPtr wb = ptr_cast<WorkingBuilding>( construction );
if( wb.isValid() && wb->maximumWorkers() > 0 )
{
unsigned int worklessCount = statistic::getWorklessNumber( game.city() );
if( worklessCount < wb->maximumWorkers() )
{
GameEventPtr e = WarningMessage::create( "##city_need_more_workers##" );
e->dispatch();
}
}
}
}
else
{
ConstructionPtr construction = ptr_cast<Construction>( _overlay );
if( construction.isValid() )
{
GameEventPtr e = WarningMessage::create( construction->errorDesc() );
e->dispatch();
}
}
}
bool Game::load(std::string filename)
{
Logger::warning( "Game: try load from " + filename );
Logger::warning( "Game: reseting variables" );
reset();
scene::SplashScreen screen;
screen.initialize();
bool usingOldgfx = SETTINGS_VALUE( oldgfx ) || !SETTINGS_VALUE( c3gfx ).toString().empty();
screen.setImage( usingOldgfx ? "load4" : "freska", 1 );
screen.update( *_d->engine );
vfs::Path fPath( filename );
if( !fPath.exist() )
{
Logger::warning( "Game: Cannot find file " + fPath.toString() );
fPath = game::Settings::rpath( filename );
if( !fPath.exist() )
{
Logger::warning( "Game: Cannot find file " + fPath.toString() );
Logger::warning( "Game: Try find file in resource's folder " );
fPath = game::Settings::rcpath( filename ).absolutePath();
if( !fPath.exist() )
{
Logger::warning( "Game: Cannot find file " + fPath.toString() );
return false;
}
}
}
Logger::warning( "Game: init empire start options" );
events::Dispatcher::instance().reset();
_d->empire->initialize( SETTINGS_RC_PATH( citiesModel ),
SETTINGS_RC_PATH( empireObjectsModel ),
SETTINGS_RC_PATH( worldModel ) );
Logger::warning( "Game: try find loader" );
game::Loader loader;
loader.onUpdate().connect( &screen, &scene::SplashScreen::setText );
bool loadOk = loader.load( fPath, *this );
if( !loadOk )
{
Logger::warning( "LOADING ERROR: can't load game from " + filename );
return false;
}
_d->restartFile = loader.restartFile();
Logger::warning( "Game: init player city" );
world::CityPtr city = _d->empire->initPlayerCity( ptr_cast<world::City>( _d->city ) );
if( city.isNull() )
{
Logger::warning( "INIT ERROR: can't initalize city %s in empire" + _d->city->name() );
return false;
}
_d->empire->emperor().checkCities();
Logger::warning( "Game: calculate road access for buildings" );
const OverlayList& llo = _d->city->overlays();
for( auto overlay : llo )
{
ConstructionPtr construction = overlay.as<Construction>();
if( construction.isValid() )
{
construction->computeRoadside();
}
}
Logger::warning( "Game: initialize local pathfinder" );
Pathfinder::instance().update( _d->city->tilemap() );
Logger::warning( "Game: load finished" );
screen.exitScene( scene::SplashScreen::hideDevText );
return true;
}
