void MessageWndEdit::FindGameWords() {
// add player and empire names
for (std::map<int, Empire*>::value_type& entry : Empires()) {
m_game_words.insert(entry.second->Name());
m_game_words.insert(entry.second->PlayerName());
}
// add system names
for (std::shared_ptr<System> system : GetUniverse().Objects().FindObjects<System>()) {
if (system->Name() != "")
m_game_words.insert(system->Name());
}
// add ship names
for (std::shared_ptr<Ship> ship : GetUniverse().Objects().FindObjects<Ship>()) {
if (ship->Name() != "")
m_game_words.insert(ship->Name());
}
// add ship design names
for (const auto& design : GetPredefinedShipDesignManager().GetOrderedShipDesigns()) {
if (!design->Name().empty())
m_game_words.insert(UserString(design->Name()));
}
// add specials names
for (const std::string& special_name : SpecialNames()) {
if (special_name != "")
m_game_words.insert(UserString(special_name));
}
// add species names
for (const std::map<std::string, Species*>::value_type& entry : GetSpeciesManager()) {
if (entry.second->Name() != "")
m_game_words.insert(UserString(entry.second->Name()));
}
// add techs names
for (const std::string& tech_name : GetTechManager().TechNames()) {
if (tech_name != "")
m_game_words.insert(UserString(tech_name));
}
// add building type names
for (const auto& entry : GetBuildingTypeManager()) {
if (entry.second->Name() != "")
m_game_words.insert(UserString(entry.second->Name()));
}
// add ship hulls
for (const auto& design : GetPredefinedShipDesignManager().GetOrderedShipDesigns()) {
if (!design->Hull().empty())
m_game_words.insert(UserString(design->Hull()));
}
// add ship parts
for (const auto& design : GetPredefinedShipDesignManager().GetOrderedShipDesigns()) {
for (const std::string& part_name : design->Parts()) {
if (part_name != "")
m_game_words.insert(UserString(part_name));
}
}
}
void IApp::StartBackgroundParsing() {
const auto& rdir = GetResourceDir();
GetBuildingTypeManager().SetBuildingTypes(Pending::StartParsing(parse::buildings, rdir / "scripting/buildings"));
GetEncyclopedia().SetArticles(Pending::StartParsing(parse::encyclopedia_articles, rdir / "scripting/encyclopedia"));
GetFieldTypeManager().SetFieldTypes(Pending::StartParsing(parse::fields, rdir / "scripting/fields"));
GetSpecialsManager().SetSpecialsTypes(Pending::StartParsing(parse::specials, rdir / "scripting/specials"));
GetSpeciesManager().SetSpeciesTypes(Pending::StartParsing(parse::species, rdir / "scripting/species"));
GetPartTypeManager().SetPartTypes(Pending::StartParsing(parse::ship_parts, rdir / "scripting/ship_parts"));
GetHullTypeManager().SetHullTypes(Pending::StartParsing(parse::ship_hulls, rdir / "scripting/ship_hulls"));
GetPredefinedShipDesignManager().SetShipDesignTypes(
Pending::StartParsing(parse::ship_designs, rdir / "scripting/ship_designs"));
GetPredefinedShipDesignManager().SetMonsterDesignTypes(
Pending::StartParsing(parse::ship_designs, rdir / "scripting/monster_designs"));
GetGameRules().Add(Pending::StartParsing(parse::game_rules, rdir / "scripting/game_rules.focs.txt"));
GetTechManager().SetTechs(Pending::StartParsing(parse::techs<TechManager::TechParseTuple>, rdir / "scripting/techs"));
InitEmpireColors(rdir / "empire_colors.xml");
}
void MessageWndEdit::FindGameWords() {
// add player and empire names
for (EmpireManager::const_iterator it = Empires().begin(); it != Empires().end(); ++it) {
m_gameWords.insert(it->second->Name());
m_gameWords.insert(it->second->PlayerName());
}
// add system names
std::vector<TemporaryPtr<System> > systems = GetUniverse().Objects().FindObjects<System>();
for (unsigned int i = 0; i < systems.size(); ++i) {
if (systems[i]->Name() != "")
m_gameWords.insert(systems[i]->Name());
}
// add ship names
std::vector<TemporaryPtr<Ship> > ships = GetUniverse().Objects().FindObjects<Ship>();
for (unsigned int i = 0; i < ships.size(); ++i) {
if (ships[i]->Name() != "")
m_gameWords.insert(ships[i]->Name());
}
// add ship design names
for (PredefinedShipDesignManager::iterator it = GetPredefinedShipDesignManager().begin();
it != GetPredefinedShipDesignManager().end(); ++it)
{
if (it->second->Name() != "")
m_gameWords.insert(UserString(it->second->Name()));
}
// add specials names
std::vector<std::string> specials = SpecialNames();
for (unsigned int i = 0; i < specials.size(); ++i) {
if (specials[i] != "")
m_gameWords.insert(UserString(specials[i]));
}
// add species names
for (SpeciesManager::iterator it = GetSpeciesManager().begin();
it != GetSpeciesManager().end(); ++it)
{
if (it->second->Name() != "")
m_gameWords.insert(UserString(it->second->Name()));
}
// add techs names
std::vector<std::string> techs = GetTechManager().TechNames();
for (unsigned int i = 0; i < techs.size(); ++i) {
if (techs[i] != "")
m_gameWords.insert(UserString(techs[i]));
}
// add building type names
for (BuildingTypeManager::iterator it = GetBuildingTypeManager().begin();
it != GetBuildingTypeManager().end(); ++it)
{
if (it->second->Name() != "")
m_gameWords.insert(UserString(it->second->Name()));
}
// add ship hulls
for (PredefinedShipDesignManager::iterator it = GetPredefinedShipDesignManager().begin();
it != GetPredefinedShipDesignManager().end(); ++it)
{
if (it->second->Hull() != "")
m_gameWords.insert(UserString(it->second->Hull()));
}
// add ship parts
for (PredefinedShipDesignManager::iterator it = GetPredefinedShipDesignManager().begin();
it != GetPredefinedShipDesignManager().end(); ++it)
{
const std::vector<std::string>& parts = it->second->Parts();
for (std::vector<std::string>::const_iterator it1 = parts.begin(); it1 != parts.end(); ++it1) {
if (*it1 != "")
m_gameWords.insert(UserString(*it1));
}
}
}
void ResearchQueue::Update(float RPs, const std::map<std::string, float>& research_progress) {
// status of all techs for this empire
const Empire* empire = GetEmpire(m_empire_id);
if (!empire)
return;
std::map<std::string, TechStatus> sim_tech_status_map;
for (const auto& tech : GetTechManager()) {
const std::string& tech_name = tech->Name();
sim_tech_status_map[tech_name] = empire->GetTechStatus(tech_name);
}
SetTechQueueElementSpending(RPs, research_progress, sim_tech_status_map, m_queue,
m_total_RPs_spent, m_projects_in_progress, m_empire_id);
if (m_queue.empty()) {
ResearchQueueChangedSignal();
return; // nothing more to do...
}
const int TOO_MANY_TURNS = 500; // stop counting turns to completion after this long, to prevent seemingly endless loops
// initialize status of everything to never getting done
for (Element& element : m_queue)
element.turns_left = -1;
if (RPs <= EPSILON) {
ResearchQueueChangedSignal();
return; // nothing more to do if not enough RP...
}
boost::posix_time::ptime dp_time_start;
boost::posix_time::ptime dp_time_end;
// "Dynamic Programming" version of research queue simulator -- copy the queue simulator containers
// perform dynamic programming calculation of completion times, then after regular simulation is done compare results (if both enabled)
//record original order & progress
// will take advantage of fact that sets (& map keys) are by default kept in sorted order lowest to highest
std::map<std::string, float> dp_prog = research_progress;
std::map< std::string, int > orig_queue_order;
std::map<int, float> dpsim_research_progress;
for (unsigned int i = 0; i < m_queue.size(); ++i) {
std::string tname = m_queue[i].name;
orig_queue_order[tname] = i;
dpsim_research_progress[i] = dp_prog[tname];
}
std::map<std::string, TechStatus> dpsim_tech_status_map = std::move(sim_tech_status_map);
// initialize simulation_results with -1 for all techs, so that any techs that aren't
// finished in simulation by turn TOO_MANY_TURNS will be left marked as never to be finished
std::vector<int> dpsimulation_results(m_queue.size(), -1);
const int DP_TURNS = TOO_MANY_TURNS; // track up to this many turns
std::map<std::string, std::set<std::string>> waiting_for_prereqs;
std::set<int> dp_researchable_techs;
for (unsigned int i = 0; i < m_queue.size(); ++i) {
std::string techname = m_queue[i].name;
if (m_queue[i].paused)
continue;
const Tech* tech = GetTech(techname);
if (!tech)
continue;
if (dpsim_tech_status_map[techname] == TS_RESEARCHABLE) {
dp_researchable_techs.insert(i);
} else if (dpsim_tech_status_map[techname] == TS_UNRESEARCHABLE ||
dpsim_tech_status_map[techname] == TS_HAS_RESEARCHED_PREREQ)
{
std::set<std::string> these_prereqs = tech->Prerequisites();
for (auto ptech_it = these_prereqs.begin(); ptech_it != these_prereqs.end();) {
if (dpsim_tech_status_map[*ptech_it] != TS_COMPLETE) {
++ptech_it;
} else {
auto erase_it = ptech_it;
++ptech_it;
these_prereqs.erase(erase_it);
}
}
waiting_for_prereqs[techname] = these_prereqs;
}
}
int dp_turns = 0;
//pp_still_available[turn-1] gives the RP still available in this resource pool at turn "turn"
std::vector<float> rp_still_available(DP_TURNS, RPs); // initialize to the full RP allocation for every turn
while ((dp_turns < DP_TURNS) && !(dp_researchable_techs.empty())) {// if we haven't used up our turns and still have techs to process
++dp_turns;
std::map<int, bool> already_processed;
for (int tech_id : dp_researchable_techs) {
already_processed[tech_id] = false;
}
auto cur_tech_it = dp_researchable_techs.begin();
while ((rp_still_available[dp_turns-1] > EPSILON)) { // try to use up this turns RPs
if (cur_tech_it == dp_researchable_techs.end()) {
break; //will be wasting some RP this turn
}
int cur_tech = *cur_tech_it;
if (already_processed[cur_tech]) {
++cur_tech_it;
continue;
}
already_processed[cur_tech] = true;
const std::string& tech_name = m_queue[cur_tech].name;
const Tech* tech = GetTech(tech_name);
float progress = dpsim_research_progress[cur_tech];
float tech_cost = tech ? tech->ResearchCost(m_empire_id) : 0.0f;
float RPs_needed = tech ? tech_cost * (1.0f - std::min(progress, 1.0f)) : 0.0f;
float RPs_per_turn_limit = tech ? tech->PerTurnCost(m_empire_id) : 1.0f;
float RPs_to_spend = std::min(std::min(RPs_needed, RPs_per_turn_limit), rp_still_available[dp_turns-1]);
progress += RPs_to_spend / std::max(EPSILON, tech_cost);
dpsim_research_progress[cur_tech] = progress;
rp_still_available[dp_turns-1] -= RPs_to_spend;
auto next_res_tech_it = cur_tech_it;
int next_res_tech_idx;
if (++next_res_tech_it == dp_researchable_techs.end()) {
next_res_tech_idx = m_queue.size()+1;
} else {
next_res_tech_idx = *(next_res_tech_it);
}
if (tech_cost - EPSILON <= progress * tech_cost) {
dpsim_tech_status_map[tech_name] = TS_COMPLETE;
dpsimulation_results[cur_tech] = dp_turns;
#ifndef ORIG_RES_SIMULATOR
m_queue[cur_tech].turns_left = dp_turns;
#endif
dp_researchable_techs.erase(cur_tech_it);
std::set<std::string> unlocked_techs;
if (tech)
unlocked_techs = tech->UnlockedTechs();
for (std::string u_tech_name : unlocked_techs) {
auto prereq_tech_it = waiting_for_prereqs.find(u_tech_name);
if (prereq_tech_it != waiting_for_prereqs.end() ){
std::set<std::string>& these_prereqs = prereq_tech_it->second;
auto just_finished_it = these_prereqs.find(tech_name);
if (just_finished_it != these_prereqs.end() ) { //should always find it
these_prereqs.erase(just_finished_it);
if (these_prereqs.empty()) { // tech now fully unlocked
int this_tech_idx = orig_queue_order[u_tech_name];
dp_researchable_techs.insert(this_tech_idx);
waiting_for_prereqs.erase(prereq_tech_it);
already_processed[this_tech_idx] = true; //doesn't get any allocation on current turn
if (this_tech_idx < next_res_tech_idx ) {
next_res_tech_idx = this_tech_idx;
}
}
} else { //couldnt find tech_name in prereqs list
DebugLogger() << "ResearchQueue::Update tech unlocking problem:"<< tech_name << "thought it was a prereq for " << u_tech_name << "but the latter disagreed";
}
} //else { //tech_name thinks itself a prereq for ytechName, but u_tech_name not in prereqs -- not a problem so long as u_tech_name not in our queue at all
// DebugLogger() << "ResearchQueue::Update tech unlocking problem:"<< tech_name << "thought it was a prereq for " << u_tech_name << "but the latter disagreed";
//}
}
}// if (tech->ResearchCost() - EPSILON <= progress * tech_cost)
cur_tech_it = dp_researchable_techs.find(next_res_tech_idx);
}//while ((rp_still_available[dp_turns-1]> EPSILON))
//dp_time = dpsim_queue_timer.elapsed() * 1000;
// DebugLogger() << "ProductionQueue::Update queue dynamic programming sim time: " << dpsim_queue_timer.elapsed() * 1000.0;
} // while ((dp_turns < DP_TURNS ) && !(dp_researchable_techs.empty() ) )
ResearchQueueChangedSignal();
}
