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(); }