size_t Private::IndexKeywords( std::string const & keyword, Table const & mapping, IdSetTable & id_set, bool is_keyword_complete) { IdSet set; if (is_keyword_complete) { auto iter = mapping.find(keyword); if (iter != mapping.end()) set.insert(iter->second); } else { for (auto & pair : mapping) if (pair.first.find(keyword) != std::string::npos) set.insert(pair.second); } if (!set.empty()) { auto iter = std::find(id_set.begin(), id_set.end(), set); if (iter == id_set.end()) { id_set.push_back(std::move(set)); return id_set.size() - 1U; } else return std::distance(id_set.begin(), iter); } return ~size_t(0U); }
IdSet InputFrame::unpackIdSet(){ IdSet set; uint32_t msize = unpackInt(); for(uint32_t i = 0; i < msize; ++i){ set.insert( unpackInt() ); } return set; }
IdSet MoonInstanceScript::BuildIdSet(uint32 pCount, ...) { IdSet NewSet; va_list List; va_start(List, pCount); for(uint32 i = 0; i < pCount; ++i) NewSet.insert(va_arg(List, uint32)); va_end(List); return NewSet; }
/** Statically analyse the given ast. * * \param ast_ The AST. * \param in_object Whether or not ast_ is within the lexical scope of an object AST. * \param vars The variables defined within lexical scope of ast_. * \returns The free variables in ast_. */ static IdSet static_analysis(AST *ast_, bool in_object, const IdSet &vars) { IdSet r; if (auto *ast = dynamic_cast<const Apply*>(ast_)) { append(r, static_analysis(ast->target, in_object, vars)); for (AST *arg : ast->arguments) append(r, static_analysis(arg, in_object, vars)); } else if (auto *ast = dynamic_cast<const Array*>(ast_)) { for (AST *el : ast->elements) append(r, static_analysis(el, in_object, vars)); } else if (auto *ast = dynamic_cast<const Binary*>(ast_)) { append(r, static_analysis(ast->left, in_object, vars)); append(r, static_analysis(ast->right, in_object, vars)); } else if (dynamic_cast<const BuiltinFunction*>(ast_)) { // Nothing to do. } else if (auto *ast = dynamic_cast<const Conditional*>(ast_)) { append(r, static_analysis(ast->cond, in_object, vars)); append(r, static_analysis(ast->branchTrue, in_object, vars)); append(r, static_analysis(ast->branchFalse, in_object, vars)); } else if (auto *ast = dynamic_cast<const Error*>(ast_)) { return static_analysis(ast->expr, in_object, vars); } else if (auto *ast = dynamic_cast<const Function*>(ast_)) { auto new_vars = vars; IdSet params; for (auto *p : ast->parameters) { if (params.find(p) != params.end()) { throw StaticError(ast_->location, "Duplicate function parameter: " + p->name); } params.insert(p); new_vars.insert(p); } auto fv = static_analysis(ast->body, in_object, new_vars); for (auto *p : ast->parameters) fv.erase(p); append(r, fv); } else if (dynamic_cast<const Import*>(ast_)) { // Nothing to do. } else if (dynamic_cast<const Importstr*>(ast_)) { // Nothing to do. } else if (auto *ast = dynamic_cast<const Index*>(ast_)) { append(r, static_analysis(ast->target, in_object, vars)); append(r, static_analysis(ast->index, in_object, vars)); } else if (auto *ast = dynamic_cast<const Local*>(ast_)) { IdSet ast_vars; for (const auto &bind: ast->binds) { ast_vars.insert(bind.first); } auto new_vars = vars; append(new_vars, ast_vars); IdSet fvs; for (const auto &bind: ast->binds) append(fvs, static_analysis(bind.second, in_object, new_vars)); append(fvs, static_analysis(ast->body, in_object, new_vars)); for (const auto &bind: ast->binds) fvs.erase(bind.first); append(r, fvs); } else if (dynamic_cast<const LiteralBoolean*>(ast_)) { // Nothing to do. } else if (dynamic_cast<const LiteralNumber*>(ast_)) { // Nothing to do. } else if (dynamic_cast<const LiteralString*>(ast_)) { // Nothing to do. } else if (dynamic_cast<const LiteralNull*>(ast_)) { // Nothing to do. } else if (auto *ast = dynamic_cast<Object*>(ast_)) { for (auto field : ast->fields) { append(r, static_analysis(field.name, in_object, vars)); append(r, static_analysis(field.body, true, vars)); } } else if (auto *ast = dynamic_cast<ObjectComposition*>(ast_)) { auto new_vars = vars; new_vars.insert(ast->id); append(r, static_analysis(ast->field, false, new_vars)); append(r, static_analysis(ast->value, true, new_vars)); r.erase(ast->id); append(r, static_analysis(ast->array, in_object, vars)); } else if (dynamic_cast<const Self*>(ast_)) { if (!in_object) throw StaticError(ast_->location, "Can't use self outside of an object."); } else if (dynamic_cast<const Super*>(ast_)) { if (!in_object) throw StaticError(ast_->location, "Can't use super outside of an object."); } else if (auto *ast = dynamic_cast<const Unary*>(ast_)) { append(r, static_analysis(ast->expr, in_object, vars)); } else if (auto *ast = dynamic_cast<const Var*>(ast_)) { if (vars.find(ast->id) == vars.end()) { throw StaticError(ast->location, "Unknown variable: "+ast->id->name); } r.insert(ast->id); } else { std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl; std::abort(); } for (auto *id : r) ast_->freeVariables.push_back(id); return r; }
/** Inserts all of s into r. */ static void append(IdSet &r, const IdSet &s) { r.insert(s.begin(), s.end()); }
bool listAllSeries(const std::string& rootCategory, const std::string& outputFile) { bool result(false); using namespace fredcpp; // Initialize Api api; api.withLogger(external::SimpleLogger::getInstance()) .withExecutor(external::CurlHttpClient::getInstance()) .withParser(external::PugiXmlParser::getInstance()) ; external::SimpleLogger::getInstance().enableInfo(); FREDCPP_LOG_INFO(FREDCPP_FACILITY << " version " << FREDCPP_VERSION_STRING << " (" << FREDCPP_BRIEF << ")"); FREDCPP_LOG_INFO("Getting API key from environment variable " << ENV_API_KEY << " ..."); api.withKey(getKeyFromEnv(ENV_API_KEY)); // Build a list of available sub-categories under the root FREDCPP_LOG_INFO("Building list of available sub-categories of category " << rootCategory << " ..."); ChildrenByIdMap categoryTree; if ( 0 == buildCategoryTree(api, categoryTree, rootCategory)) { FREDCPP_LOG_FATAL("Unable to retrieve categories"); exit(EXIT_FAILURE); } FREDCPP_LOG_INFO("Available categories count:" << categoryTree.size()); FREDCPP_LOG_INFO("Creating output data file " << outputFile << " ..."); std::ofstream output(outputFile.c_str()); if (!output) { exitOnBadOutputFile(outputFile); } // Get series IdSet uniqueSeries; ApiResponse response; for (ChildrenByIdMap::iterator it = categoryTree.begin(); it != categoryTree.end(); ++it) { std::string categoryId(it->first); api.get(ApiRequestBuilder::CategorySeries(categoryId) , response) || exitOnApiError(response); if (!response.entities.size()) { FREDCPP_LOG_INFO("category:" << categoryId << " contains no series"); } // Print series // NOTE: a given series can belong to multiple categories, // so keep track of unique series for (std::size_t n = 0; n < response.entities.size(); ++n) { std::string seriesId (response.entities[n].attribute("id")); if (uniqueSeries.find(seriesId) != uniqueSeries.end()) { continue; } uniqueSeries.insert(seriesId); output << response.entities[n].attribute("id") << "|" << response.entities[n].attribute("frequency_short") << "|" << response.entities[n].attribute("title") << "|" << response.entities[n].attribute("observation_start") << "|" << response.entities[n].attribute("observation_end") << "|" << std::endl; } } // Report stats FREDCPP_LOG_INFO("root-category:" << rootCategory << " sub-categories-count:" << categoryTree.size() - 1 << " series-count:" << uniqueSeries.size()); output.close(); FREDCPP_LOG_INFO("Successfully created file " << outputFile); result = true; return (result); }
void RSPCombat::doCombat(std::map<uint32_t, IdSet> sides) { Game* game = Game::getGame(); PlayerManager::Ptr playermanager = game->getPlayerManager(); ObjectManager* objectmanager = game->getObjectManager(); DesignStore::Ptr ds = game->getDesignStore(); const char * const rsp[] = {"rock", "scissors", "paper"}; IdSet listallobids; IdSet listallplayerids; std::map<uint32_t, std::vector<Combatant*> > fleetcache; battlelogger.reset(new BattleXML::BattleLogger()); msgstrings.clear(); for(std::map<uint32_t, IdSet>::iterator itmap = sides.begin(); itmap != sides.end(); ++itmap) { std::vector<Combatant*> pcombatant; Player::Ptr player = playermanager->getPlayer(itmap->first); battlelogger->startSide(player->getName()); IdSet theset = itmap->second; for(IdSet::iterator itset = theset.begin(); itset != theset.end(); ++itset) { listallobids.insert(*itset); IGObject::Ptr obj = objectmanager->getObject (*itset); objectcache[*itset] = obj; if(obj->getType() == obT_Fleet) { Fleet* f2 = (Fleet*)(obj->getObjectBehaviour()); IdMap shiplist = f2->getShips(); uint32_t damage = f2->getDamage(); for(IdMap::reverse_iterator itship = shiplist.rbegin(); itship != shiplist.rend(); ++itship) { for(uint32_t i = 0; i < itship->second; i++) { Combatant* f1 = new Combatant(); f1->setOwner(itmap->first); f1->setObject(obj->getID()); f1->setShipType(itship->first); uint32_t mydamage = damage / std::max(1U, (unsigned int)(shiplist.size() - i)); f1->setDamage(mydamage); damage -= mydamage; std::string type = ds->getDesign(itship->first)->getName(); f1->setBattleXmlType(type); f1->setBattleXmlId(str(boost::format("%1%-%2%-%3%") % type % obj->getID() % i)); f1->setBattleXmlName(str(boost::format("%1%'s %2%, %3% %4%") % player->getName() % obj->getName() % type % i)); battlelogger->addCombatant(f1); pcombatant.push_back(f1); } } } else { int shipcount = 2; int homeplanetid = game->getResourceManager()->getResourceDescription("Home Planet")->getResourceType(); if(((Planet*)(obj->getObjectBehaviour()))->getResource(homeplanetid) == 1) { //three more for home planets shipcount += 3; } for(int i = 0; i < shipcount; i++) { Combatant* f1 = new Combatant(); f1->setOwner(itmap->first); f1->setObject(obj->getID()); f1->setShipType(0); f1->setBattleXmlType("planet"); f1->setBattleXmlId(str(boost::format("planet-%1%-%2%") % obj->getID() % i)); f1->setBattleXmlName(str(boost::format("%1%'s colony on %2%, Defense battery %3%") % player->getName() % obj->getName() % i)); battlelogger->addCombatant(f1); pcombatant.push_back(f1); } } } listallplayerids.insert(itmap->first); battlelogger->endSide(); //sort combatant list by ship type, descending sort(pcombatant.begin(), pcombatant.end(), CombatantSorter()); fleetcache[itmap->first] = pcombatant; } for(std::set<uint32_t>::iterator itplayer = listallplayerids.begin(); itplayer != listallplayerids.end(); ++itplayer) { msgstrings[*itplayer] = ""; } Random* random = Game::getGame()->getRandom(); Logger::getLogger()->debug("Combat start"); while(fleetcache.size() >= 2) { battlelogger->startRound(); uint32_t pos1, pos2; if(fleetcache.size() == 2) { pos1 = 0; pos2 = 1; } else { pos1 = pos2 = random->getInRange(0U, ((uint32_t)(fleetcache.size() - 1))); while(pos2 == pos1) { pos2 = random->getInRange(0U, ((uint32_t)(fleetcache.size() - 1))); } } std::map<uint32_t, std::vector<Combatant*> >::iterator itpa = fleetcache.begin(); advance(itpa, pos1); std::map<uint32_t, std::vector<Combatant*> >::iterator itpb = fleetcache.begin(); advance(itpb, pos2); std::vector<Combatant*> f1 = itpa->second; std::vector<Combatant*> f2 = itpb->second; uint32_t ownerid1 = f1[0]->getOwner(); uint32_t ownerid2 = f2[0]->getOwner(); std::string p1name = playermanager->getPlayer(ownerid1)->getName(); std::string p2name = playermanager->getPlayer(ownerid2)->getName(); int32_t r1 = random->getInRange((int32_t)0, (int32_t)2); int32_t r2 = random->getInRange((int32_t)0, (int32_t)2); std::map<Combatant*, uint32_t> d1, d2; battlelogger->log(str(boost::format("%1%'s fleet chooses %2%.") % p1name % rsp[r2])); battlelogger->log(str(boost::format("%1%'s fleet chooses %2%.") % p2name % rsp[(r2 + r1) % 3])); if(r1 == 0) { //draw battlelogger->log("It's a draw"); d1 = buildShotList(f1, true); d2 = buildShotList(f2, true); if(d1.size() != 0) doDamage(d1, f2); if(d2.size() != 0) doDamage(d2, f1); } else { if(r1 == 1) { //pa win battlelogger->log(str(boost::format("%1% wins.") % p1name)); d1 = buildShotList(f1); if(d1.size() == 0) { battlelogger->log(str(boost::format("%1%'s forces escape") % p1name)); msgstrings[ownerid1] += "Your Fleet escaped. "; for(std::map<uint32_t, std::string>::iterator msgit = msgstrings.begin(); msgit != msgstrings.end(); ++msgit) { if(msgit->first == ownerid1) continue; msgit->second += str(boost::format("%1%'s fleet of escaped. ") % p1name); } resolveCombatantsToObjects(f1); for(std::vector<Combatant*>::iterator itcombatant = f1.begin(); itcombatant != f1.end(); ++itcombatant) { delete *itcombatant; } fleetcache.erase(itpa); battlelogger->endRound(); continue; } doDamage(d1, f2); } else { //pb win battlelogger->log(str(boost::format("%1% wins.") % p2name)); d2 = buildShotList(f2); if(d2.size() == 0) { battlelogger->log(str(boost::format("%1%'s forces escape") % p2name)); msgstrings[ownerid2] += "Your Fleet escaped. "; for(std::map<uint32_t, std::string>::iterator msgit = msgstrings.begin(); msgit != msgstrings.end(); ++msgit) { if(msgit->first == ownerid2) continue; msgit->second += str(boost::format("%1%'s fleet of escaped. ") % p2name); } resolveCombatantsToObjects(f2); for(std::vector<Combatant*>::iterator itcombatant = f2.begin(); itcombatant != f2.end(); ++itcombatant) { delete *itcombatant; } fleetcache.erase(itpb); battlelogger->endRound(); continue; } doDamage(d2, f1); } } if(isAllDead(f1)) { msgstrings[ownerid1] += str(boost::format("Your fleet was destroyed by %1%'s fleet. ") % p2name); msgstrings[ownerid2] += str(boost::format("You destroyed %1%'s fleet. ") % p1name); std::string deathmsg = str(boost::format("%1%'s fleet destroyed %2%'s fleet. ") % p1name % p2name); for(std::map<uint32_t, std::string>::iterator msgit = msgstrings.begin(); msgit != msgstrings.end(); ++msgit) { if(msgit->first == ownerid1 || msgit->first == ownerid2) continue; msgit->second += deathmsg; } resolveCombatantsToObjects(f1); for(std::vector<Combatant*>::iterator itcombatant = f1.begin(); itcombatant != f1.end(); ++itcombatant) { delete *itcombatant; } fleetcache.erase(itpa); } if(isAllDead(f2)) { msgstrings[ownerid2] += str(boost::format("Your fleet was destroyed by %1%'s fleet. ") % p1name); msgstrings[ownerid1] += str(boost::format("You destroyed %1%'s fleet. ") % p2name); std::string deathmsg = str(boost::format("%1%'s fleet destroyed %2%'s fleet. ") % p2name % p1name); for(std::map<uint32_t, std::string>::iterator msgit = msgstrings.begin(); msgit != msgstrings.end(); ++msgit) { if(msgit->first == ownerid1 || msgit->first == ownerid2) continue; msgit->second += deathmsg; } resolveCombatantsToObjects(f2); for(std::vector<Combatant*>::iterator itcombatant = f2.begin(); itcombatant != f2.end(); ++itcombatant) { delete *itcombatant; } fleetcache.erase(itpb); } battlelogger->endRound(); } std::string file = battlelogger->save(); if(!fleetcache.empty()) { std::vector<Combatant*> flast = fleetcache.begin()->second; resolveCombatantsToObjects(flast); msgstrings[flast[0]->getOwner()] += "Your Fleet survived combat."; for(std::vector<Combatant*>::iterator itcombatant = flast.begin(); itcombatant != flast.end(); ++itcombatant) { delete *itcombatant; } fleetcache.erase(fleetcache.begin()); if(!fleetcache.empty()) { Logger::getLogger()->warning("fleetcache not empty at end of combat"); } } for(std::map<uint32_t, std::string>::iterator msgit = msgstrings.begin(); msgit != msgstrings.end(); ++msgit) { Message::Ptr msg( new Message() ); msg->setSubject("Combat"); for(std::set<uint32_t>::iterator itob = listallobids.begin(); itob != listallobids.end(); ++itob) { msg->addReference(rst_Object, *itob); } for(std::set<uint32_t>::iterator itpl = listallplayerids.begin(); itpl != listallplayerids.end(); ++itpl) { msg->addReference(rst_Player, *itpl); } msg->setBody(msgit->second); Game::getGame()->getPlayerManager()->getPlayer(msgit->first)->postToBoard(msg); } for(std::map<uint32_t, IGObject::Ptr>::iterator itob = objectcache.begin(); itob != objectcache.end(); ++itob) { Game::getGame()->getObjectManager()->doneWithObject(itob->first); } objectcache.clear(); }