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