int addHero(HeroProfile* h) { assert(globalHeroTable.count(h->tableId)==0 && "duplicate HeroProfile"); globalHeroTable[h->tableId] = h; return globalHeroTable.size(); }
inline void Restaurant::FillInPredictivesNonGraphical( const std::vector<double>& parent_predictives, int type, int depth, const HPYParameter& hpy_parameter, std::vector<double>& predictives) const { for (size_t i = 0; i < parent_predictives.size(); ++i) { predictives[i] = parent_predictives[i]; } for (auto floor_it = floor2c_t_.begin(); floor_it != floor2c_t_.end(); ++floor_it) { auto floor_id = (*floor_it).first; auto& c_t = (*floor_it).second; tmp_c_[floor_id] = c_t.first; predictives[floor_id] *= (hpy_parameter.concentration(depth, floor_id) + hpy_parameter.discount(depth, floor_id) * c_t.second) / (c_t.first + hpy_parameter.concentration(depth, floor_id)); } auto type_it = type2internal_.find(type); if (type_it == type2internal_.end()) return; auto& sections = (*type_it).second.sections_; auto section_it = sections.begin(); for (; section_it != sections.end(); ++section_it) { auto floor_id = (*section_it).first; auto& section = (*section_it).second; auto cw = section.customers; auto tw = section.tables; predictives[floor_id] += (cw - hpy_parameter.discount(depth, floor_id) * tw) / (tmp_c_[floor_id] + hpy_parameter.concentration(depth, floor_id)); } }
void FloorSampler::TakeInSectionLL( const boost::container::flat_map<topic_t, std::pair<int, int> >& floor2c_t, int add_customers, int add_tables, int current_k, int depth) { int s = pdf_.size(); auto it = floor2c_t.begin(); int j = 0; if (!include_zero_) { j = 1; if (it != floor2c_t.end() && (*it).first == 0) ++it; } for (; j < s; ++j) { if (it == floor2c_t.end() || (*it).first > j) { assert(j != current_k); // current restaurant should never be empty pdf_[j] += arrangement_part_[depth]->log_p(add_customers, add_tables, 0, 0); } else { assert((*it).first == j); int c = (*it).second.first; int t = (*it).second.second; if (j == current_k) { c -= add_customers; t -= add_tables; } pdf_[j] += arrangement_part_[depth]->log_p(add_customers, add_tables, c, t); ++it; } } }
ResultCode CreateExtSaveData(MediaType media_type, u32 high, u32 low, VAddr icon_buffer, u32 icon_size, const FileSys::ArchiveFormatInfo& format_info) { // Construct the binary path to the archive first FileSys::Path path = FileSys::ConstructExtDataBinaryPath(static_cast<u32>(media_type), high, low); auto archive = id_code_map.find(media_type == MediaType::NAND ? ArchiveIdCode::SharedExtSaveData : ArchiveIdCode::ExtSaveData); if (archive == id_code_map.end()) { return UnimplementedFunction(ErrorModule::FS); // TODO(Subv): Find the right error } auto ext_savedata = static_cast<FileSys::ArchiveFactory_ExtSaveData*>(archive->second.get()); ResultCode result = ext_savedata->Format(path, format_info); if (result.IsError()) return result; if (!Memory::IsValidVirtualAddress(icon_buffer)) return ResultCode(-1); // TODO(Subv): Find the right error code std::vector<u8> smdh_icon(icon_size); Memory::ReadBlock(icon_buffer, smdh_icon.data(), smdh_icon.size()); ext_savedata->WriteIcon(path, smdh_icon.data(), smdh_icon.size()); return RESULT_SUCCESS; }
int addPSkill(SkillInfo* skill) { assert(globalSkillTable.count(skill->sid)==0 && "duplicate HeroProfile"); globalSkillTable[skill->sid] = skill; return globalSkillTable.size(); }
ResultCode FormatArchive(ArchiveIdCode id_code, const FileSys::ArchiveFormatInfo& format_info, const FileSys::Path& path) { auto archive_itr = id_code_map.find(id_code); if (archive_itr == id_code_map.end()) { return UnimplementedFunction(ErrorModule::FS); // TODO(Subv): Find the right error } return archive_itr->second->Format(path, format_info); }
/* * Retrieve a material by tag */ boost::optional<std::size_t> get_material_by_tag(const std::string &tag) noexcept { boost::optional<std::size_t> result; auto finder = material_defs_idx.find(tag); if (finder != material_defs_idx.end()) { result = finder->second; } return result; }
ResultVal<FileSys::ArchiveFormatInfo> GetArchiveFormatInfo(ArchiveIdCode id_code, FileSys::Path& archive_path) { auto archive = id_code_map.find(id_code); if (archive == id_code_map.end()) { return UnimplementedFunction(ErrorModule::FS); // TODO(Subv): Find the right error } return archive->second->GetFormatInfo(archive_path); }
boost::optional<reaction_task_t> find_automatic_reaction_task(const settler_ai_t &ai) { if (automatic_reactions.empty()) return boost::optional<reaction_task_t>{}; boost::optional<reaction_task_t> result; // Iterate through available reactions for (auto outerit=automatic_reactions.begin(); outerit != automatic_reactions.end(); ++outerit) { // Is the workshop busy? auto busy_finder = workshop_claimed.find(outerit->first); if (busy_finder == workshop_claimed.end()) { // Iterate available automatic reactions for (const std::string &reaction_name : outerit->second) { auto reaction = reaction_defs.find(reaction_name); if (reaction != reaction_defs.end()) { // Is the settler allowed to do this? int target_category = -1; if (reaction->second.skill == "Carpentry") { target_category = JOB_CARPENTRY; } else if (reaction->second.skill == "Masonry") { target_category = JOB_MASONRY; } if (target_category == -1 || ai.permitted_work[target_category]) { // Are the inputs available? bool available = true; std::vector<std::pair<std::size_t,bool>> components; for (auto &input : reaction->second.inputs) { const int n_available = available_items_by_reaction_input(input); if (n_available < input.quantity) { available = false; } else { // Claim an item and push its # to the list std::size_t item_id = claim_item_by_reaction_input(input); components.push_back(std::make_pair(item_id,false)); } } if (available) { // Components are available, build job and return it result = reaction_task_t{outerit->first, reaction->second.name, reaction->second.tag, components}; workshop_claimed.insert(outerit->first); return result; } else { for (auto comp : components) { unclaim_by_id(comp.first); } } } } } } } return result; }
ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenFileSystem(Type type, FileSys::Path& path) { LOG_TRACE(Service_FS, "Opening FileSystem with type=%d", type); auto itr = filesystem_map.find(type); if (itr == filesystem_map.end()) { // TODO(bunnei): Find a better error code for this return ResultCode(-1); } return itr->second->Open(path); }
std::vector<HeroProfile*> heroProfiles() { std::vector<HeroProfile*> profiles; profiles.reserve(globalHeroTable.size()); transform(globalHeroTable.begin(), globalHeroTable.end(), back_inserter(profiles), [](boost::container::flat_map<int, HeroProfile*>::const_reference value){ return value.second; }); std::sort(profiles.begin(), profiles.end(), [](HeroProfile* first, HeroProfile* second){ return (first->tableId-9999.5)*(second->tableId-9999.5) < 0 ? first->tableId >= 10000 : first->tableId < second->tableId; }); return profiles; }
std::pair<double,double> FermiTable::calcAverageAtomicProperties (const boost::container::flat_map<string,double>& tracers) const { double total = 0; double aa = 0; double zz = 0; for(std::map<string,std::pair<double,double> >::const_iterator it= atomic_properties_.begin(); it!=atomic_properties_.end();++it){ assert(tracers.count(it->first)==1); const double mass_frac = tracers.find(it->first)->second; const double A = it->second.first; const double Z = it->second.second; total += mass_frac; aa += mass_frac/A; zz += mass_frac*Z/A; } return std::pair<double,double>(total/aa,zz/aa); }
ResultVal<ArchiveHandle> OpenArchive(ArchiveIdCode id_code, FileSys::Path& archive_path) { LOG_TRACE(Service_FS, "Opening archive with id code 0x%08X", id_code); auto itr = id_code_map.find(id_code); if (itr == id_code_map.end()) { // TODO: Verify error against hardware return ResultCode(ErrorDescription::NotFound, ErrorModule::FS, ErrorSummary::NotFound, ErrorLevel::Permanent); } CASCADE_RESULT(std::unique_ptr<ArchiveBackend> res, itr->second->Open(archive_path)); // This should never even happen in the first place with 64-bit handles, while (handle_map.count(next_handle) != 0) { ++next_handle; } handle_map.emplace(next_handle, std::move(res)); return MakeResult<ArchiveHandle>(next_handle++); }
ResultCode RegisterFileSystem(std::unique_ptr<FileSys::FileSystemFactory>&& factory, Type type) { auto result = filesystem_map.emplace(type, std::move(factory)); bool inserted = result.second; ASSERT_MSG(inserted, "Tried to register more than one system with same id code"); auto& filesystem = result.first->second; LOG_DEBUG(Service_FS, "Registered file system %s with id code 0x%08X", filesystem->GetName().c_str(), static_cast<u32>(type)); return RESULT_SUCCESS; }
bool is_better_armor(const std::string &item_tag, boost::container::flat_map<item_location_t, float> &ac_by_loc) { auto finder = get_clothing_by_tag(item_tag); if (!finder) return false; const float item_ac = finder->armor_class; item_location_t loc = INVENTORY; if (finder->slot == "head") loc = HEAD; if (finder->slot == "torso") loc = TORSO; if (finder->slot == "legs") loc = LEGS; if (finder->slot == "shoes") loc = FEET; auto tester = ac_by_loc.find(loc); if (tester == ac_by_loc.end()) { return true; } else { if (item_ac > tester->second) return true; } return false; }
void EraseAndShrink(boost::container::flat_map<Key, Value>& x, Key& k) { x.erase(k); // if (x.size() < x.capacity() / 4) { // boost::container::flat_map<Key, Value> y; // y.reserve(x.capacity() / 2); // for (auto& datum : x) { // y.insert(datum); // } // x.swap(y); // } }
// TODO(yuriks): This might be what the fs:REG service is for. See the Register/Unregister calls in // http://3dbrew.org/wiki/Filesystem_services#ProgramRegistry_service_.22fs:REG.22 ResultCode RegisterArchiveType(std::unique_ptr<FileSys::ArchiveFactory>&& factory, ArchiveIdCode id_code) { auto result = id_code_map.emplace(id_code, std::move(factory)); bool inserted = result.second; ASSERT_MSG(inserted, "Tried to register more than one archive with same id code"); auto& archive = result.first->second; LOG_DEBUG(Service_FS, "Registered archive %s with id code 0x%08X", archive->GetName().c_str(), id_code); return RESULT_SUCCESS; }
int main() { std::cout << "Element size: " << sizeof(map_element) << std::endl; std::cout << "std::map: "; run_tests(packet_collector_thread_std_map); DataCounter.clear(); #ifndef __APPLE__ std::cout << "tbb::concurrent_unordered_map: "; run_tests(packet_collector_thread_unordered_concurrent_map); DataCounterUnorderedConcurrent.clear(); #endif // Boost unordered map std::cout << "boost::unordered_map: "; run_tests(packet_collector_thread_boost_unordered_map); DataCounterBoostUnordered.clear(); // Boost flat_map DataCounterBoostFlatMap.reserve( number_of_ips ); std::cout << "boost::container::flat_map with preallocated elements: "; run_tests(packet_collector_thread_flat_map_preallocated); DataCounterBoostFlatMap.clear(); std::cout << "std::unordered_map C++11: "; run_tests(packet_collector_thread_unordered_map); DataCounterUnordered.clear(); // Preallocate hash buckets DataCounterUnorderedPreallocated.reserve( number_of_ips ); std::cout << "std::unordered_map C++11 preallocated buckets: "; run_tests(packet_collector_thread_unordered_map_preallocated); DataCounterUnorderedPreallocated.clear(); // Preallocate vector DataCounterVector.reserve( number_of_ips ); std::cout << "std::vector preallocated: "; run_tests(packet_collector_thread_vector); DataCounterVector.clear(); }
double Restaurant::predictive_probability(topic_t floor_id, int type, double parent_probability, double discount, double concentration) const { int cw = 0; int tw = 0; int c = 0; int t = 0; auto section_it = type2internal_.find(type); if (section_it != type2internal_.end()) { cw = (*section_it).second.customers(floor_id); tw = (*section_it).second.tables(floor_id); } auto floor_it = floor2c_t_.find(floor_id); if (floor_it != floor2c_t_.end()) { c = (*floor_it).second.first; t = (*floor_it).second.second; } return ComputePYPPredictive(cw, tw, c, t, parent_probability, discount, concentration); }
void workflow_system::update(const double duration_ms) { if (dirty) { automatic_reactions.clear(); // Enumerate buildings and see which ones have reactions. each<position_t, building_t>([this] (entity_t &e, position_t &pos, building_t &b) { if (b.complete) { auto finder = reaction_building_defs.find(b.tag); if (finder != reaction_building_defs.end()) { for (const std::string &reaction_name : finder->second) { auto reactor = reaction_defs.find(reaction_name); if (reactor != reaction_defs.end()) { // Automatic reactions are added to the auto reactor list if (reactor->second.automatic) { auto automatic_finder = automatic_reactions.find(e.id); if (automatic_finder == automatic_reactions.end()) { automatic_reactions[e.id] = std::vector<std::string>{ reaction_name }; } else { automatic_finder->second.push_back(reaction_name); } } } } } } }); // Erase all completed jobs designations->build_orders.erase( std::remove_if(designations->build_orders.begin(), designations->build_orders.end(), [] (auto order_pair) { return order_pair.first == 0; }), designations->build_orders.end()); // Not dirty anymore! dirty = false; } }
/* * Linter for materials, used in raw loader. */ void sanity_check_materials() noexcept { for (const auto &mat : material_defs) { if (mat.tag.empty()) std::cout << "WARNING: Empty material tag\n"; if (mat.name.empty()) std::cout << "WARNING: Empty material name, tag: " << mat.tag << "\n"; /*if (!mat.mines_to_tag.empty()) { auto finder = item_defs.find(mat.mines_to_tag); if (finder == item_defs.end()) std::cout << "WARNING: Unknown mining result " << mat.mines_to_tag << ", tag: " << mat.tag << "\n"; } if (!mat.mines_to_tag_second.empty()) { auto finder = item_defs.find(mat.mines_to_tag_second); if (finder == item_defs.end()) std::cout << "WARNING: Unknown mining result " << mat.mines_to_tag_second << ", tag: " << mat.tag << "\n"; }*/ if (!mat.ore_materials.empty()) { for (const std::string &metal : mat.ore_materials) { auto finder = material_defs_idx.find(metal); if (finder == material_defs_idx.end()) { std::cout << "WARNING: Substance " << mat.tag << " produces a non-existent ore: " << metal << "\n"; } } } } }
namespace FileSystem { /** * Map of registered file systems, identified by type. Once an file system is registered here, it * is never removed until UnregisterFileSystems is called. */ static boost::container::flat_map<Type, std::unique_ptr<FileSys::FileSystemFactory>> filesystem_map; ResultCode RegisterFileSystem(std::unique_ptr<FileSys::FileSystemFactory>&& factory, Type type) { auto result = filesystem_map.emplace(type, std::move(factory)); bool inserted = result.second; ASSERT_MSG(inserted, "Tried to register more than one system with same id code"); auto& filesystem = result.first->second; LOG_DEBUG(Service_FS, "Registered file system %s with id code 0x%08X", filesystem->GetName().c_str(), static_cast<u32>(type)); return RESULT_SUCCESS; } ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenFileSystem(Type type, FileSys::Path& path) { LOG_TRACE(Service_FS, "Opening FileSystem with type=%d", type); auto itr = filesystem_map.find(type); if (itr == filesystem_map.end()) { // TODO(bunnei): Find a better error code for this return ResultCode(-1); } return itr->second->Open(path); } void UnregisterFileSystems() { filesystem_map.clear(); } void InstallInterfaces(SM::ServiceManager& service_manager) { UnregisterFileSystems(); std::make_shared<FSP_SRV>()->InstallAsService(service_manager); } } // namespace FileSystem
void UnregisterArchiveTypes() { id_code_map.clear(); }
void Restaurant::FillInPredictives(const std::vector<double>& parent_predictives, int type, const LambdaManagerInterface& lmanager, int depth, const HPYParameter& hpy_parameter, std::vector<double>& predictives) const { auto floor_it = floor2c_t_.begin(); auto type_it = type2internal_.find(type); predictives[0] = parent_predictives[0]; if (floor2c_t_.empty()) { for (size_t i = 1; i < predictives.size(); ++i) { double lambda = lmanager.lambda(i, depth); predictives[i] = lambda * parent_predictives[i] + (1 - lambda) * predictives[0]; } return; } if ((*floor_it).first == 0) { auto& c_t = (*floor_it).second; predictives[0] *= (hpy_parameter.concentration(depth, 0) + hpy_parameter.discount(depth, 0) * c_t.second) / (c_t.first + hpy_parameter.concentration(depth, 0)); if (type_it != type2internal_.end()) { auto& sections = (*type_it).second.sections_; if (!sections.empty()) { auto section_begin = sections.begin(); if ((*section_begin).first == 0) { int cw = (*section_begin).second.customers; int tw = (*section_begin).second.tables; predictives[0] += (cw - hpy_parameter.discount(depth, 0) * tw) / (c_t.first + hpy_parameter.concentration(depth, 0)); } } } } for (size_t i = 1; i < predictives.size(); ++i) { double lambda = lmanager.lambda(i, depth); predictives[i] = lambda * parent_predictives[i] + (1 - lambda) * predictives[0]; } if ((*floor_it).first == 0) { ++floor_it; } for (; floor_it != floor2c_t_.end(); ++floor_it) { auto floor_id = (*floor_it).first; auto& c_t = (*floor_it).second; tmp_c_[floor_id] = c_t.first; predictives[floor_id] *= (hpy_parameter.concentration(depth, floor_id) + hpy_parameter.discount(depth, floor_id) * c_t.second) / (c_t.first + hpy_parameter.concentration(depth, floor_id)); } if (type_it == type2internal_.end()) return; auto& sections = (*type_it).second.sections_; auto section_it = sections.begin(); if (section_it != sections.end() && (*section_it).first == 0) { ++section_it; } for (; section_it != sections.end(); ++section_it) { auto floor_id = (*section_it).first; auto& section = (*section_it).second; int cw = section.customers; int tw = section.tables; predictives[floor_id] += (cw - hpy_parameter.discount(depth, floor_id) * tw) / (tmp_c_[floor_id] + hpy_parameter.concentration(depth, floor_id)); } }
namespace PH { // Hero Profile int HeroProfile::getMaxStar() const { int maxStar = star; int transNum = transformTargetHeroId; for (;;) { if(transNum == -1) break; const HeroProfile& next = HPT(transNum); transNum = next.transformTargetHeroId; maxStar++; } return maxStar; } bool HeroProfile::isMat() const { return tableId < 10000; } int LevelStats::getOpLevel() { //// // ---------- Accounting after battle ---------- //// float score =0.f; this->refMaxCombo = std::max(this->refMaxCombo, 1); this->refAvgCombo = std::max(this->refAvgCombo, 1); this->refRound = std::max(this->refRound, 1); // A float tmp = this->maxCombo; tmp /= (float)this->refMaxCombo; tmp *= 12; tmp = std::min(30.f, tmp); score += tmp; // B tmp = (float)this->totalCombo; tmp /= (float)this->turnCount; tmp /= (float)this->refAvgCombo; tmp *= 15; tmp = std::min(30.f, tmp); score += tmp; // C float tmp2 = 0.f; for( auto val : this->roundPerLevel) tmp2 += val; tmp2 /= (float)this->roundPerLevel.size(); tmp2 = std::max(1.f, tmp2); tmp = (float)this->refRound; tmp /= tmp2; tmp *= 25; tmp = std::min(60.f, tmp); score += tmp; // D tmp = 4.f; tmp /= (this->reviveCount+4); tmp *= 40.f; tmp = std::min(40.f, tmp); score += tmp; int opLevel = 5; if(score > 61) opLevel = 4; if (score > 80) opLevel = 3; if (score > 100) opLevel = 2; if (score > 130) opLevel = 1; return opLevel; //return 1; } bool isIdChainInTeam(int id, const std::vector<Hero*>& team) { for(int id2 = id; id2 != -1; id2 = HPT(id2).transformTargetHeroId) { for(Hero* h : team) if(h && h->heroId == id2) return true; } return false; } bool isRelationActive(const HeroRelation& relation, const std::vector<Hero*>& team) { for(int id : relation.withHeroes) { if(!isIdChainInTeam(id, team)) return false; } return true; } Hero boostHeroStatsByRelations(const Hero& refH, const HeroList& team) { Hero h = refH; for(const HeroRelation& r: h.relations) { if(!isRelationActive(r, team)) continue; for(auto& pair : r.effects) { RelationEffects effect; double val; boost::tie(effect, val) = pair; if(effect == HP) h.health += refH.health * val; else if(effect == STRENGTH) h.attack += refH.attack * val; else if(effect == REGEN) h.regen += refH.regen * val; else LOGD("Unknown relation effect %d", effect); } } return h; } //--------------- // Hero //--------------- Hero::Hero(std::string uid, int hid, int lvl, int ex) :id(uid), heroId(hid), level(lvl), exp(ex) { profile = &HPT(hid); eliteLevel = 0; health = profile->health.eval(level); attack = profile->attack.eval(level); regen = profile->regen.eval(level); expCap = level > profile->maxLevel ? -1 : profile->exp.eval(level); maxEnergy = profile->activeSkillId != -1 ? AST(profile->activeSkillId).energy : 0; skillBonus = 0; trainPrice = lvl * 100; } static boost::container::flat_map<int, HeroProfile*> globalHeroTable; static boost::container::flat_map<int, SkillInfo*> globalSkillTable; const SkillInfo& AST(int i) { assert(globalSkillTable.count(i) && "Skill does not exist"); return *globalSkillTable[i]; } const SkillInfo& PST(int i) { assert(globalSkillTable.count(i) && "Skill does not exist"); return *globalSkillTable[i]; } const HeroProfile& HPT(int i) { assert(globalHeroTable.count(i) && "HeroProfile does not exist"); return *globalHeroTable[i]; } int HPTN(const HeroProfile *profile) { std::vector<HeroProfile*> profiles = heroProfiles(); for(int i = 0 ; i < profiles.size() ; i++) { if(profiles[i] && profiles[i]->tableId == profile->tableId)return i; } return -1; } std::vector<HeroProfile*> heroProfiles() { std::vector<HeroProfile*> profiles; profiles.reserve(globalHeroTable.size()); transform(globalHeroTable.begin(), globalHeroTable.end(), back_inserter(profiles), [](boost::container::flat_map<int, HeroProfile*>::const_reference value){ return value.second; }); std::sort(profiles.begin(), profiles.end(), [](HeroProfile* first, HeroProfile* second){ return (first->tableId-9999.5)*(second->tableId-9999.5) < 0 ? first->tableId >= 10000 : first->tableId < second->tableId; }); return profiles; } int addHero(HeroProfile* h) { assert(globalHeroTable.count(h->tableId)==0 && "duplicate HeroProfile"); globalHeroTable[h->tableId] = h; return globalHeroTable.size(); } int addASkill(SkillInfo* skill) { assert(globalSkillTable.count(skill->sid)==0 && "duplicate HeroProfile"); globalSkillTable[skill->sid] = skill; return globalSkillTable.size(); } int addPSkill(SkillInfo* skill) { assert(globalSkillTable.count(skill->sid)==0 && "duplicate HeroProfile"); globalSkillTable[skill->sid] = skill; return globalSkillTable.size(); } }
void UnregisterFileSystems() { filesystem_map.clear(); }
const SkillInfo& PST(int i) { assert(globalSkillTable.count(i) && "Skill does not exist"); return *globalSkillTable[i]; }
const HeroProfile& HPT(int i) { assert(globalHeroTable.count(i) && "HeroProfile does not exist"); return *globalHeroTable[i]; }