/* virtual */
void
Button::Draw()
{
if (fResource == NULL)
return;
try {
IE::button* button = (IE::button*)fControl;
const Bitmap* frame;
// TODO: Seems enabled and selected aren't used
if (!fEnabled)
frame = fResource->FrameForCycle(button->cycle, button->frame_disabled);
else if (fPressed)
frame = fResource->FrameForCycle(button->cycle, button->frame_pressed);
/*else if (fSelected)
frame = fResource->FrameForCycle(button->cycle, button->frame_selected);
*/
else
frame = fResource->FrameForCycle(button->cycle, button->frame_unpressed);
if (frame != NULL) {
GFX::rect destRect(sint16(fControl->x), sint16(fControl->y),
uint16(fControl->w), uint16(fControl->h));
fWindow->ConvertToScreen(destRect);
GraphicsEngine::Get()->BlitToScreen(frame, NULL, &destRect);
//frame->Release();
}
} catch (...) {
}
Control::Draw();
}
void NetGameSettings::Unpacketize(uint16 id, uint8 *buf, uint16 size)
{
uint16 packid;
uint16 pos = 0;
uint32 playerMask;
PULLID(packid);
Assert(packid == k_PACKET_GAME_SETTINGS_ID);
PULLLONG(m_x);
PULLLONG(m_y);
PULLLONG(m_numPlayers);
PULLBYTE(m_gameStyle);
PULLLONG(m_movesPerSlice);
PULLLONG(m_totalTime);
PULLLONG(m_turnTime);
PULLLONG(m_cityTime);
PULLLONG(playerMask);
PULLLONG(g_theGameSettings->m_difficulty);
PULLLONG(g_theGameSettings->m_risk);
PULLLONG(g_theGameSettings->m_alienEndGame);
PULLLONG(g_theGameSettings->m_pollution);
BOOL isYwrap, isXwrap;
PULLLONG(isYwrap);
PULLLONG(isXwrap);
Assert(pos == size);
if(g_controlPanel) {
}
g_tiledMap->CopyVision();
for(sint32 p = 0; p < k_MAX_PLAYERS; p++) {
if(g_player[p]) {
g_player[p]->m_all_armies->FastKillList();
g_player[p]->GetAllUnitList()->FastKillList();
g_player[p]->GetAllCitiesList()->FastKillList();
g_player[p]->GetTradersList()->FastKillList();
g_player[p]->m_vision->Clear();
}
}
g_theUnitTree->Clear();
g_theInstallationTree->Clear();
delete g_theUnitTree;
g_theUnitTree = NULL;
delete g_theInstallationTree;
g_theInstallationTree = NULL;
g_network.ClearDeadUnits();
g_theWorld->Reset(sint16(m_x), sint16(m_y), isYwrap, isXwrap);
sint32 i;
for(i = 0; i < k_MAX_PLAYERS; i++) {
if(g_player[i]) {
delete g_player[i];
}
}
delete [] g_player;
g_player = new Player *[k_MAX_PLAYERS];
for(i = 0; i < k_MAX_PLAYERS; i++) {
g_player[i] = NULL;
}
for(i = 0; i < k_MAX_PLAYERS; i++) {
if(playerMask & (1 << i)) {
g_player[i] = new Player(i, 0, PLAYER_TYPE_HUMAN);
}
}
delete g_selected_item;
g_selected_item = new SelectedItem(m_numPlayers);
g_theUnitTree = new QuadTree<Unit>((sint16)g_theWorld->GetXWidth(),
(sint16)g_theWorld->GetYHeight(),
g_theWorld->IsYwrap());
g_theInstallationTree = new InstallationQuadTree((sint16)g_theWorld->GetXWidth(),
(sint16)g_theWorld->GetYHeight(),
g_theWorld->IsYwrap());
g_network.SetStyleFromServer(m_gameStyle, m_movesPerSlice, m_totalTime, m_turnTime, m_cityTime);
g_tiledMap->CopyVision();
gameinit_ResetForNetwork();
g_network.SetLoop(TRUE);
}
bool Load()
{
TDFParser cfgFile;
if (!cfgFile.loadFromFile(TA3D::Paths::ConfigFile,false,false,false,true)) // Load this from real file system since it has nothing to do with game content
{
LOG_ERROR(LOG_PREFIX_SETTINGS << "Impossible to load the settings from `" << TA3D::Paths::ConfigFile << "`");
lp_CONFIG->Lang = "english"; // Set default language to English
lp_CONFIG->first_start = true; // No config file -> guess best settings
// Apply settings for the current language
I18N::Instance()->currentLanguage(lp_CONFIG->Lang);
return false;
}
TA3D::VARS::lp_CONFIG->fps_limit = cfgFile.pullAsFloat("TA3D.FPS Limit");
TA3D::VARS::lp_CONFIG->timefactor = cfgFile.pullAsFloat("TA3D.Time Factor");
TA3D::VARS::lp_CONFIG->shadow_quality = sint16(cfgFile.pullAsInt("TA3D.Shadow Quality"));
TA3D::VARS::lp_CONFIG->shadowmap_size = uint8(cfgFile.pullAsInt("TA3D.ShadowMap Size", 2));
TA3D::VARS::lp_CONFIG->priority_level = sint16(cfgFile.pullAsInt("TA3D.Priority Level"));
TA3D::VARS::lp_CONFIG->fsaa = sint16(cfgFile.pullAsInt("TA3D.FSAA"));
TA3D::VARS::lp_CONFIG->anisotropy = sint16(cfgFile.pullAsInt("TA3D.Anisotropy", 1));
TA3D::VARS::lp_CONFIG->Lang = cfgFile.pullAsString("TA3D.Language").toLower();
TA3D::VARS::lp_CONFIG->water_quality = sint16(cfgFile.pullAsInt("TA3D.Water Quality"));
TA3D::VARS::lp_CONFIG->screen_width = uint16(cfgFile.pullAsInt("TA3D.Screen Width"));
TA3D::VARS::lp_CONFIG->screen_height = uint16(cfgFile.pullAsInt("TA3D.Screen Height"));
TA3D::VARS::lp_CONFIG->color_depth = uint8(cfgFile.pullAsInt("TA3D.Color Depth", 32));
TA3D::VARS::lp_CONFIG->showfps = cfgFile.pullAsBool("TA3D.Show FPS");
TA3D::VARS::lp_CONFIG->wireframe = cfgFile.pullAsBool("TA3D.Show Wireframe");
TA3D::VARS::lp_CONFIG->explosion_particles = cfgFile.pullAsBool("TA3D.Show explosion particles", true);
TA3D::VARS::lp_CONFIG->particle = cfgFile.pullAsBool("TA3D.Show particles");
TA3D::VARS::lp_CONFIG->waves = cfgFile.pullAsBool("TA3D.Show Waves");
TA3D::VARS::lp_CONFIG->height_line = cfgFile.pullAsBool("TA3D.Show Height Lines");
TA3D::VARS::lp_CONFIG->fullscreen = cfgFile.pullAsBool("TA3D.Show FullScreen", false);
TA3D::VARS::lp_CONFIG->detail_tex = cfgFile.pullAsBool("TA3D.Detail Texture");
TA3D::VARS::lp_CONFIG->draw_console_loading = cfgFile.pullAsBool("TA3D.Draw Console Loading");
TA3D::VARS::lp_CONFIG->tooltips = cfgFile.pullAsBool("TA3D.Tooltips");
TA3D::VARS::lp_CONFIG->serializedGameData = cfgFile.pullAsString("TA3D.Game Data", String());
TA3D::VARS::lp_CONFIG->last_MOD = cfgFile.pullAsString("TA3D.Last MOD", "");
TA3D::VARS::lp_CONFIG->camera_zoom = uint8(cfgFile.pullAsInt("TA3D.Camera Zoom Mode", ZOOM_NORMAL));
TA3D::VARS::lp_CONFIG->camera_def_angle = cfgFile.pullAsFloat("TA3D.Camera Default Angle", 63.44f);
TA3D::VARS::lp_CONFIG->camera_def_h = cfgFile.pullAsFloat("TA3D.Camera Default Height", 200.0f);
TA3D::VARS::lp_CONFIG->camera_zoom_speed = cfgFile.pullAsFloat("TA3D.Camera Zoom Speed", 1.0f);
TA3D::VARS::lp_CONFIG->menuTransparency = cfgFile.pullAsFloat("TA3D.Interface Transparency", 0.0f);
TA3D::VARS::lp_CONFIG->use_texture_cache = cfgFile.pullAsBool("TA3D.Use Texture Cache", false);
TA3D::VARS::lp_CONFIG->skin_name = cfgFile.pullAsString("TA3D.Skin", "");
TA3D::VARS::lp_CONFIG->net_server = cfgFile.pullAsString("TA3D.Net Server", TA3D_DEFAULT_SERVER_HOSTNAME);
TA3D::VARS::TA3D_CURRENT_MOD = TA3D::VARS::lp_CONFIG->last_MOD;
TA3D::VARS::lp_CONFIG->player_name = cfgFile.pullAsString("TA3D.Player name", "player");
TA3D::VARS::lp_CONFIG->render_sky = cfgFile.pullAsBool("TA3D.Render Sky", true);
TA3D::VARS::lp_CONFIG->low_definition_map = cfgFile.pullAsBool("TA3D.Low Definition Map", false);
TA3D::VARS::lp_CONFIG->use_texture_compression = cfgFile.pullAsBool("TA3D.Use Texture Compression", true);
TA3D::VARS::lp_CONFIG->underwater_bright = cfgFile.pullAsBool("TA3D.Underwater Bright", false);
TA3D::VARS::lp_CONFIG->disable_GLSL = cfgFile.pullAsBool("TA3D.Disable GLSL", false);
TA3D::VARS::lp_CONFIG->right_click_interface = cfgFile.pullAsBool("TA3D.Right Click Interface", false);
TA3D::VARS::lp_CONFIG->ortho_camera = cfgFile.pullAsBool("TA3D.Orthographic Camera", false);
TA3D::VARS::lp_CONFIG->mouse_sensivity = cfgFile.pullAsFloat("TA3D.Mouse Sensitivity", 1.0f);
TA3D::VARS::lp_CONFIG->far_sight = cfgFile.pullAsBool("TA3D.Far Sight", true);
TA3D::VARS::lp_CONFIG->sound_volume = cfgFile.pullAsInt("TA3D.Sound Volume", 128);
TA3D::VARS::lp_CONFIG->music_volume = cfgFile.pullAsInt("TA3D.Music Volume", 128);
TA3D::VARS::lp_CONFIG->grab_inputs = cfgFile.pullAsBool("TA3D.Grab Inputs", false);
TA3D::VARS::lp_CONFIG->system7zCommand = cfgFile.pullAsString("TA3D.7z command", "7z");
TA3D::VARS::lp_CONFIG->resourcePaths = cfgFile.pullAsString("TA3D.Resource Paths");
TA3D::VARS::lp_CONFIG->developerMode = cfgFile.pullAsBool("TA3D.Developer Mode");
TA3D::VARS::lp_CONFIG->unitTextureQuality = cfgFile.pullAsInt("TA3D.Texture Quality", 3);
String cfg_version = cfgFile.pullAsString("TA3D.Version");
String ref_version;
ref_version << TA3D_VERSION_HI << "." << TA3D_VERSION_LO;
if (cfg_version != ref_version) // Update ?
{
lp_CONFIG->net_server = TA3D_DEFAULT_SERVER_HOSTNAME;
if (cfg_version.empty()) // Pre-SDL versions
{
lp_CONFIG->first_start = true; // First start of a >= 0.6 release
lp_CONFIG->shadow_quality = sint16(cfgFile.pullAsInt("TA3D.Show Shadows"));
int langID = lp_CONFIG->Lang.to<int>(); // TA3D used to store language ID instead of language
switch( langID )
{
case 0: lp_CONFIG->Lang = "english"; break;
case 1: lp_CONFIG->Lang = "french"; break;
case 2: lp_CONFIG->Lang = "german"; break;
case 3: lp_CONFIG->Lang = "spanish"; break;
case 4: lp_CONFIG->Lang = "italian"; break;
case 5: lp_CONFIG->Lang = "japanese"; break;
default:
lp_CONFIG->Lang = "english";
};
}
}
// Apply settings for the current language
if (!lp_CONFIG->Lang.empty())
I18N::Instance()->currentLanguage(lp_CONFIG->Lang);
LOG_INFO(LOG_PREFIX_SETTINGS << "Loaded from `" << TA3D::Paths::ConfigFile << "`");
return true;
}
void GoalMapTarget::AddNewWanderGoals(AiMain *ai, const int points)
{
Assert(ai);
MapPointData pos;
MapPointData *map_size = ai->m_map->GetSize();
BOOL is_land;
sint32 pos_cont;
pos.z = 0;
Assert(points < (map_size->x * map_size->y));
GoalMapTarget *goal;
int misses = 0;
for (int count = 0; count < points && misses < 100*points; )
{
pos.x = sint16(ai->m_rand->Next((sint32) map_size->x));
pos.y = sint16(ai->m_rand->Next((sint32) map_size->y));
sint32 player_id;
uint32 a_id;
sint32 top_unit_type;
sint32 unit_num;
uint32 c_id;
BOOL unitVis;
BOOL cityVis;
BOOL mineVis;
sint32 WANDER_GOAL_hey_theres_is_an_army_here=0;
BOOL can_be_expelled;
ai->m_world->GetCellContents(&pos, &player_id,
&a_id, &top_unit_type, &unit_num, &c_id, &unitVis,
&cityVis, &mineVis, &can_be_expelled);
if ((a_id != 0) && !can_be_expelled) {
if (ai->m_my_player_id != player_id) {
continue;
}
} else if (c_id != 0) {
if (ai->m_my_player_id != player_id) {
continue;
}
}
ai->m_continents->GetContinent(ai, pos, pos_cont, is_land);
if (is_land == TRUE)
{
goal = new GoalMapTarget(ai, pos, GOAL_TYPE_WANDER);
Assert(goal);
count++;
}
else
misses++;
}
Assert(misses < 100*points);
}
void Squad_Strength::AddArmies(const sint32 num)
{
Assert(0 < num);
m_army_count += sint16(num);
}
void Squad_Strength::SetRangeUnitCount(const sint32 n)
{
m_ranged_unit_count = sint16(n);
}
void Squad_Strength::SetTransports(const sint32 number_units_can_be_carried)
{
m_transport_capacity = sint16(number_units_can_be_carried);
Assert(m_transport_capacity >= 0);
}
void Squad_Strength::SetUnitCount(sint32 units)
{
m_unit_count = sint16(units);
}
void Squad_Strength::DelUnits(const sint32 num)
{
Assert(0 < num);
m_unit_count -= sint16(num);
}
AUI_ERRCODE aui_DirtyList::ComputeSpans( RECT *newRect )
{
Assert( newRect != NULL );
if ( !newRect ) return AUI_ERRCODE_HACK;
if (newRect->top < 0) newRect->top = 0;
if (newRect->left < 0) newRect->left = 0;
if (newRect->bottom >= m_height) newRect->bottom = m_height-1;
if (newRect->right >= m_width) newRect->right = m_width-1;
sint32 newStart = newRect->left;
sint32 newStop = newRect->right;
Assert( newStart <= newStop );
if ( newStart > newStop ) return AUI_ERRCODE_INVALIDPARAM;
if ( newStart == newStop ) return AUI_ERRCODE_OK;
sint32 h = newRect->bottom - newRect->top;
Assert( h >= 0 );
if ( h < 0 ) return AUI_ERRCODE_INVALIDPARAM;
if ( !h ) return AUI_ERRCODE_OK;
aui_SpanList *curSpanList = m_spanListArray + newRect->top;
for ( ; h; h--, curSpanList++ )
{
aui_Span *curSpan = curSpanList->spans;
BOOL consolidated = FALSE;
sint32 curStart = 0;
sint32 curStop = 0;
sint32 prevStop = 0;
sint32 s;
for ( s = curSpanList->num; s; s--, curSpan++ )
{
curStop = ( curStart = curStop + curSpan->run ) + curSpan->length;
if ( newStart <= curStop )
{
if ( newStop >= curStart )
{
newStart = newStart < curStart ? newStart : curStart;
newStop = newStop > curStop ? newStop : curStop;
if ( consolidated )
{
memmove( curSpan - 1, curSpan, s * sizeof( aui_Span ) );
curSpanList->num--;
curSpan--;
}
else
consolidated = TRUE;
curSpan->run = sint16(newStart - prevStop);
curSpan->length = sint16(newStop - newStart);
Assert( curSpan->run >= 0 );
Assert( curSpan->length > 0 );
}
else
{
if ( consolidated )
break;
if ( curSpanList->num < k_DIRTYLIST_MAXSPANS )
memmove( curSpan + 1, curSpan, s * sizeof( aui_Span ) );
s = 0;
break;
}
}
if ( !consolidated )
prevStop = curStop;
}
if ( !s && !consolidated )
{
if ( curSpanList->num == k_DIRTYLIST_MAXSPANS )
{
curSpanList->num = 1;
curSpan = curSpanList->spans;
if ( newStart < curSpan->run )
curSpan->run = (sint16)newStart;
curSpan->length = 0;
const aui_Span *pStop = curSpan + k_DIRTYLIST_MAXSPANS;
for ( aui_Span *p = curSpan; p != pStop; p++ )
curSpan->length += p->run + p->length;
if ( newStop > curSpan->length )
curSpan->length = (sint16)newStop;
curSpan->length -= curSpan->run;
}
else
{
curSpanList->num++;
curSpan->run = sint16(newStart - prevStop);
curSpan->length = sint16(newStop - newStart);
Assert( curSpan->run >= 0 );
Assert( curSpan->length > 0 );
}
}
}
m_isEmpty = FALSE;
return AUI_ERRCODE_OK;
}
bool Config::maySwitchToAnotherMenu()
{
if (lp_CONFIG->quickstart)
{
if (time_out || pArea->get_state("config_confirm.b_cancel_changes" ) || key[KEY_ESC])
{
I_Msg( TA3D::TA3D_IM_GUI_MSG, "config_confirm.hide");
TA3D::Settings::Restore(TA3D::Paths::ConfigFile);
TA3D::Settings::Load();
save = false;
lp_CONFIG->quickstart = false;
lp_CONFIG->quickrestart = true;
lp_CONFIG->restorestart = true;
*saved_config = *lp_CONFIG;
return true;
}
else
if (pArea->get_state("config_confirm.b_confirm"))
{
I_Msg( TA3D::TA3D_IM_GUI_MSG, "config_confirm.hide");
lp_CONFIG->quickstart = false;
saved_config->quickstart = false;
TA3D::Settings::Save(); // Keep settings :)
}
}
if (pArea->get_state( "*.b_activate"))
{
Gui::GUIOBJ::Ptr obj = pArea->get_object("*.l_files");
if (obj && obj->Text.size() > obj->Pos)
{
sound_manager->setPlayListFileMode( obj->Pos, false, false);
obj->Text[ obj->Pos ][ 1 ] = '*';
}
}
if (pArea->get_state( "*.b_deactivate"))
{
Gui::GUIOBJ::Ptr obj = pArea->get_object("*.l_files");
if (obj && obj->Text.size() > obj->Pos)
{
sound_manager->setPlayListFileMode( obj->Pos, false, true);
obj->Text[ obj->Pos ][ 1 ] = ' ';
}
}
if (pArea->get_state( "*.b_battle" ) )
{
Gui::GUIOBJ::Ptr obj = pArea->get_object("*.l_files");
if (obj && obj->Text.size() > obj->Pos)
{
sound_manager->setPlayListFileMode(obj->Pos, true, false);
obj->Text[ obj->Pos ][1] = 'B';
}
}
if (pArea->get_state("*.b_ok"))
{
save = true;
return true; // On "OK", leave the menu
}
if (pArea->get_state( "*.b_cancel" ) ) // On "cancel", leave
return true;
lp_CONFIG->showfps = pArea->get_state( "*.showfps");
if (pArea->get_value("*.fps_limit") >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object("*.fps_limit");
if (obj && obj->Data != uint32(-1))
{
obj->Text[0] = fps_limits[obj->Value];
switch (obj->Value)
{
case 0: lp_CONFIG->fps_limit = 50; break;
case 1: lp_CONFIG->fps_limit = 60; break;
case 2: lp_CONFIG->fps_limit = 70; break;
case 3: lp_CONFIG->fps_limit = 80; break;
case 4: lp_CONFIG->fps_limit = 90; break;
case 5: lp_CONFIG->fps_limit = 100; break;
default: lp_CONFIG->fps_limit = -1;
}
}
}
if (lp_CONFIG->grab_inputs != pArea->get_state("*.grab_inputs"))
{
lp_CONFIG->grab_inputs = pArea->get_state("*.grab_inputs");
grab_mouse(lp_CONFIG->grab_inputs);
}
if (lp_CONFIG->sound_volume != pArea->get_value("*.sound_volume"))
{
lp_CONFIG->sound_volume = pArea->get_value("*.sound_volume");
sound_manager->setVolume(lp_CONFIG->sound_volume);
}
if (lp_CONFIG->music_volume != pArea->get_value("*.music_volume"))
{
lp_CONFIG->music_volume = pArea->get_value("*.music_volume");
sound_manager->setMusicVolume(lp_CONFIG->music_volume);
}
lp_CONFIG->unitTextureQuality = pArea->get_value("*.texture_quality");
lp_CONFIG->menuTransparency = float(pArea->get_value("*.interface_transparency")) / 255.0f;
lp_CONFIG->shadowmap_size = uint8(pArea->get_value("*.shadow_map_size"));
lp_CONFIG->far_sight = pArea->get_state("*.far_sight");
lp_CONFIG->anisotropy = sint16(pArea->get_value("*.anisotropy"));
lp_CONFIG->mouse_sensivity = float(pArea->get_value("*.mouse_sensitivity")) * 0.01f;
lp_CONFIG->ortho_camera = pArea->get_state("*.disable_perspective");
lp_CONFIG->right_click_interface = pArea->get_state("*.right_click_interface");
lp_CONFIG->disable_GLSL = pArea->get_state("*.disable_GLSL");
lp_CONFIG->underwater_bright = pArea->get_state("*.underwater_bright");
lp_CONFIG->use_texture_compression = pArea->get_state("*.use_texture_compression");
lp_CONFIG->low_definition_map = pArea->get_state("*.low_definition_map");
lp_CONFIG->render_sky = pArea->get_state( "*.sky");
lp_CONFIG->particle = pArea->get_state( "*.particle");
lp_CONFIG->explosion_particles = pArea->get_state( "*.explosion_particles");
lp_CONFIG->waves = pArea->get_state( "*.waves");
lp_CONFIG->height_line = pArea->get_state( "*.height_line");
lp_CONFIG->detail_tex = pArea->get_state( "*.detail_tex");
lp_CONFIG->draw_console_loading = pArea->get_state( "*.draw_console_loading");
lp_CONFIG->fullscreen = pArea->get_state( "*.fullscreen");
lp_CONFIG->use_texture_cache = pArea->get_state( "*.use_texture_cache");
lp_CONFIG->developerMode = pArea->get_state("*.developer_mode");
lp_CONFIG->tooltips = pArea->get_state("*.tool_tips");
if (pArea->get_value( "*.camera_zoom" ) >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object( "*.camera_zoom");
if (obj && obj->Value >= -1)
{
obj->Text[0] = obj->Text[1 + obj->Value];
lp_CONFIG->camera_zoom = uint8(obj->Value);
}
}
if (pArea->get_value( "*.camera_def_angle" ) >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object( "*.camera_def_angle");
if (obj && obj->Value >= 0)
{
obj->Text[0] = obj->Text[ 1 + obj->Value ];
lp_CONFIG->camera_def_angle = obj->Text[0].to<float>();
}
}
if (pArea->get_value( "*.camera_def_h" ) >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object( "*.camera_def_h");
if (obj && obj->Value >= 0)
{
obj->Text[0] = obj->Text[1 + obj->Value];
lp_CONFIG->camera_def_h = obj->Text[0].to<float>();
}
}
if (pArea->get_value( "*.camera_zoom_speed" ) >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object( "*.camera_zoom_speed");
if (obj && obj->Value >= 0)
{
obj->Text[0] = obj->Text[ 1 + obj->Value ];
lp_CONFIG->camera_zoom_speed = obj->Text[0].to<float>();
}
}
if (pArea->get_value( "*.LANG" ) >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object( "*.LANG");
if (obj && obj->Value != -1)
{
obj->Text[0] = obj->Text[1 + obj->Value];
lp_CONFIG->Lang = languageList[obj->Value].englishCaption();
}
}
if (pArea->get_value("*.screenres") >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object( "*.screenres");
if (obj && obj->Value != -1)
{
obj->Text[0] = obj->Text[ 1 + obj->Value ];
lp_CONFIG->screen_width = uint16(res_width[ obj->Value ]);
lp_CONFIG->screen_height = uint16(res_height[ obj->Value ]);
lp_CONFIG->color_depth = uint8(res_bpp[ obj->Value ]);
}
}
if (pArea->get_value("*.shadow_quality") >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object("*.shadow_quality");
if (obj && obj->Value != -1)
{
obj->Text[0] = obj->Text[1 + obj->Value];
lp_CONFIG->shadow_quality = sint16(obj->Value);
}
}
if (pArea->get_value("*.timefactor") >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object( "*.timefactor");
if (obj && obj->Value != -1)
{
obj->Text[0] = obj->Text[ 1 + obj->Value ];
lp_CONFIG->timefactor = float(obj->Value + 1);
}
}
if (pArea->get_value( "*.fsaa" ) >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object( "*.fsaa");
if (obj && obj->Value != -1)
{
obj->Text[0] = obj->Text[ 1 + obj->Value ];
lp_CONFIG->fsaa = sint16(obj->Value << 1);
}
}
if (pArea->get_value("*.water_quality") >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object("*.water_quality");
if (obj && obj->Value != -1)
{
obj->Text[0] = obj->Text[ 1 + obj->Value ];
lp_CONFIG->water_quality = sint16(obj->Value);
}
}
if (pArea->get_value("*.mod") >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object( "*.mod");
if (obj && obj->Value != -1)
{
obj->Text[0] = obj->Text[ 1 + obj->Value];
lp_CONFIG->last_MOD = obj->Value > 0 ? String("mods/") << obj->Text[0] << '/' : String();
}
}
if (pArea->get_value( "*.skin" ) >= 0)
{
Gui::GUIOBJ::Ptr obj = pArea->get_object( "*.skin");
if (obj && obj->Value != -1)
{
obj->Text[0] = obj->Text[1 + obj->Value];
lp_CONFIG->skin_name = obj->Value >= 0 ? String("gui/") << obj->Text[0] : String();
}
}
if (key[KEY_ESC]) // Leave menu on ESC
return true;
return false;
}
//----------------------------------------------------------------------------
//
// Name : UnseenCell::UnseenCell
//
// Description: Constructor
//
// Parameters : point : The point (RC coordinate)
//
// Globals : g_theWorld : World information
//
// Returns : -
//
// Remark(s) : The constructor to use normally.
//
//----------------------------------------------------------------------------
UnseenCell::UnseenCell(const MapPoint & point)
:
m_env (0),
m_terrain_type (TERRAIN_UNKNOWN),
m_move_cost (MOVECOST_UNKNOWN),
m_flags (0x0000),
m_bioInfectedOwner (0x00), /// @todo Check PLAYER_UNASSIGNED?
m_nanoInfectedOwner (0x00),
m_convertedOwner (0x00),
m_franchiseOwner (0x00),
m_injoinedOwner (0x00),
m_happinessAttackOwner (0x00),
m_citySize (0),
m_cityOwner (0),
m_citySpriteIndex (-1),
m_cell_owner (PLAYER_UNASSIGNED),
m_slaveBits (0x0000),
#ifdef BATTLE_FLAGS
m_battleFlags (0),
#endif
m_tileInfo (NULL),
m_point (point),
m_installations (new PointerList<UnseenInstallationInfo>),
m_improvements (new PointerList<UnseenImprovementInfo>),
m_cityName (NULL),
m_actor (NULL),
m_poolIndex (-1),
m_visibleCityOwner (0)
{
if (g_theWorld->GetTileInfo(point))
{
m_tileInfo = new TileInfo(g_theWorld->GetTileInfo(point));
}
Cell * cell = g_theWorld->GetCell(point);
if (cell)
{
m_env = cell->GetEnv();
m_move_cost = sint16(cell->GetMoveCost());
m_terrain_type = (sint8)TERRAIN_TYPES(cell->GetTerrain());
#ifdef BATTLE_FLAGS
m_battleFlags = cell->GetBattleFlags();
#endif
sint32 i;
// Same as well information about existing
// tile improvments, except roadlike ones,
// so that this information is available
// later as well.
// And in order not to break anythink use the existing
// list for unfinished tile improvements.
for(i = 0; i < cell->GetNumDBImprovements(); i++) {
sint32 imp = cell->GetDBImprovement(i);
m_improvements->AddTail(new UnseenImprovementInfo(imp, 100));
}
for(i = 0; i < cell->GetNumImprovements(); i++) {
TerrainImprovement imp = cell->AccessImprovement(i);
if (imp.IsValid())
{
m_improvements->AddTail(new UnseenImprovementInfo(imp.GetType(),
imp.PercentComplete()));
}
}
DynamicArray<Installation> instArray;
g_theInstallationTree->GetAt(point, instArray);
for(i = 0; i < instArray.Num(); i++) {
m_installations->AddTail(new UnseenInstallationInfo(instArray[i].GetType(),
instArray[i].GetVisibility()));
}
m_cell_owner = (sint8) cell->GetOwner();
// Store the city that controlls this tile.
m_visibleCityOwner = cell->GetCityOwner().m_id;
Unit city = cell->GetCity();
if (city.IsValid())
{
m_citySize = (sint16)city.PopCount();
m_citySpriteIndex = (sint16)city.CD()->GetDesiredSpriteIndex();
const MBCHAR *name = city.GetName();
m_cityName = new MBCHAR[strlen(name) + 1];
strcpy(m_cityName, name);
m_cityOwner = static_cast<sint16>(city.GetCityData()->GetOwner());
CityData *cityData = city.GetData()->GetCityData();
UnitActor *actor = city.GetActor();
if (actor) {
SpriteState *newSS = new SpriteState(city.GetSpriteState()->GetIndex());
UnitActor *newActor = new UnitActor(newSS,
city,
city.GetType(),
point,
city.GetOwner(),
TRUE,
city.GetVisionRange(),
city.CD()->GetDesiredSpriteIndex());
newActor->SetUnitVisibility((1 << g_selected_item->GetVisiblePlayer())
| actor->GetUnitVisibility());
newActor->SetPos(point);
newActor->SetIsFortified(actor->IsFortified());
newActor->SetIsFortifying(actor->IsFortifying());
newActor->SetHasCityWalls(actor->HasCityWalls());
newActor->SetHasForceField(actor->HasForceField());
newActor->SetSize(m_citySize);
newActor->ChangeImage(newSS, city.GetType(), city);
newActor->AddIdle();
newActor->GetNextAction();
m_actor = newActor;
} // actor
SetIsBioInfected(cityData->IsBioInfected());
SetIsNanoInfected(cityData->IsNanoInfected());
SetIsConverted(cityData->IsConverted());
SetIsFranchised(cityData->IsFranchised());
SetIsInjoined(cityData->IsInjoined());
SetWasHappinessAttacked(cityData->WasHappinessAttacked());
SetIsRioting(cityData->GetIsRioting());
SetHasAirport(cityData->HasAirport());
SetHasSleepingUnits(cityData->HasSleepingUnits());
SetIsWatchful(cityData->IsWatchful());
SetIsCapitol(cityData->IsCapitol()); //emod
SetIsReligionIcon(cityData->HasReligionIcon()); //emod
m_bioInfectedOwner = (sint8)cityData->GetBioInfectedBy();
m_nanoInfectedOwner = (sint8)cityData->GetNanoInfectedBy();
m_convertedOwner = (sint8)cityData->IsConvertedTo();
m_franchiseOwner = (sint8)cityData->GetFranchiseOwner();
m_injoinedOwner = (sint8)cityData->InjoinedBy();
m_happinessAttackOwner = (sint8)cityData->GetHappinessAttackedBy();
m_slaveBits = cityData->GetSlaveBits();
SetIsSpecialIcon(cityData->HasSpecialIcon()); //emod
sint32 pollution = cityData->GetPollution();
SetIsPollutionRisk(pollution > g_theConstDB->Get(0)->GetLocalPollutionLevel());
} // city.IsValid
} // cell
SetHasHut(NULL != g_theWorld->GetGoodyHut(point));
}
void World::ClipGF(sint16 **tmp_map)
{
MapPoint pos;
MapPoint w;
sint16 v;
sint16 threshold_min = 1;
sint16 threshold_max = 1;
sint32 count = 0;
for (pos.x=0; pos.x<m_size.x; pos.x++) {
for (pos.y=0; pos.y<m_size.y; pos.y++) {
sint16 curr = tmp_map[pos.x][pos.y];
if ((1 == curr)) {
count=0;
if(pos.GetNeighborPosition(NORTHEAST, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (0 == v) count++;
}
if(pos.GetNeighborPosition(NORTHWEST, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (0 == v) count++;
}
if(pos.GetNeighborPosition(SOUTHWEST, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (0 == v) count++;
}
if(pos.GetNeighborPosition(SOUTHEAST, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (0 == v) count++;
}
if (3 == count) {
curr = -curr;
tmp_map[pos.x][pos.y] = curr;
}
}
}
}
for (pos.x=0; pos.x<m_size.x; pos.x++) {
for (pos.y=0; pos.y<m_size.y; pos.y++) {
if (tmp_map[pos.x][pos.y] < 0) {
tmp_map[pos.x][pos.y] = 0;
}
}
}
bool going_up = false;
for (pos.x=0; pos.x<m_size.x; pos.x++) {
for (pos.y=0; pos.y<m_size.y; pos.y++) {
sint16 curr = tmp_map[pos.x][pos.y];
if ((threshold_min <= curr) && (curr <= threshold_max)) {
if(pos.GetNeighborPosition(SOUTHEAST, w)) {
count = 0;
v = tmp_map[w.x][w.y];
going_up = v < threshold_min;
}
if(pos.GetNeighborPosition(EAST, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (going_up) {
if (threshold_max <= v) {
going_up = false;
count++;
}
} else {
if (v < threshold_min) {
going_up = true;
count++;
}
}
}
if(pos.GetNeighborPosition(NORTHEAST, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (going_up) {
if (threshold_max <= v) {
going_up = false;
count++;
}
} else {
if (v < threshold_min) {
going_up = true;
count++;
}
}
}
if(pos.GetNeighborPosition(NORTH, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (going_up) {
if (threshold_max <= v) {
going_up = false;
count++;
}
} else {
if (v < threshold_min) {
going_up = true;
count++;
}
}
}
if(pos.GetNeighborPosition(NORTHWEST, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (going_up) {
if (threshold_max <= v) {
going_up = false;
count++;
}
} else {
if (v < threshold_min) {
going_up = true;
count++;
}
}
}
if(pos.GetNeighborPosition(WEST, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (going_up) {
if (threshold_max <= v) {
going_up = false;
count++;
}
} else {
if (v < threshold_min) {
going_up = true;
count++;
}
}
}
if(pos.GetNeighborPosition(SOUTHWEST, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (going_up) {
if (threshold_max <= v) {
going_up = false;
count++;
}
} else {
if (v < threshold_min) {
going_up = true;
count++;
}
}
}
if(pos.GetNeighborPosition(SOUTH, w)) {
v = sint16(abs(tmp_map[w.x][w.y]));
if (going_up) {
if (threshold_max <= v) {
going_up = false;
count++;
}
} else {
if (v < threshold_min) {
going_up = true;
count++;
}
}
}
if (count < 3) {
curr = -curr;
tmp_map[pos.x][pos.y] = curr;
}
} else {
curr = -curr;
tmp_map[pos.x][pos.y] = curr;
}
}
}
}
