variant<AvatarInfo, AvatarMenuOption> getAvatarInfo(View* view, const PlayerCreaturesInfo* creatures, Options* options, CreatureFactory* creatureFactory) { auto keeperCreatureInfos = creatures->first; auto keeperCreatures = keeperCreatureInfos.transform([&](auto& elem) { return elem.creatureId.transform([&](auto& id) { auto ret = creatureFactory->fromId(id, getPlayerTribeId(elem.tribeAlignment)); for (auto& trait : elem.specialTraits) applySpecialTrait(trait, ret.get()); return ret; }); }); auto adventurerCreatureInfos = creatures->second; auto adventurerCreatures = adventurerCreatureInfos.transform([&](auto& elem) { return elem.creatureId.transform([&](auto& id) { return creatureFactory->fromId(id, getPlayerTribeId(elem.tribeAlignment)); }); }); vector<View::AvatarData> keeperAvatarData; for (int i : All(keeperCreatures)) keeperAvatarData.push_back(View::AvatarData { keeperCreatures[i].transform([](const auto& c) { return getUpgradedViewId(c.get()); }), keeperCreatures[i].transform([](const auto& c) { return c->getName().firstOrBare(); }), keeperCreatureInfos[i].tribeAlignment, keeperCreatures[i][0]->getName().identify(), PlayerRole::KEEPER, keeperCreatureInfos[i].description }); vector<View::AvatarData> adventurerAvatarData; for (int i : All(adventurerCreatures)) adventurerAvatarData.push_back(View::AvatarData { adventurerCreatures[i].transform([](const auto& c) { return getUpgradedViewId(c.get()); }), adventurerCreatures[i].transform([](const auto& c) { return c->getName().firstOrBare(); }), adventurerCreatureInfos[i].tribeAlignment, adventurerCreatures[i][0]->getName().identify(), PlayerRole::ADVENTURER, adventurerCreatureInfos[i].description }); auto result1 = view->chooseAvatar(concat(keeperAvatarData, adventurerAvatarData), options); if (auto option = result1.getValueMaybe<AvatarMenuOption>()) return *option; auto result = result1.getReferenceMaybe<View::AvatarChoice>(); variant<KeeperCreatureInfo, AdventurerCreatureInfo> creatureInfo; PCreature ret; if (result->creatureIndex < keeperCreatures.size()) { creatureInfo = creatures->first[result->creatureIndex]; ret = std::move(keeperCreatures[result->creatureIndex][result->genderIndex]); ret->getName().setBare("Keeper"); } else { creatureInfo = creatures->second[result->creatureIndex - keeperCreatures.size()]; ret = std::move(adventurerCreatures[result->creatureIndex - keeperCreatures.size()][result->genderIndex]); ret->getName().setBare("Adventurer"); } auto villains = creatureInfo.visit([](const auto& elem) { return elem.tribeAlignment;}); return AvatarInfo{std::move(ret), creatureInfo, villains }; }
void MonsterAI::makeMove() { vector<pair<MoveInfo, int>> moves; for (int i : All(behaviours)) { MoveInfo move = behaviours[i]->getMove(); move.value *= weights[i]; moves.emplace_back(move, weights[i]); if (pickItems) { for (auto elem : Item::stackItems(creature->getPickUpOptions())) { Item* item = elem.second[0]; if (!item->getShopkeeper() && creature->canPickUp(elem.second)) { MoveInfo pickupMove { behaviours[i]->itemValue(item) * weights[i], [=]() { creature->globalMessage(creature->getTheName() + " picks up " + elem.first, ""); creature->pickUp(elem.second); }}; moves.emplace_back(pickupMove, weights[i]); } } } } /*vector<Item*> inventory = creature->getEquipment().getItems([this](Item* item) { return !creature->getEquipment().isEquiped(item);}); for (Item* item : inventory) { bool useless = true; for (PBehaviour& behaviour : behaviours) if (behaviour->itemValue(item) > 0) useless = false; if (useless) moves.push_back({ 0.01, [=]() { creature->globalMessage(creature->getTheName() + " drops " + item->getAName(), ""); creature->drop({item}); }}); }*/ MoveInfo winner {0, nullptr}; for (int i : All(moves)) { MoveInfo& move = moves[i].first; if (move.value > winner.value) winner = move; if (i < moves.size() - 1 && move.value > moves[i + 1].second) break; } CHECK(winner.value > 0); winner.move(); }
string combine(const vector<string>& adj, bool commasOnly) { string res; for (int i : All(adj)) { if (i == adj.size() - 1 && i > 0 && !commasOnly) res.append(" and "); else if (i > 0) res.append(", "); res.append(adj[i]); } return res; }
void Player::spellAction() { vector<View::ListElem> list; auto spells = creature->getSpells(); for (int i : All(spells)) list.push_back(View::ListElem(spells[i].name + " " + (!creature->castSpell(i) ? "(ready in " + convertToString(int(spells[i].ready - creature->getTime() + 0.9999)) + " turns)" : ""), creature->castSpell(i) ? View::NORMAL : View::INACTIVE)); auto index = model->getView()->chooseFromList("Cast a spell:", list); if (!index) return; tryToPerform(creature->castSpell(*index)); }
vector<WCreature> Effect::summonCreatures(Position pos, int radius, vector<PCreature> creatures, TimeInterval delay) { vector<Position> area = pos.getRectangle(Rectangle(-Vec2(radius, radius), Vec2(radius + 1, radius + 1))); vector<WCreature> ret; for (int i : All(creatures)) for (Position v : Random.permutation(area)) if (v.canEnter(creatures[i].get())) { ret.push_back(creatures[i].get()); v.addCreature(std::move(creatures[i]), delay); break; } return ret; }
void MainWindow::on_actionNewWindow_triggered() { myDialog *dialog = new myDialog(this); dialog->show(); str *n = new str; QObject::connect(dialog,SIGNAL(Simple(QString)),n,SLOT(Simple(QString))); QObject::connect(dialog,SIGNAL(Invers(QString)),n,SLOT(Inversia(QString))); QObject::connect(dialog,SIGNAL(Register(QString)),n,SLOT(Register(QString))); QObject::connect(dialog,SIGNAL(RegisterAndInvers(QString)),n,SLOT(All(QString))); }
PCreature TimeQueue::removeCreature(Creature* cRef) { int ind = -1; for (int i : All(creatures)) if (creatures[i].get() == cRef) { ind = i; break; } CHECK(ind > -1) << "Creature not found"; PCreature ret = std::move(creatures[ind]); creatures.erase(creatures.begin() + ind); dead.insert(ret.get()); return ret; }
PItem Inventory::removeItem(Item* itemRef) { int ind = -1; for (int i : All(items)) if (items[i].get() == itemRef) { ind = i; break; } CHECK(ind > -1) << "Tried to remove unknown item."; PItem item = std::move(items[ind]); items.erase(items.begin() + ind); removeElement(itemsCache, itemRef); return item; }
int RandomGen::getRandom(const vector<double>& weights, double r) { double sum = 0; for (double elem : weights) sum += elem; if (r == -1) r = Random.getDouble(0, sum); sum = 0; for (int i : All(weights)) { sum += weights[i]; if (sum >= r) return i; } return weights.size() - 1; }
int RandomGen::get(const vector<double>& weights) { double sum = 0; for (double elem : weights) sum += elem; CHECK(sum > 0); double r = getDouble(0, sum); sum = 0; for (int i : All(weights)) { sum += weights[i]; if (sum >= r) return i; } return weights.size() - 1; }
void testRange() { vector<int> a; vector<int> b {0,1,2,3,4,5,6}; for (int x : Range(7)) a.push_back(x); CHECKEQ(a, b); a.clear(); for (int x : Range(2, 6)) a.push_back(x); CHECKEQ(getSubsequence(b, 2, 4), a); a.clear(); for (int x : All(b)) a.push_back(x); CHECKEQ(a, b); }
PItem Inventory::removeItem(Item* itemRef) { int ind = -1; for (int i : All(items)) if (items[i].get() == itemRef) { ind = i; break; } CHECK(ind > -1) << "Tried to remove unknown item."; PItem item = std::move(items[ind]); items.erase(items.begin() + ind); removeElement(itemsCache, itemRef); for (ItemIndex ind : ENUM_ALL(ItemIndex)) if (indexes[ind] && getIndexPredicate(ind)(item.get())) removeElement(*indexes[ind], itemRef); return item; }
void CampaignBuilder::placeVillains(Campaign& campaign, vector<Campaign::SiteInfo::Dweller> villains, const VillainPlacement& placement, int count) { random.shuffle(villains.begin(), villains.end()); for (int i = 0; villains.size() < count; ++i) villains.push_back(villains[i]); if (villains.size() > count) villains.resize(count); vector<Vec2> freePos; for (Vec2 v : campaign.sites.getBounds()) if (!campaign.sites[v].blocked && campaign.sites[v].isEmpty() && placement.xPredicate(v.x)) freePos.push_back(v); freePos = random.permutation(freePos); if (auto& pos = placement.firstLocation) freePos = concat({*pos}, freePos); for (int i : All(villains)) campaign.sites[freePos[i]].dweller = villains[i]; }
optional<OpenalId> AudioDevice::getFreeSource() { RecursiveLock lock(mutex); for (int i : All(sources)) { auto& source = sources[i]; ALint state = 0; AL(alGetSourcei(source.getId(), AL_SOURCE_STATE, &state)); if (state == AL_STOPPED) { // recreating the source does a better job at cleaning up after streaming // without it the old buffer queue still existed source = SoundSource(); return source.getId(); } } if (sources.size() < maxSources) { sources.emplace_back(); return sources.back().getId(); } else return none; }
MoveInfo Behaviour::tryToApplyItem(EffectType type, double maxTurns) { for (int i : All(creature->getSpells())) { SpellInfo spell = creature->getSpells()[i]; if (spell.type == type && creature->canCastSpell(i)) return { 1, [=]() { creature->globalMessage(creature->getTheName() + " casts a spell."); creature->castSpell(i); }}; } auto items = creature->getEquipment().getItems(Item::effectPredicate(type)); for (Item* item : items) if (creature->canApplyItem(item) && item->getApplyTime() <= maxTurns) return { 1, [=]() { creature->globalMessage(creature->getTheName() + " " + item->getApplyMsgThirdPerson(), item->getNoSeeApplyMsg()); creature->applyItem(item); }}; return {0, nullptr}; }
void Compute(graph<vertex>& GA, commandLine P) { long n = GA.n, m = GA.m; uintE* IDs = newA(uintE,n), *prevIDs = newA(uintE,n); {parallel_for(long i=0;i<n;i++) {prevIDs[i] = i; IDs[i] = i;}} //initialize unique IDs bool* all = newA(bool,n); {parallel_for(long i=0;i<n;i++) all[i] = 1;} vertexSubset All(n,n,all); //all vertices bool* active = newA(bool,n); {parallel_for(long i=0;i<n;i++) active[i] = 1;} vertexSubset Active(n,n,active); //initial frontier contains all vertices while(!Active.isEmpty()){ //iterate until IDS converge edgeMap(GA, Active, CC_F(IDs,prevIDs),m/20,no_output); vertexSubset output = vertexFilter(All,CC_Shortcut(IDs,prevIDs)); Active.del(); Active = output; } Active.del(); All.del(); free(IDs); free(prevIDs); }
CostInfo TaskMap<CostInfo>::removeTask(Task* task) { CostInfo cost; if (completionCost.count(task)) { cost = completionCost.at(task); completionCost.erase(task); } if (auto pos = getPosition(task)) marked[*pos] = nullptr; for (int i : All(tasks)) if (tasks[i].get() == task) { removeIndex(tasks, i); break; } if (creatureMap.contains(task)) creatureMap.erase(task); if (positionMap.count(task)) { removeElement(reversePositions[positionMap.at(task)], task); positionMap.erase(task); } return cost; }
void GoRegionBoard::GenBlocksRegions() { if (UpToDate()) return; Clear(); GenBlocks(); for (SgBWIterator it; it; ++it) { SgBlackWhite color(*it); for (SgConnCompIterator it(AllPoints() - All(color), Board().Size()); it; ++it) GenRegion(*it, color); } FindBlocksWithEye(); m_code = Board().GetHashCode(); m_invalid = false; if (HEAVYCHECK) CheckConsistency(); }
void testRange2() { vector<int> a; const vector<int> b {6,5,4,3,2,1,0}; for (int x : Range(6, -1)) a.push_back(x); CHECKEQ(a, b); a.clear(); for (int x : Range(4, 0)) a.push_back(x); CHECKEQ(getSubsequence(b, 2, 4), a); a.clear(); for (int x : All(b)) { a.push_back(b[x]); } CHECKEQ(a, b); a.clear(); for (int x : Range(4, 4)) a.push_back(x); a.clear(); for (int x : Range(4, 3)) a.push_back(x); CHECK(getOnlyElement(a) == 4); }
_loading_options(bool load_all = true) : scene_name(nullptr) { All(load_all); }
_loading_options& Nothing(void) { return All(false); }
void I2C_RL8xxM::AllOff () { All (false); }
void StereoReconstructor::computeRTRandom(std::string cam1Folder, std::string cam2Folder) { bool load1 = loadMatrixAndCoe(cam1Folder, camMatrix1, distCoeffs1); bool load2 = loadMatrixAndCoe(cam2Folder, camMatrix2, distCoeffs2); if (load1 == false || load2 == false) { std::cout << "Load matrix and distortion failed!" << std::endl; return; } std::vector<std::string> imgFiles1 = Utilities::folderImagesScan(cam1Folder.c_str()); std::vector<std::string> imgFiles2 = Utilities::folderImagesScan(cam2Folder.c_str()); cv::Mat img = cv::imread(cam1Folder + imgFiles1[0].c_str(), 1); camImageSize = img.size(); int totalN = imgFiles1.size(); std::ofstream Tx("辅助_T_x.txt"); //x方向位移 std::ofstream Ty("辅助_T_y.txt"); //y方向位移 std::ofstream Tz("辅助_T_z.txt"); //z方向位移 std::ofstream Rx("辅助_R_x.txt"); //旋转轴x方向 std::ofstream Ry("辅助_R_y.txt"); //旋转轴y方向 std::ofstream Rz("辅助_R_z.txt"); //旋转轴z方向 std::ofstream Ra("辅助_R_a.txt"); //旋转角度 std::ofstream All("辅助_All.txt"); //所有数据 All << "Tx " << "Ty " << "Tz " << "T " << "Rx " << "Ry " << "Rz " << "Ra " << std::endl; for (int k = 1; k <= totalN; k++) { std::cout << k; double tbegin = cv::getTickCount(); std::vector<int> nums; while (nums.size() < k) { srand(time(NULL)); int random = rand() % totalN; if (nums.empty() || std::find(nums.begin(), nums.end(), random) == nums.end()) { nums.push_back(random); } } for (size_t i = 0; i < nums.size(); ++i) { imgPoints1.push_back(load2DPoints(cam1Folder + imgFiles1[nums[i]].substr(0, imgFiles1[nums[i]].size() - 4) + "_imgCorners.txt")); imgPoints2.push_back(load2DPoints(cam2Folder + imgFiles2[nums[i]].substr(0, imgFiles2[nums[i]].size() - 4) + "_imgCorners.txt")); objPoints.push_back(load3DPoints(cam1Folder + "ObjCorners.txt")); } cv::Mat E, F; cv::stereoCalibrate(objPoints, imgPoints1, imgPoints2, camMatrix1, distCoeffs1, camMatrix2, distCoeffs2, camImageSize, R, T, E, F, cv::TermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 100, 1e-5), CV_CALIB_FIX_INTRINSIC); //罗德里格斯(Rodrigues)变换 cv::Mat R2T(3, 1, CV_64F); cv::Rodrigues(R, R2T); float tx = Utilities::matGet2D(T, 0, 0); float ty = Utilities::matGet2D(T, 0, 1); float tz = Utilities::matGet2D(T, 0, 2); float T = std::sqrt(tx*tx + ty*ty + tz*tz); Tx << tx << std::endl; Ty << ty << std::endl; Tz << tz << std::endl; double dx = Utilities::matGet2D(R2T, 0, 0); double dy = Utilities::matGet2D(R2T, 0, 1); double dz = Utilities::matGet2D(R2T, 0, 2); double dl = std::sqrt(dx*dx + dy*dy + dz*dz); float angle = dl * 180 / 3.1415926535897932; float fdx = dx / dl; float fdy = dy / dl; float fdz = dz / dl; Rx << fdx << std::endl; Ry << fdy << std::endl; Rz << fdz << std::endl; Ra << angle << std::endl; All << tx << " " << ty << " " << tz << " " << T << " " << fdx << " " << fdy << " " << fdz << " " << angle << std::endl; nums.clear(); imgPoints1.clear(); imgPoints2.clear(); objPoints.clear(); double tend = cv::getTickCount(); double frequency = cv::getTickFrequency(); int span = (tend - tbegin) / frequency; std::cout << "副图像,标定时间 " << span << ",基线长度" << T << std::endl; } Tx.close(); Ty.close(); Tz.close(); Rx.close(); Ry.close(); Rz.close(); Ra.close(); All.close(); }
string lowercase(string s) { for (int i : All(s)) if (isupper(s[i])) s[i] = tolower(s[i]); return s; }
//================================================ void comp_All() { gStyle->SetOptStat(0); All(); //SignalShape(); }
void I2C_RL8xxM::AllOn () { All (true); }
bool DisjointSets::same(const vector<int>& v) { for (int i : All(v)) if (!same(v[i], v[0])) return false; return true; }
optional<Campaign> Campaign::prepareCampaign(View* view, Options* options, RetiredGames&& retired, RandomGen& random) { Vec2 size(16, 9); int numBlocked = 0.6 * size.x * size.y; Table<SiteInfo> terrain = getTerrain(random, size, numBlocked); string worldName = NameGenerator::get(NameGeneratorId::WORLD)->getNext(); options->setDefaultString(OptionId::KEEPER_NAME, NameGenerator::get(NameGeneratorId::FIRST)->getNext()); while (1) { //options->setLimits(OptionId::RETIRED_VILLAINS, 0, min<int>(retired.size(), 4)); options->setLimits(OptionId::MAIN_VILLAINS, 0, 9); options->setLimits(OptionId::LESSER_VILLAINS, 0, 8); options->setLimits(OptionId::ALLIES, 0, 6); options->setLimits(OptionId::INFLUENCE_SIZE, 3, 6); int numRetired = min(retired.getNumActive(), options->getIntValue(OptionId::MAIN_VILLAINS)); int numMain = options->getIntValue(OptionId::MAIN_VILLAINS) - numRetired; int numLesser = options->getIntValue(OptionId::LESSER_VILLAINS); int numAllies = options->getIntValue(OptionId::ALLIES); vector<VillainInfo> mainVillains; while (mainVillains.size() < numMain) append(mainVillains, random.permutation(getMainVillains())); mainVillains.resize(numMain); vector<VillainInfo> lesserVillains; while (lesserVillains.size() < numLesser) append(lesserVillains, random.permutation(getLesserVillains())); lesserVillains.resize(numLesser); vector<VillainInfo> allies; while (allies.size() < numAllies) append(allies, random.permutation(getAllies())); allies.resize(numAllies); Campaign campaign(terrain); campaign.worldName = worldName; vector<Vec2> freePos; for (Vec2 v : Rectangle(size)) if (campaign.sites[v].canEmbark()) freePos.push_back(v); for (int i : All(mainVillains)) { Vec2 pos = random.choose(freePos); removeElement(freePos, pos); campaign.sites[pos].dweller = mainVillains[i]; } vector<RetiredGames::RetiredGame> activeGames = retired.getActiveGames(); for (int i : Range(numRetired)) { Vec2 pos = random.choose(freePos); removeElement(freePos, pos); campaign.sites[pos].dweller = RetiredInfo{activeGames[i].gameInfo, activeGames[i].fileInfo}; } for (int i : All(lesserVillains)) { Vec2 pos = random.choose(freePos); removeElement(freePos, pos); campaign.sites[pos].dweller = lesserVillains[i]; } for (int i : All(allies)) { Vec2 pos = random.choose(freePos); removeElement(freePos, pos); campaign.sites[pos].dweller = allies[i]; } while (1) { bool updateMap = false; campaign.influenceSize = options->getIntValue(OptionId::INFLUENCE_SIZE); campaign.refreshInfluencePos(); CampaignAction action = view->prepareCampaign(campaign, options, retired); switch (action.getId()) { case CampaignActionId::REROLL_MAP: terrain = getTerrain(random, size, numBlocked); worldName = NameGenerator::get(NameGeneratorId::WORLD)->getNext(); options->setDefaultString(OptionId::KEEPER_NAME, NameGenerator::get(NameGeneratorId::FIRST)->getNext()); case CampaignActionId::UPDATE_MAP: updateMap = true; break; case CampaignActionId::UPDATE_OPTION: switch (action.get<OptionId>()) { case OptionId::KEEPER_NAME: case OptionId::INFLUENCE_SIZE: break; default: updateMap = true; break; } break; case CampaignActionId::CANCEL: return none; case CampaignActionId::CHOOSE_SITE: if (campaign.playerPos) campaign.clearSite(*campaign.playerPos); campaign.playerPos = action.get<Vec2>(); campaign.sites[*campaign.playerPos].dweller = PlayerInfo{ViewId::KEEPER}; break; case CampaignActionId::CONFIRM: return campaign; } if (updateMap) break; } } }