void SeedFinder::getSeeds(std::string const &read, std::map<int, std::vector<Seed>> &seed_map, std::vector<int> &seeds_of_size, std::vector<int> &map_keys, int &seed_count, int const &seed_min_length) const { //mem finding vector<match_t> matches; //will contain the matches bool print = 0; //not sure what it prints if set to 1 sa_->findMEM(0, read, matches, seed_min_length, print); //parse the results for (int i = 0; i < matches.size(); ++i) { match_t m = matches[i]; int node_nr = binary_node_search(m.ref); int node_start = startOfHit(node_nr, m.ref); seed_map[node_nr].push_back(Seed(node_nr, node_start, m.query, m.len)); while (seeds_of_size.size() <= m.len) { seeds_of_size.push_back(0); } ++seeds_of_size[m.len]; ++seed_count; if (std::find(map_keys.begin(), map_keys.end(), node_nr) == map_keys.end()) { map_keys.push_back(node_nr); } } }
Seed generateSeed (std::string const& passPhrase) { sha512_half_hasher_s h; h(passPhrase.data(), passPhrase.size()); auto const digest = sha512_half_hasher::result_type(h); return Seed({ digest.data(), 16 }); }
boost::optional<Seed> parseBase58 (std::string const& s) { auto const result = decodeBase58Token( s, TokenType::TOKEN_FAMILY_SEED); if (result.empty()) return boost::none; if (result.size() != 16) return boost::none; return Seed(makeSlice(result)); }
void DepthFilter::initializeSeeds(FramePtr frame) { Features new_features; feature_detector_->setExistingFeatures(frame->fts_); feature_detector_->detect(frame.get(), frame->img_pyr_, Config::triangMinCornerScore(), new_features); // initialize a seed for every new feature seeds_updating_halt_ = true; lock_t lock(seeds_mut_); // by locking the updateSeeds function stops ++Seed::batch_counter; std::for_each(new_features.begin(), new_features.end(), [&](Feature* ftr){ seeds_.push_back(Seed(ftr, new_keyframe_mean_depth_, new_keyframe_min_depth_)); }); if(options_.verbose) SVO_INFO_STREAM("DepthFilter: Initialized "<<new_features.size()<<" new seeds"); seeds_updating_halt_ = false; }
void SpinMatrix::Init(const Options& options) { const unsigned int size = m_cols * m_rows; //Tc at 2.26918531421 J = options.J; B = options.B; Seed(); switch (options.startIsing) { case Options::IsingStart::InfiniteTemperature: { Temperature = 10; std::uniform_int_distribution<> d{ 0, 1 }; for (unsigned int i = 0; i < size; ++i) m_spins[i] = (d(rndEngine) ? 1 : -1); Energy = 0; for (unsigned int row = 0; row < m_rows; ++row) for (unsigned int col = 0; col < m_cols; ++col) { Energy += PartSiteEnergy(row, col); Magnetization += GetSpin(row, col); } } break; case Options::IsingStart::ZeroTemperature: Temperature = 0.1; for (unsigned int i = 0; i < size; ++i) m_spins[i] = (options.B > 0 ? -1 : 1); Energy = (-2. - options.B) * size; Magnetization = size * (options.B > 0 ? -1 : 1); break; } setExpMap(); }
std::string HDSeed::Bip32Root(const std::string& fingerprint) const { // TODO: make fingerprint non-const std::string input(fingerprint); std::uint32_t notUsed = 0; auto seed = Seed(input, notUsed); if (!seed) { return ""; } auto start = static_cast<const unsigned char*>(seed->getMemory()); const auto end = start + seed->getMemorySize(); std::vector<unsigned char> bytes(start, end); std::ostringstream stream; stream << std::hex << std::setfill('0'); for (int byte : bytes) { stream << std::setw(2) << byte; } return stream.str(); }
std::shared_ptr<proto::AsymmetricKey> HDSeed::GetStorageKey( std::string& fingerprint) const { std::uint32_t notUsed = 0; auto seed = Seed(fingerprint, notUsed); if (false == bool(seed)) { otErr << OT_METHOD << __FUNCTION__ << ": Unable to load seed." << std::endl; return {}; } proto::HDPath path; path.set_root(fingerprint); path.add_child( static_cast<std::uint32_t>(Bip43Purpose::FS) | static_cast<std::uint32_t>(Bip32Child::HARDENED)); path.add_child( static_cast<std::uint32_t>(Bip32Child::ENCRYPT_KEY) | static_cast<std::uint32_t>(Bip32Child::HARDENED)); return bip32_.GetHDKey(EcdsaCurve::SECP256K1, *seed, path); }
std::shared_ptr<proto::AsymmetricKey> HDSeed::GetPaymentCode( std::string& fingerprint, const std::uint32_t nym) const { std::shared_ptr<proto::AsymmetricKey> output; std::uint32_t notUsed = 0; auto seed = Seed(fingerprint, notUsed); if (!seed) { return output; } proto::HDPath path; path.set_root(fingerprint); path.add_child( static_cast<std::uint32_t>(Bip43Purpose::PAYCODE) | static_cast<std::uint32_t>(Bip32Child::HARDENED)); path.add_child( static_cast<std::uint32_t>(Bip44Type::BITCOIN) | static_cast<std::uint32_t>(Bip32Child::HARDENED)); path.add_child(nym | static_cast<std::uint32_t>(Bip32Child::HARDENED)); output = bip32_.GetHDKey(EcdsaCurve::SECP256K1, *seed, path); return output; }
MATH_BEGIN_NAMESPACE LCG::LCG() { Seed(Clock::TickU32()); }
bool RandomNumberGenerator::Init() { Seed((int32_t)time(0)); return true; }
std::pair <std::vector<StateOfCar>, Seed> AStarSeed::findPathToTarget(const cv::Mat& map, const State& start, const State& goal, const int distance_transform, const int debug_current_state, int& status) { // USE : for guaranteed termination of planner int no_of_iterations = 0; int max_iterations = 10000; node_handle.getParam("local_planner/max_iterations", max_iterations); fusion_map = map; map_max_rows = map.rows; map_max_cols = map.cols; if (distance_transform == 1) { distanceTransform(); } if (debug_current_state) { image = fusion_map.clone(); } StateOfCar start_state(start), target_state(goal); std::map<StateOfCar, open_map_element> open_map; std::map<StateOfCar, StateOfCar, comparatorMapState> came_from; SS::PriorityQueue<StateOfCar> open_set; open_set.push(start_state); if (start_state.isCloseTo(target_state)) { status = 1; return std::make_pair(std::vector<StateOfCar>(), Seed()); } else if (isOnTheObstacle(start_state)) { std::cout << "Bot is on the Obstacle Map \n"; return std::make_pair(std::vector<StateOfCar>(), Seed()); } else if (isOnTheObstacle(target_state)) { std::cout << "Target is on the Obstacle Map \n"; return std::make_pair(std::vector<StateOfCar>(), Seed()); } while (!open_set.empty() && ros::ok()) { if (no_of_iterations > max_iterations) { status = open_set.size(); return std::make_pair(std::vector<StateOfCar>(), Seed()); } StateOfCar current_state = open_set.top(); if (open_map.find(current_state) != open_map.end() && open_map[current_state].membership == CLOSED) { open_set.pop(); } current_state = open_set.top(); if (debug_current_state) { std::cout << "current x : " << current_state.x() << " current y : " << current_state.y() << std::endl; plotPointInMap(current_state); cv::imshow("[PLANNER] Map", image); cvWaitKey(0); } // TODO : use closeTo instead of onTarget if (current_state.isCloseTo(target_state)) { status = 2; return reconstructPath(current_state, came_from); } open_set.pop(); open_map[current_state].membership = UNASSIGNED; open_map[current_state].cost = -current_state.gCost(); open_map[current_state].membership = CLOSED; std::vector<StateOfCar> neighbors_of_current_state = neighborNodesWithSeeds(current_state); for (unsigned int iterator = 0; iterator < neighbors_of_current_state.size(); iterator++) { StateOfCar neighbor = neighbors_of_current_state[iterator]; double tentative_gcost_along_followed_path = neighbor.gCost() + current_state.gCost(); double admissible = neighbor.distanceTo(target_state); double consistent = admissible; if (!((open_map.find(neighbor) != open_map.end()) && (open_map[neighbor].membership == OPEN))) { came_from[neighbor] = current_state; neighbor.hCost(consistent); neighbor.gCost(tentative_gcost_along_followed_path); neighbor.updateTotalCost(); open_set.push(neighbor); open_map[neighbor].membership = OPEN; open_map[neighbor].cost = neighbor.gCost(); } } no_of_iterations++; } status = 0; return std::make_pair(std::vector<StateOfCar>(), Seed()); }
Random() : gen_(Seed()) , dst_(std::numeric_limits<T>::min(), std::numeric_limits<T>::max()) , rand_(gen_, dst_) {}
void ASCRandNumGen::Seed() { Seed(SC_UINT(time(0))); }
void RNG::SeedTime() { Kernal::uint32 t = Watch::GetTime(); Seed(t); }
void sar(char *argv[], unsigned int seed) { RandomLib::Random rng; rng.Reseed(); // List of variables for run conditions: const int num_species = 50; const int num_patches = 300; const int num_step = 5000; const int search_radius = 5; // Species characteristics: const double d = 0.5; // Species mean dispersal distance (shapes dispersal kernel): 1/d const double m = 0.1; // Disturbance probability (disturbance kills individual) const double niche_min = 0.1; // Competitive strength of empty cells const double emi_from_out = 0.001; // Seed bank array2Ddouble E; array2Dint occupied; array2Dint disturbance_counter; SetArraySize2d(E, num_patches, num_patches); SetArraySize2d(occupied, num_patches, num_patches); SetArraySize2d(disturbance_counter, num_patches, num_patches); // List of global species characteristic parameters (read in from file or defined in main function): double *h = new double[num_species]; double *u = new double[num_species]; double *c = new double[num_species]; double *sigma = new double[num_species]; // read in species characteristics from file char buffer[100]; sprintf(buffer, "%s_st.txt", argv[1]); std::ifstream input_traits(buffer); for (int i = 0; i < num_species; ++i) { input_traits >> sigma[i]; // Niche width input_traits >> h[i]; // Performance at niche optimum (height, y at maximum) input_traits >> c[i]; // Seed production input_traits >> u[i]; // Resource at niche optimum (location, x at maximum) } input_traits.close(); sprintf(buffer, "%s_species.txt", argv[1]); std::ifstream input_species(buffer); { int i = 0, j = 0; while (!input_species.eof()) { input_species >> i; input_species >> j; input_species >> E[i][j]; input_species >> occupied[i][j]; input_species >> disturbance_counter[i][j]; } } input_species.close(); for (int block = 0; block < 1; ++block) { sprintf(buffer, "%s_dest%d.txt", argv[1], block); std::ifstream input_dest(buffer); for (int i = 0; i < num_patches; ++i) { for (int j = 0; j < num_patches; ++j) { disturbance_counter[i][j] = 0; // occupied[i][j] = 0; } } // Removed the input_dest as a matrix and replaced by a list (see next loop). // for (int i = 0; i < num_patches; ++i) // { // for (int j = 0; j < num_patches; ++j) // { // input_dest >> E[i][j]; // } // } // The input file is now x,y,E with 90000 lines { int i = 0, j = 0; while (!input_dest.eof()) { input_dest >> i; input_dest >> j; input_dest >> E[i][j]; } } input_dest.close(); // for (int x = 0; x < num_patches; x++) // { // for (int y = 0; y < num_patches; y++) // { // const int s = (int)(rng.Fixed() * num_species); // Select a species at random // occupied[x][y] = NICHE_F(h[s], u[s], E[x][y], sigma[s]) < niche_min ? EMPTY : s; // } // } double all_possible_seeds = 0; for (int dx = -search_radius; dx <= search_radius; dx++) { for (int dy = -search_radius; dy <= search_radius; dy++) { if ((dx != 0) || (dy != 0)) { all_possible_seeds += exp(-d * sqrt(dx * dx + dy * dy)); } } } all_possible_seeds += emi_from_out * num_species; for (int t = 0; t < num_step; ++t) { for (int cell = 0; cell < num_patches * num_patches; cell++) { const int x = (int)(rng.Fixed() * num_patches); const int y = (int)(rng.Fixed() * num_patches); if(rng.Fixed() < m) { occupied[x][y] = EMPTY; ++disturbance_counter[x][y]; // BR } double Niche_res = niche_min; if (occupied[x][y] != EMPTY) { int i = occupied[x][y]; Niche_res = NICHE_F(h[i], u[i], E[x][y], sigma[i]); } std::vector<double> Seed(num_species, 0.0); const int dx_min = (x - search_radius < 0) ? -x : -search_radius; const int dx_max = (x + search_radius >= num_patches) ? num_patches - 1 - x : search_radius; const int dy_min = (y - search_radius < 0) ? -y : -search_radius; const int dy_max = (y + search_radius >= num_patches) ? num_patches - 1 - y : search_radius; assert(x + dx_min >= 0 && x + dx_max < num_patches); assert(y + dy_min >= 0 && y + dy_max < num_patches); for (int dx = dx_min; dx <= dx_max; ++dx) { for (int dy = dy_min; dy <= dy_max; ++dy) { if (((dx != 0) || (dy != 0)) && (occupied[x + dx][y + dy] != EMPTY)) { int i = occupied[x + dx][y + dy]; if (NICHE_F(h[i], u[i], E[x][y], sigma[i]) > Niche_res) { Seed[i] += c[i] * (exp(-d * sqrt(dx * dx + dy * dy))); } } } } double all_seeds = 0.0; for (int i = 0; i < num_species; ++i) { if (NICHE_F(h[i], u[i], E[x][y], sigma[i]) > Niche_res) { Seed[i] += emi_from_out; } all_seeds += Seed[i]; } bool total_colon = false; if (all_seeds / all_possible_seeds > rng.Fixed()) { total_colon = true; } std::vector<double> Prob_recruit(num_species, 0.0); if (total_colon == true) { //Prob_recruit[0] = Colon[0]/double(total_colon); Prob_recruit[0] = Seed[0] / all_seeds; for (int i = 1; i < num_species; ++i) { Prob_recruit[i] = Seed[i] / all_seeds + Prob_recruit[i-1]; } occupied[x][y] = EMPTY; double randnumb = rng.Fixed(); for (int i = 0; i < num_species; i++) { if (randnumb < Prob_recruit[i]) { assert(NICHE_F(h[i], u[i], E[x][y], sigma[i]) > niche_min); occupied[x][y] = i; break; } } } } // ends loop over cells } // ends loop t sprintf(buffer, "%s_out200_%d.txt", argv[1], block); std::ofstream out(buffer); for (int x = 0; x < num_patches; ++x) { for (int y = 0; y < num_patches; ++y) { out << x << " " << y << " " << E[x][y] << " " << occupied[x][y] << " " << disturbance_counter[x][y] << "\n"; } } out.close(); } }
void AIClientApp::HandleMessage(const Message& msg) { //DebugLogger() << "AIClientApp::HandleMessage " << msg.Type(); switch (msg.Type()) { case Message::ERROR_MSG: { ErrorLogger() << "AIClientApp::HandleMessage : Received ERROR message from server: " << msg.Text(); break; } case Message::HOST_ID: { const std::string& text = msg.Text(); int host_id = Networking::INVALID_PLAYER_ID; if (text.empty()) { ErrorLogger() << "AIClientApp::HandleMessage for HOST_ID : Got empty message text?!"; } else { try { host_id = boost::lexical_cast<int>(text); } catch(const boost::bad_lexical_cast& ex) { ErrorLogger() << "AIClientApp::HandleMessage for HOST_ID : Couldn't parse message text \"" << text << "\": " << ex.what(); } } m_networking->SetHostPlayerID(host_id); break; } case Message::JOIN_GAME: { if (PlayerID() == Networking::INVALID_PLAYER_ID) { DebugLogger() << "AIClientApp::HandleMessage : Received JOIN_GAME acknowledgement"; try { int player_id; boost::uuids::uuid cookie; // ignore ExtractJoinAckMessageData(msg, player_id, cookie); m_networking->SetPlayerID(player_id); } catch(const boost::bad_lexical_cast& ex) { ErrorLogger() << "AIClientApp::HandleMessage for JOIN_GAME : Couldn't parse message text \"" << msg.Text() << "\": " << ex.what(); } } else { ErrorLogger() << "AIClientApp::HandleMessage : Received erroneous JOIN_GAME acknowledgement when already in a game"; } break; } case Message::GAME_START: { DebugLogger() << "AIClientApp::HandleMessage : Received GAME_START message; starting AI turn..."; bool single_player_game; // ignored bool loaded_game_data; bool ui_data_available; // ignored SaveGameUIData ui_data; // ignored bool state_string_available; // ignored, as save_state_string is sent even if not set by ExtractMessageData std::string save_state_string; m_empire_status.clear(); ExtractGameStartMessageData(msg, single_player_game, m_empire_id, m_current_turn, m_empires, m_universe, GetSpeciesManager(), GetCombatLogManager(), GetSupplyManager(), m_player_info, m_orders, loaded_game_data, ui_data_available, ui_data, state_string_available, save_state_string, m_galaxy_setup_data); DebugLogger() << "Extracted GameStart message for turn: " << m_current_turn << " with empire: " << m_empire_id; GetUniverse().InitializeSystemGraph(m_empire_id); DebugLogger() << "Message::GAME_START loaded_game_data: " << loaded_game_data; if (loaded_game_data) { TraceLogger() << "Message::GAME_START save_state_string: " << save_state_string; m_AI->ResumeLoadedGame(save_state_string); Orders().ApplyOrders(); } else { DebugLogger() << "Message::GAME_START Starting New Game!"; // % Distribution of aggression levels // Aggression : 0 1 2 3 4 5 (0=Beginner, 5=Maniacal) // __ __ __ __ __ __ //Max 0 :100 0 0 0 0 0 //Max 1 : 25 75 0 0 0 0 //Max 2 : 0 25 75 0 0 0 //Max 3 : 0 0 25 75 0 0 //Max 4 : 0 0 0 25 75 0 //Max 5 : 0 0 0 0 25 75 // Optional aggression table, possibly for 0.4.4+? // Aggression : 0 1 2 3 4 5 (0=Beginner, 5=Maniacal) // __ __ __ __ __ __ //Max 0 :100 0 0 0 0 0 //Max 1 : 25 75 0 0 0 0 //Max 2 : 8 17 75 0 0 0 //Max 3 : 0 8 17 75 0 0 //Max 4 : 0 0 8 17 75 0 //Max 5 : 0 0 0 8 17 75 const std::string g_seed = GetGalaxySetupData().m_seed; const std::string emp_name = GetEmpire(m_empire_id)->Name(); unsigned int my_seed = 0; try { // generate consistent my_seed values from galaxy seed & empire name. boost::hash<std::string> string_hash; std::size_t h = string_hash(g_seed); my_seed = 3 * static_cast<unsigned int>(h) * static_cast<unsigned int>(string_hash(emp_name)); DebugLogger() << "Message::GAME_START getting " << emp_name << " AI aggression, RNG Seed: " << my_seed; } catch (...) { DebugLogger() << "Message::GAME_START getting " << emp_name << " AI aggression, could not initialise RNG."; } int rand_num = 0; int this_aggr = m_max_aggression; if (this_aggr > 0 && my_seed > 0) { Seed(my_seed); rand_num = RandSmallInt(0, 99); // if it's in the top 25% then decrease aggression. if (rand_num > 74) this_aggr--; // Leaving the following as commented out code for now. Possibly for 0.4.4+? // in the top 8% ? decrease aggression again, unless it's already as low as it gets. // if (rand_num > 91 && this_aggr > 0) this_aggr--; } DebugLogger() << "Message::GAME_START setting AI aggression as " << this_aggr << " (from rnd " << rand_num << "; max aggression " << m_max_aggression << ")"; m_AI->SetAggression(this_aggr); m_AI->StartNewGame(); } m_AI->GenerateOrders(); break; } case Message::SAVE_GAME_COMPLETE: break; case Message::TURN_UPDATE: { //DebugLogger() << "AIClientApp::HandleMessage : extracting turn update message data"; ExtractTurnUpdateMessageData(msg, m_empire_id, m_current_turn, m_empires, m_universe, GetSpeciesManager(), GetCombatLogManager(), GetSupplyManager(), m_player_info); //DebugLogger() << "AIClientApp::HandleMessage : generating orders"; GetUniverse().InitializeSystemGraph(m_empire_id); m_AI->GenerateOrders(); //DebugLogger() << "AIClientApp::HandleMessage : done handling turn update message"; break; } case Message::TURN_PARTIAL_UPDATE: ExtractTurnPartialUpdateMessageData(msg, m_empire_id, m_universe); break; case Message::TURN_PROGRESS: { Message::TurnProgressPhase phase_id; ExtractTurnProgressMessageData(msg, phase_id); ClientApp::HandleTurnPhaseUpdate(phase_id); break; } case Message::PLAYER_STATUS: break; case Message::END_GAME: { DebugLogger() << "Message::END_GAME : Exiting"; DebugLogger() << "Acknowledge server shutdown message."; Networking().SendMessage(AIEndGameAcknowledgeMessage()); ExitApp(0); break; } case Message::PLAYER_CHAT: { std::string data; int player_id; boost::posix_time::ptime timestamp; ExtractServerPlayerChatMessageData(msg, player_id, timestamp, data); m_AI->HandleChatMessage(player_id, data); break; } case Message::DIPLOMACY: { DiplomaticMessage diplo_message; ExtractDiplomacyMessageData(msg, diplo_message); m_AI->HandleDiplomaticMessage(diplo_message); break; } case Message::DIPLOMATIC_STATUS: { DiplomaticStatusUpdateInfo diplo_update; ExtractDiplomaticStatusMessageData(msg, diplo_update); m_AI->HandleDiplomaticStatusUpdate(diplo_update); break; } case Message::LOGGER_CONFIG: { std::set<std::tuple<std::string, std::string, LogLevel>> options; ExtractLoggerConfigMessageData(msg, options); SetLoggerThresholds(options); break; } case Message::CHECKSUM: { TraceLogger() << "(AIClientApp) CheckSum."; VerifyCheckSum(msg); break; } default: { ErrorLogger() << "AIClientApp::HandleMessage : Received unknown Message type code " << msg.Type(); break; } } //DebugLogger() << "AIClientApp::HandleMessage done"; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // TRandom::TRandom // //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ TRandom::TRandom() { Seed(12345); }
//---------------------------------------------------------------- unsigned int SeedT(){ return Seed(); }
unsigned RandomGen::Seed() { unsigned seed = (unsigned)time(NULL); return Seed(seed); }
// Open libraries void startup_open_libraries() { BPTR file; long seed=0; // Open the other libraries that we need if (!(GfxBase=(struct GfxBase *)main_open_library("graphics.library",37)) || !(IntuitionBase=(struct IntuitionBase *)main_open_library("intuition.library",37)) || !(LayersBase=main_open_library("layers.library",37)) || !(DiskfontBase=main_open_library("diskfont.library",36)) || !(IconBase=main_open_library("icon.library",37)) || !(WorkbenchBase=main_open_library("workbench.library",37)) || !(CxBase=main_open_library("commodities.library",37)) || !(UtilityBase=(struct UtilityBase *)main_open_library("utility.library",37)) || !(GadToolsBase=main_open_library("gadtools.library",37)) || !(RexxSysBase=main_open_library("rexxsyslib.library",0)) || !(AslBase=main_open_library("asl.library",37))) quit(0); #ifdef __amigaos4__ // obtain ifaces if (!(IGraphics=(struct GraphicsIFace *)GetInterface((struct Library *)GfxBase,"main",1,NULL)) || !(IIntuition=(struct IntuitionIFace *)GetInterface((struct Library *)IntuitionBase,"main",1,NULL)) || !(ILayers=(struct LayersIFace *)GetInterface(LayersBase,"main",1,NULL)) || !(IDiskfont=(struct DiskfontIFace *)GetInterface(DiskfontBase,"main",1,NULL)) || !(IIcon=(struct IconIFace *)GetInterface(IconBase,"main",1,NULL)) || !(IWorkbench=(struct WorkbenchIFace *)GetInterface(WorkbenchBase,"main",1,NULL)) || !(ICommodities=(struct CommoditiesIFace *)GetInterface(CxBase,"main",1,NULL)) || !(IUtility=(struct UtilityIFace *)GetInterface((struct Library *)UtilityBase,"main",1,NULL)) || !(IGadTools=(struct GadToolsIFace *)GetInterface(GadToolsBase,"main",1,NULL)) || !(IRexxSys=(struct RexxSysIFace *)GetInterface(RexxSysBase,"main",1,NULL)) || !(IAsl=(struct AslIFace *)GetInterface(AslBase,"main",1,NULL))) quit(0); #endif // Some other useful libraries DataTypesBase=OpenLibrary("datatypes.library",0); AmigaGuideBase=OpenLibrary("amigaguide.library",0); NewIconBase=OpenLibrary("newicon.library",0); #ifdef __amigaos4__ IDataTypes=(struct DataTypesIFace *)GetInterface(DataTypesBase,"main",1,NULL); IAmigaGuide=(struct AmigaGuideIFace *)GetInterface(AmigaGuideBase,"main",1,NULL); INewIcon=(struct NewIconIFace *)GetInterface(NewIconBase,"main",1,NULL); #endif // Is CyberGfx library already in system? If so, open it for ourselves if (FindName(&SysBase->LibList,"cybergraphics.library")) { CyberGfxBase=OpenLibrary("cybergraphics.library",0); #ifdef __amigaos4__ ICyberGfx=(struct CyberGfxIFace *)GetInterface(CyberGfxBase,"main",1,NULL); #endif } // Get input.device base #ifdef __AROS__ input_req.io_Message.mn_Length = sizeof(input_req); #endif if (!OpenDevice("input.device",0,(struct IORequest *)&input_req,0)) { InputBase=(struct Library *)input_req.io_Device; #ifdef __amigaos4__ IInput = (struct InputIFace *)GetInterface(InputBase,"main",1,NULL); #endif } // Get timer.device base if (!OpenDevice("timer.device",0,(struct IORequest *)&timer_req,0)) { TimerBase=(APTR)timer_req.io_Device; #ifdef __amigaos4__ ITimer = (struct TimerIFace *)GetInterface((struct Library *)TimerBase,"main",1,NULL); #endif } else { quit(0); } // Get console.device base if (!OpenDevice("console.device",-1,(struct IORequest *)&console_req,0)) { ConsoleDevice=(APTR)console_req.io_Device; #ifdef __amigaos4__ IConsole = (struct ConsoleIFace *)GetInterface((struct Library *)ConsoleDevice,"main",1,NULL); #endif } else { quit(0); }; // Seed random number with something interesting if ((file=Open("dopus5:system/seed",MODE_OLDFILE))) { char buf[20]; Read(file,buf,20); Close(file); seed=atoi((buf[0]=='-'?buf+1:buf)); } seed+=(long)IntuitionBase+(long)AslBase*(long)WorkbenchBase*IntuitionBase->Micros; Seed(seed); }
Random::Random() { Seed(static_cast<unsigned int>(time(nullptr))); }
Random::Random(unsigned int p_Seed) { Seed(p_Seed); }
void AutoResolveCombat(CombatInfo& combat_info) { if (combat_info.objects.Empty()) return; const System* system = combat_info.objects.Object<System>(combat_info.system_id); if (!system) Logger().errorStream() << "AutoResolveCombat couldn't get system with id " << combat_info.system_id; else Logger().debugStream() << "AutoResolveCombat at " << system->Name(); if (GetOptionsDB().Get<bool>("verbose-logging")) { Logger().debugStream() << "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"; Logger().debugStream() << "AutoResolveCombat objects before resolution: " << combat_info.objects.Dump(); } // reasonably unpredictable but reproducible random seeding const int base_seed = combat_info.objects.begin()->first + CurrentTurn(); // compile list of valid objects to attack or be attacked in this combat std::set<int> valid_target_object_ids; // all objects that can be attacked std::set<int> valid_attacker_object_ids; // all objects that can attack std::map<int, std::set<int> > empire_valid_attacker_object_ids; // objects that can attack that each empire owns float monster_detection = 0.0; for (ObjectMap::iterator it = combat_info.objects.begin(); it != combat_info.objects.end(); ++it) { const UniverseObject* obj = it->second; //Logger().debugStream() << "Considerting object " << obj->Name() << " owned by " << obj->Owner(); if (ObjectCanAttack(obj)) { //Logger().debugStream() << "... can attack"; valid_attacker_object_ids.insert(it->first); empire_valid_attacker_object_ids[obj->Owner()].insert(it->first); } if (ObjectCanBeAttacked(obj)) { //Logger().debugStream() << "... can be attacked"; valid_target_object_ids.insert(it->first); } if (obj->Unowned() && obj->ObjectType() == OBJ_SHIP) monster_detection = std::max(monster_detection, obj->CurrentMeterValue(METER_DETECTION)); } // map from empire to set of IDs of objects that empire's objects // could potentially target. std::map<int, std::set<int> > empire_valid_target_object_ids; // objects that each empire can attack for (std::set<int>::const_iterator target_it = valid_target_object_ids.begin(); target_it != valid_target_object_ids.end(); ++target_it) { int object_id = *target_it; const UniverseObject* obj = combat_info.objects.Object(object_id); //Logger().debugStream() << "Considering attackability of object " << obj->Name() << " owned by " << obj->Owner(); // for all empires, can they attack this object? for (std::set<int>::const_iterator empire_it = combat_info.empire_ids.begin(); empire_it != combat_info.empire_ids.end(); ++empire_it) { int attacking_empire_id = *empire_it; if (attacking_empire_id == ALL_EMPIRES) { if (ObjectAttackableByMonsters(obj, monster_detection)) { //Logger().debugStream() << "object: " << obj->Name() << " attackable by monsters"; empire_valid_target_object_ids[ALL_EMPIRES].insert(object_id); } } else { // call function to find if empires can attack objects... if (ObjectAttackableByEmpire(obj, attacking_empire_id)) { //Logger().debugStream() << "object: " << obj->Name() << " attackable by empire " << attacking_empire_id; empire_valid_target_object_ids[attacking_empire_id].insert(object_id); } } } } // Each combat "round" a randomly-selected object in the battle attacks // something, if it is able to do so. The number of rounds scales with the // number of objects, so the total actions per object is independent of // number of objects in the battle const int NUM_COMBAT_ROUNDS = 3*valid_attacker_object_ids.size(); for (int round = 1; round <= NUM_COMBAT_ROUNDS; ++round) { Seed(base_seed + round); // ensure each combat round produces different results // ensure something can attack and something can be attacked if (valid_attacker_object_ids.empty()) { Logger().debugStream() << "Nothing left can attack; combat over"; break; } if (empire_valid_target_object_ids.empty()) { Logger().debugStream() << "Nothing left can be attacked; combat over"; break; } // empires may have valid targets, but nothing to attack with. If all // empires have no attackers or no valid targers, combat is over bool someone_can_attack_something = false; for (std::map<int, std::set<int> >::const_iterator attacker_it = empire_valid_attacker_object_ids.begin(); attacker_it != empire_valid_attacker_object_ids.end(); ++attacker_it) { if (empire_valid_target_object_ids.find(attacker_it->first) != empire_valid_target_object_ids.end()) { someone_can_attack_something = true; break; } } if (!someone_can_attack_something) { Logger().debugStream() << "No empire has valid targets and something to attack with; combat over."; break; } Logger().debugStream() << "Combat at " << system->Name() << " (" << combat_info.system_id << ") Round " << round; // select attacking object in battle SmallIntDistType attacker_id_num_dist = SmallIntDist(0, valid_attacker_object_ids.size() - 1); std::set<int>::const_iterator attacker_it = valid_attacker_object_ids.begin(); std::advance(attacker_it, attacker_id_num_dist()); assert(attacker_it != valid_attacker_object_ids.end()); int attacker_id = *attacker_it; UniverseObject* attacker = combat_info.objects.Object(attacker_id); if (!attacker) { Logger().errorStream() << "AutoResolveCombat couldn't get object with id " << attacker_id; continue; } Logger().debugStream() << "Attacker: " << attacker->Name(); Ship* attack_ship = universe_object_cast<Ship*>(attacker); Planet* attack_planet = universe_object_cast<Planet*>(attacker); // loop over weapons of attacking object. each gets a shot at a // randomly selected target object std::vector<PartAttackInfo> weapons; if (attack_ship) { weapons = ShipWeaponsStrengths(attack_ship); for (std::vector<PartAttackInfo>::const_iterator part_it = weapons.begin(); part_it != weapons.end(); ++part_it) { Logger().debugStream() << "weapon: " << part_it->part_type_name << " attack: " << part_it->part_attack; } } else if (attack_planet) { // treat planet defenses as short range weapons.push_back(PartAttackInfo(PC_SHORT_RANGE, "", attack_planet->CurrentMeterValue(METER_DEFENSE))); } if (weapons.empty()) { Logger().debugStream() << "no weapons' can't attack"; continue; // no ability to attack! } for (std::vector<PartAttackInfo>::const_iterator weapon_it = weapons.begin(); weapon_it != weapons.end(); ++weapon_it) { // select object from valid targets for this object's owner TODO: with this weapon... Logger().debugStream() << "Attacking with weapon " << weapon_it->part_type_name << " with power " << weapon_it->part_attack; // get valid targets set for attacker owner. need to do this for // each weapon that is attacking, as the previous shot might have // destroyed something int attacker_owner_id = attacker->Owner(); std::map<int, std::set<int> >::iterator target_vec_it = empire_valid_target_object_ids.find(attacker_owner_id); if (target_vec_it == empire_valid_target_object_ids.end()) { Logger().debugStream() << "No targets for attacker with id: " << attacker_owner_id; break; } const std::set<int>& valid_target_ids = target_vec_it->second; if (valid_target_ids.empty()) break; // should be redundant with this entry being erased when emptied // select target object SmallIntDistType target_id_num_dist = SmallIntDist(0, valid_target_ids.size() - 1); std::set<int>::const_iterator target_it = valid_target_ids.begin(); std::advance(target_it, target_id_num_dist()); assert(target_it != valid_target_ids.end()); int target_id = *target_it; UniverseObject* target = combat_info.objects.Object(target_id); if (!target) { Logger().errorStream() << "AutoResolveCombat couldn't get target object with id " << target_id; continue; } Logger().debugStream() << "Target: " << target->Name(); // do actual attacks, and mark attackers as valid targets for attacked object's owners if (attack_ship) { if (Ship* target_ship = universe_object_cast<Ship*>(target)) { AttackShipShip(attack_ship, weapon_it->part_attack, target_ship, combat_info.damaged_object_ids); empire_valid_target_object_ids[target_ship->Owner()].insert(attacker_id); } else if (Planet* target_planet = universe_object_cast<Planet*>(target)) { AttackShipPlanet(attack_ship, weapon_it->part_attack, target_planet, combat_info.damaged_object_ids); empire_valid_target_object_ids[target_planet->Owner()].insert(attacker_id); } } else if (attack_planet) { if (Ship* target_ship = universe_object_cast<Ship*>(target)) { AttackPlanetShip(attack_planet, target_ship, combat_info.damaged_object_ids); empire_valid_target_object_ids[target_ship->Owner()].insert(attacker_id); } else if (Planet* target_planet = universe_object_cast<Planet*>(target)) { AttackPlanetPlanet(attack_planet, target_planet, combat_info.damaged_object_ids); empire_valid_target_object_ids[target_planet->Owner()].insert(attacker_id); } } // check for destruction of target object if (target->ObjectType() == OBJ_SHIP) { if (target->CurrentMeterValue(METER_STRUCTURE) <= 0.0) { Logger().debugStream() << "!! Target Ship is destroyed!"; // object id destroyed combat_info.destroyed_object_ids.insert(target_id); // all empires in battle know object was destroyed for (std::set<int>::const_iterator it = combat_info.empire_ids.begin(); it != combat_info.empire_ids.end(); ++it) { int empire_id = *it; if (empire_id != ALL_EMPIRES) combat_info.destroyed_object_knowers[empire_id].insert(target_id); } // remove destroyed ship's ID from lists of valid attackers and targets valid_attacker_object_ids.erase(target_id); valid_target_object_ids.erase(target_id); // probably not necessary as this set isn't used in this loop for (target_vec_it = empire_valid_target_object_ids.begin(); target_vec_it != empire_valid_target_object_ids.end(); ++target_vec_it) { target_vec_it->second.erase(target_id); } for (target_vec_it = empire_valid_attacker_object_ids.begin(); target_vec_it != empire_valid_attacker_object_ids.end(); ++target_vec_it) { target_vec_it->second.erase(target_id); } // TODO: only erase from owner's entry in this list } } else if (target->ObjectType() == OBJ_PLANET) { if (target->CurrentMeterValue(METER_SHIELD) <= 0.0 && target->CurrentMeterValue(METER_DEFENSE) <= 0.0 && target->CurrentMeterValue(METER_CONSTRUCTION) <= 0.0) { Logger().debugStream() << "!! Target Planet is knocked out of battle"; // remove disabled planet's ID from lists of valid attackers and targets valid_attacker_object_ids.erase(target_id); valid_target_object_ids.erase(target_id); // probably not necessary as this set isn't used in this loop for (target_vec_it = empire_valid_target_object_ids.begin(); target_vec_it != empire_valid_target_object_ids.end(); ++target_vec_it) { target_vec_it->second.erase(target_id); } for (target_vec_it = empire_valid_attacker_object_ids.begin(); target_vec_it != empire_valid_attacker_object_ids.end(); ++target_vec_it) { target_vec_it->second.erase(target_id); } // TODO: only erase from owner's entry in this list } } // check if any empire has no remaining target or attacker objects. // If so, remove that empire's entry std::map<int, std::set<int> > temp = empire_valid_target_object_ids; for (target_vec_it = empire_valid_target_object_ids.begin(); target_vec_it != empire_valid_target_object_ids.end(); ++target_vec_it) { if (target_vec_it->second.empty()) { temp.erase(target_vec_it->first); Logger().debugStream() << "No valid targets left for empire with id: " << target_vec_it->first; } } empire_valid_target_object_ids = temp; temp = empire_valid_attacker_object_ids; for (target_vec_it = empire_valid_attacker_object_ids.begin(); target_vec_it != empire_valid_attacker_object_ids.end(); ++target_vec_it) { if (target_vec_it->second.empty()) { temp.erase(target_vec_it->first); Logger().debugStream() << "No valid attacking objects left for empire with id: " << target_vec_it->first; } } empire_valid_attacker_object_ids = temp; } // end for over weapons } // end for over combat arounds // ensure every participant knows what happened. // TODO: assemble list of objects to copy for each empire. this should // include objects the empire already knows about with standard // visibility system, and also any objects the empire knows are // destroyed or for (std::map<int, ObjectMap>::iterator it = combat_info.empire_known_objects.begin(); it != combat_info.empire_known_objects.end(); ++it) { it->second.Copy(combat_info.objects); } if (GetOptionsDB().Get<bool>("verbose-logging")) Logger().debugStream() << "AutoResolveCombat objects after resolution: " << combat_info.objects.Dump(); }
std::pair<std::vector<StateOfCar>, Seed> AStarSeed::findPathToTargetWithAstar(const cv::Mat& img,const State& start,const State& goal) { // USE : for garanteed termination of planner int no_of_iterations = 0; fusionMap = img; MAP_MAX_ROWS = img.rows; MAP_MAX_COLS = img.cols; if(DT==1) distanceTransform(); if (DEBUG) { image = fusionMap.clone(); } StateOfCar startState(start), targetState(goal); std::map<StateOfCar, open_map_element> openMap; std::map<StateOfCar,StateOfCar, comparatorMapState> came_from; SS::PriorityQueue<StateOfCar> openSet; openSet.push(startState); if (startState.isCloseTo(targetState)) { std::cout<<"Bot is On Target"<<std::endl; return std::make_pair(std::vector<StateOfCar>(), Seed()); } else if(isOnTheObstacle(startState)){ std::cout<<"Bot is on the Obstacle Map \n"; return std::make_pair(std::vector<StateOfCar>(), Seed()); } else if(isOnTheObstacle(targetState)){ std::cout<<"Target is on the Obstacle Map \n"; return std::make_pair(std::vector<StateOfCar>(), Seed()); } while (!openSet.empty() && ros::ok()) { // std::cout<<"openSet size : "<<openSet.size()<<"\n"; if(no_of_iterations > MAX_ITERATIONS){ std::cerr<<"Overflow : openlist size : "<<openSet.size()<<"\n"; return std::make_pair(std::vector<StateOfCar>(), Seed()); } StateOfCar currentState=openSet.top(); if (openMap.find(currentState)!=openMap.end() && openMap[currentState].membership == CLOSED) { openSet.pop(); } currentState=openSet.top(); if (DEBUG) { std::cout<<"current x : "<<currentState.x()<<" current y : "<<currentState.y()<<std::endl; plotPointInMap(currentState); cv::imshow("[PLANNER] Map", image); cvWaitKey(0); } // TODO : use closeTo instead of onTarget if (currentState.isCloseTo(targetState)) { std::cout<<"openSet size : "<<openSet.size()<<"\n"; // std::cout<<"Target Reached"<<std::endl; return reconstructPath(currentState, came_from); } openSet.pop(); openMap[currentState].membership = UNASSIGNED; openMap[currentState].cost=-currentState.gCost(); openMap[currentState].membership=CLOSED; std::vector<StateOfCar> neighborsOfCurrentState = neighborNodesWithSeeds(currentState); for (unsigned int iterator=0; iterator < neighborsOfCurrentState.size(); iterator++) { StateOfCar neighbor = neighborsOfCurrentState[iterator]; double tentativeGCostAlongFollowedPath = neighbor.gCost() + currentState.gCost(); double admissible = neighbor.distanceTo(targetState); double consistent = admissible; double intensity = fusionMap.at<uchar>(neighbor.y(), neighbor.x()); double consistentAndIntensity = (neighbor.hCost()*neighbor.hCost()+2 + intensity*intensity)/(neighbor.hCost()+intensity+2); if (!((openMap.find(neighbor) != openMap.end()) && (openMap[neighbor].membership == OPEN))) { came_from[neighbor] = currentState; neighbor.gCost( tentativeGCostAlongFollowedPath) ; if(DT==1) neighbor.hCost(consistentAndIntensity); else neighbor.hCost( consistent) ; neighbor.updateTotalCost(); openSet.push(neighbor); openMap[neighbor].membership = OPEN; openMap[neighbor].cost = neighbor.gCost(); } } no_of_iterations++; } std::cerr<<"NO PATH FOUND"<<std::endl; return std::make_pair(std::vector<StateOfCar>(), Seed()); }