void print_inputs(Inputs in, int nprocs, int version ) { // Calculate Estimate of Memory Usage int mem_tot = estimate_mem_usage( in ); logo(version); center_print("INPUT SUMMARY", 79); border_print(); #ifdef VERIFICATION printf("Verification Mode: on\n"); #endif printf("Materials: %d\n", 12); printf("H-M Benchmark Size: %s\n", in.HM); printf("Total Nuclides: %ld\n", in.n_isotopes); printf("Gridpoints (per Nuclide): "); fancy_int(in.n_gridpoints); printf("Unionized Energy Gridpoints: "); fancy_int(in.n_isotopes*in.n_gridpoints); printf("XS Lookups: "); fancy_int(in.lookups); #ifdef DOMPI printf("MPI Ranks: %d\n", nprocs); printf("OMP Threads per MPI Rank: %d\n", in.nthreads); printf("Mem Usage per MPI Rank (MB): "); fancy_int(mem_tot); #else printf("Threads: %d\n", in.nthreads); printf("Est. Memory Usage (MB): "); fancy_int(mem_tot); #endif border_print(); center_print("INITIALIZATION", 79); border_print(); }
void inventory_selector::draw( WINDOW *w ) const { mvwprintw( w, 0, 0, title.c_str() ); // Position of inventory columns is adaptive. They're aligned to the left if they occupy less than 2/3 of the screen. // Otherwise they're aligned symmetrically to the center of the screen. static const float min_ratio_to_center = 1.f / 3; const int free_space = getmaxx( w ) - get_columns_width(); const bool center_align = std::abs( float( free_space ) / getmaxx( w ) ) <= min_ratio_to_center; const int max_gap = ( columns.size() > 1 ) ? free_space / ( int( columns.size() ) - 1 ) : 0; const int gap = center_align ? max_gap : std::min<int>( max_gap, 4 ); const int gap_rounding_error = ( center_align && columns.size() > 1 ) ? free_space % ( columns.size() - 1 ) : 0; size_t x = 1; size_t y = 2; size_t active_x = 0; for( const auto &column : columns ) { if( &column == &columns.back() ) { x += gap_rounding_error; } if( !is_active_column( *column ) ) { column->draw( w, x, y ); } else { active_x = x; } if( column->pages_count() > 1 ) { mvwprintw( w, getmaxy( w ) - 2, x, _( "Page %d/%d" ), column->page_index() + 1, column->pages_count() ); } x += column->get_width() + gap; } get_active_column().draw( w, active_x, y ); if( empty() ) { center_print( w, getmaxy( w ) / 2, c_dkgray, _( "Your inventory is empty." ) ); } const std::string msg_str = ( navigation == navigation_mode::CATEGORY ) ? _( "Category selection; [TAB] switches mode, arrows select." ) : _( "Item selection; [TAB] switches mode, arrows select." ); const nc_color msg_color = ( navigation == navigation_mode::CATEGORY ) ? h_white : c_ltgray; if( center_align ) { center_print( w, getmaxy( w ) - 1, msg_color, msg_str.c_str() ); } else { trim_and_print( w, getmaxy( w ) - 1, 1, getmaxx( w ), msg_color, msg_str.c_str() ); } }
void snake_game::snake_over(WINDOW *w_snake, int iScore) { werase(w_snake); print_header(w_snake, false); // Body of dead snake size_t body_length = 3; for (size_t i = 1; i <= body_length; i++) { for (size_t j = 0; j <= 1; j++) { mvwprintz(w_snake, i, 4 + j * 65, c_green, "| |"); } } // Head of dead snake mvwprintz(w_snake, body_length + 1, 3, c_green, "( )"); mvwprintz(w_snake, body_length + 1, 4, c_dkgray, "x x"); mvwprintz(w_snake, body_length + 2, 3, c_green, " \\___/ "); mvwputch(w_snake, body_length + 3, 6, c_red, '|'); mvwputch(w_snake, body_length + 4, 6, c_red, '^'); // Tail of dead snake mvwprintz(w_snake, body_length + 1, 70, c_green, "\\ /"); mvwputch(w_snake, body_length + 2, 71, c_green, 'v'); std::vector<std::string> game_over_text; game_over_text.push_back(" ________ _____ _____ ___________ "); game_over_text.push_back(" / _____/ / _ \\ / \\ \\_ _____/ "); game_over_text.push_back("/ \\ ___ / /_\\ \\ / \\ / \\ | __)_ "); game_over_text.push_back("\\ \\_\\ \\/ | \\/ Y \\ | \\"); game_over_text.push_back(" \\______ /\\____|__ /\\____|__ //_______ / "); game_over_text.push_back(" \\/ \\/ \\/ \\/ "); game_over_text.push_back(" ________ ____ _________________________ "); game_over_text.push_back(" \\_____ \\\\ \\ / /\\_ _____/\\______ \\ "); game_over_text.push_back(" / | \\\\ Y / | __)_ | _/ "); game_over_text.push_back(" / | \\\\ / | \\ | | \\ "); game_over_text.push_back(" \\_______ / \\___/ /_______ / |____|_ / "); game_over_text.push_back(" \\/ \\/ \\/ "); for (size_t i = 0; i < game_over_text.size(); i++) { mvwprintz(w_snake, i + 3, 17, c_ltred, game_over_text[i].c_str()); } center_print(w_snake, 17, c_yellow, _("TOTAL SCORE: %d"), iScore); center_print(w_snake, 21, c_white, _("Press 'q' or ESC to exit.")); wrefresh(w_snake); do { InputEvent input_event = get_input(); if (input_event == Cancel) { return; } } while (true); }
void worldfactory::draw_mod_list( WINDOW *w, int &start, int &cursor, const std::vector<std::string> &mods, bool is_active_list, const std::string &text_if_empty ) { werase( w ); calcStartPos( start, cursor, getmaxy( w ), mods.size() ); if( mods.empty() ) { center_print( w, 0, c_red, "%s", text_if_empty.c_str() ); } else { const size_t wwidth = getmaxx( w ) - 1 - 3; // border (1) + ">> " (3) for( size_t i = start, c = 0; i < mods.size() && (int)c < getmaxy( w ); ++i, ++c ) { auto mod = mman->mod_map[mods[i]]; if( (int)i != cursor ) { mvwprintw( w, c, 1, " " ); } else { if( is_active_list ) { mvwprintz( w, c, 1, c_yellow, ">> " ); } else { mvwprintz( w, c, 1, c_blue, ">> " ); } } const std::string name = utf8_truncate( mod->name, wwidth ); #ifndef LUA if ( mod->need_lua ) { mvwprintz( w, c, 4, c_dkgray, "%s", name.c_str() ); } else { mvwprintz( w, c, 4, c_white, "%s", name.c_str() ); } #else mvwprintz( w, c, 4, c_white, "%s", name.c_str() ); #endif } } draw_scrollbar( w, cursor, getmaxy( w ), mods.size(), 0, 0 ); wrefresh( w ); }
void print_menu(char ** options, int num_options, int highlight, int first_print, int last_print){ clear(); int y = 1; int iter; for (iter = first_print; iter < last_print; iter++){ if (highlight == iter){ attron(A_REVERSE); center_print(y, options[iter]); attroff(A_REVERSE); } else { center_print(y, options[iter]); } y++; } }
// Prints out the summary of User input void print_input_summary(Input * I) { center_print("INPUT SUMMARY", 79); border_print(); #ifdef OPENMP printf("%-25s%d\n", "Number of Threads:", I->nthreads); #endif printf("%-25s%d\n", "Energy Groups:", I->egroups); printf("%-25s%d\n", "2D Source Regions:", I->source_2D_regions); printf("%-25s%d\n", "Coarse Axial Intervals:", I->coarse_axial_intervals); printf("%-25s%d\n", "Fine Axial Intervals:", I->fine_axial_intervals); printf("%-25s%d\n", "Axial Decomposition:", I->decomp_assemblies_ax); printf("%-25s%d\n", "3D Source Regions:", I->source_3D_regions); printf("%-25s", "Segments:"); fancy_int(I->segments); printf("%-25s%.2f\n", "Memory Estimate (MB):", I->nbytes/1024.0/1024.0); #ifdef TABLE printf("%-25s%s\n", "Exponential Table:","ON"); #else printf("%-25s%s\n", "Exponential Table:","OFF"); #endif #ifdef PAPI if( I->papi_event_set == -1) printf("%-25s%s\n", "PAPI event to count:", I->event_name); #endif border_print(); }
// Prints program logo void logo(int version) { border_print(); printf( " _____ _____ ____ _ \n" " | __ \\ / ____| _ \\ | | \n" " | |__) | (___ | |_) | ___ _ __ ___| |__ \n" " | _ / \\___ \\| _ < / _ \\ '_ \\ / __| '_ \\ \n" " | | \\ \\ ____) | |_) | __/ | | | (__| | | |\n" " |_| \\_\\_____/|____/ \\___|_| |_|\\___|_| |_|\n" ); border_print(); center_print("Developed at Argonne National Laboratory", 79); char v[100]; sprintf(v, "Version: %d", version); center_print(v, 79); border_print(); }
// Prints program logo void logo(int version) { border_print(); printf( " __ __ ___________ _ \n" " \\ \\ / // ___| ___ \\ | | \n" " \\ V / \\ `--.| |_/ / ___ _ __ ___| |__ \n" " / \\ `--. \\ ___ \\/ _ \\ '_ \\ / __| '_ \\ \n" " / /^\\ \\/\\__/ / |_/ / __/ | | | (__| | | | \n" " \\/ \\/\\____/\\____/ \\___|_| |_|\\___|_| |_| \n\n" ); border_print(); center_print("Developed at Argonne National Laboratory", 79); char v[100]; sprintf(v, "Version: %d", version); center_print(v, 79); border_print(); }
void snake_game::print_header(WINDOW *w_snake, bool show_shortcut) { draw_border(w_snake); if (show_shortcut) { std::string shortcut = _("<q>uit"); shortcut_print(w_snake, 0, FULL_SCREEN_WIDTH - utf8_width(shortcut.c_str()) - 2, c_white, c_ltgreen, shortcut); } center_print(w_snake, 0, c_white, _("S N A K E")); }
void print_results( Inputs in, int mype, double runtime, int nprocs, unsigned long long vhash ) { // Calculate Lookups per sec int lookups_per_sec = (int) ((double) in.lookups / runtime); // If running in MPI, reduce timing statistics and calculate average #ifdef DOMPI int total_lookups = 0; MPI_Barrier(MPI_COMM_WORLD); MPI_Reduce(&lookups_per_sec, &total_lookups, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); #endif // Print output if( mype == 0 ) { border_print(); center_print("RESULTS", 79); border_print(); // Print the results printf("Threads: %d\n", in.nthreads); #ifdef DOMPI printf("MPI ranks: %d\n", nprocs); #endif #ifdef DOMPI printf("Total Lookups/s: "); fancy_int(total_lookups); printf("Avg Lookups/s per MPI rank: "); fancy_int(total_lookups / nprocs); #else printf("Runtime: %.3lf seconds\n", runtime); printf("Lookups: "); fancy_int(in.lookups); printf("Lookups/s: "); fancy_int(lookups_per_sec); #endif #ifndef VERIFICATION printf("Non-zero Check: %llu\n", vhash); #else printf("Verification checksum: %llu\n", vhash); #endif border_print(); // For bechmarking, output lookup/s data to file if( SAVE ) { FILE * out = fopen( "results.txt", "a" ); fprintf(out, "%d\t%d\n", in.nthreads, lookups_per_sec); fclose(out); } } }
// Prints program logo void logo(int version) { border_print(); printf( " __ __ ___ __ __ ___ __ ___ \n" " /__` | |\\/| |__) | |__ |\\/| / \\ / ` __ |__/ |__ |__) |\\ | |__ | \n" " .__/ | | | | |___ |___ | | \\__/ \\__, | \\ |___ | \\ | \\| |___ |___\n" ); printf("\n"); border_print(); printf("\n"); center_print("Developed at", 79); center_print("The Massachusetts Institute of Technology", 79); center_print("and", 79); center_print("Argonne National Laboratory", 79); printf("\n"); char v[100]; sprintf(v, "Version: %d", version); center_print(v, 79); printf("\n"); border_print(); }
void line_input(int y, char * input, int input_size){ char ch; int size = 0; memset(input, 0, input_size); while (size < input_size){ ch = getch(); if (ch == '\n'){ input[size] = '\0'; break; } else { input[size] = ch; size++; } center_print(y, input); refresh(); } }
int sokoban_game::start_game() { int iScore = 0; int iMoves = 0; iTotalMoves = 0; int iDirY, iDirX; const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0; const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0; parse_level(); WINDOW *w_sokoban = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, iOffsetY, iOffsetX); draw_border(w_sokoban); center_print(w_sokoban, 0, hilite(c_white), _("Sokoban")); input_context ctxt("SOKOBAN"); ctxt.register_cardinal(); ctxt.register_action("NEXT"); ctxt.register_action("PREV"); ctxt.register_action("RESET"); ctxt.register_action("QUIT"); ctxt.register_action("UNDO"); ctxt.register_action("HELP_KEYBINDINGS"); std::vector<std::string> shortcuts; shortcuts.push_back(_("<+> next")); // '+': next shortcuts.push_back(_("<-> prev")); // '-': prev shortcuts.push_back(_("<r>eset")); // 'r': reset shortcuts.push_back(_("<q>uit")); // 'q': quit shortcuts.push_back(_("<u>ndo move")); // 'u': undo move int indent = 10; for (size_t i = 0; i < shortcuts.size(); i++) { indent = std::max(indent, utf8_width(shortcuts[i].c_str()) + 1); } indent = std::min(indent, 30); for (size_t i = 0; i < shortcuts.size(); i++) { shortcut_print(w_sokoban, i + 1, FULL_SCREEN_WIDTH - indent, c_white, c_ltgreen, shortcuts[i]); } int iPlayerY = 0; int iPlayerX = 0; bool bNewLevel = true; bool bMoved = false; do { if (bNewLevel) { bNewLevel = false; iMoves = 0; vUndo.clear(); iPlayerY = mLevelInfo[iCurrentLevel]["PlayerY"]; iPlayerX = mLevelInfo[iCurrentLevel]["PlayerX"]; mLevel = vLevel[iCurrentLevel]; } print_score(w_sokoban, iScore, iMoves); std::string action; if (check_win()) { //we won yay if (!mAlreadyWon[iCurrentLevel]) { iScore += 500; mAlreadyWon[iCurrentLevel] = true; } action = "NEXT"; } else { draw_level(w_sokoban); wrefresh(w_sokoban); //Check input action = ctxt.handle_input(); } bMoved = false; if (ctxt.get_direction(iDirX, iDirY, action)) { bMoved = true; } else if (action == "QUIT") { return iScore; } else if (action == "UNDO") { int iPlayerYNew = 0; int iPlayerXNew = 0; bool bUndoSkip = false; //undo move if (!vUndo.empty()) { //reset last player pos mLevel[iPlayerY][iPlayerX] = (mLevel[iPlayerY][iPlayerX] == "+") ? "." : " "; iPlayerYNew = vUndo[vUndo.size() - 1].iOldY; iPlayerXNew = vUndo[vUndo.size() - 1].iOldX; mLevel[iPlayerYNew][iPlayerXNew] = vUndo[vUndo.size() - 1].sTileOld; vUndo.pop_back(); bUndoSkip = true; } if (bUndoSkip && !vUndo.empty()) { iDirY = vUndo[vUndo.size() - 1].iOldY; iDirX = vUndo[vUndo.size() - 1].iOldX; if (vUndo[vUndo.size() - 1].sTileOld == "$" || vUndo[vUndo.size() - 1].sTileOld == "*") { mLevel[iPlayerY][iPlayerX] = (mLevel[iPlayerY][iPlayerX] == ".") ? "*" : "$"; mLevel[iPlayerY + iDirY][iPlayerX + iDirX] = (mLevel[iPlayerY + iDirY][iPlayerX + iDirX] == "*") ? "." : " "; vUndo.pop_back(); } } if (bUndoSkip) { iPlayerY = iPlayerYNew; iPlayerX = iPlayerXNew; } } else if (action == "RESET") { //reset level bNewLevel = true; } else if (action == "NEXT") { //next level clear_level(w_sokoban); iCurrentLevel++; if (iCurrentLevel >= iNumLevel) { iCurrentLevel = 0; } bNewLevel = true; } else if (action == "PREV") { //prev level clear_level(w_sokoban); iCurrentLevel--; if (iCurrentLevel < 0) { iCurrentLevel = iNumLevel - 1; } bNewLevel = true; } if (bMoved) { //check if we can move the player std::string sMoveTo = mLevel[iPlayerY + iDirY][iPlayerX + iDirX]; bool bMovePlayer = false; if (sMoveTo != "#") { if (sMoveTo == "$" || sMoveTo == "*") { //Check if we can move the package std::string sMovePackTo = mLevel[iPlayerY + (iDirY * 2)][iPlayerX + (iDirX * 2)]; if (sMovePackTo == "." || sMovePackTo == " ") { //move both bMovePlayer = true; mLevel[iPlayerY + (iDirY * 2)][iPlayerX + (iDirX * 2)] = (sMovePackTo == ".") ? "*" : "$"; vUndo.push_back(cUndo(iDirY, iDirX, sMoveTo)); iMoves--; } } else { bMovePlayer = true; } if (bMovePlayer) { //move player vUndo.push_back(cUndo(iPlayerY, iPlayerX, mLevel[iPlayerY][iPlayerX])); mLevel[iPlayerY][iPlayerX] = (mLevel[iPlayerY][iPlayerX] == "+") ? "." : " "; mLevel[iPlayerY + iDirY][iPlayerX + iDirX] = (sMoveTo == "." || sMoveTo == "*") ? "+" : "@"; iPlayerY += iDirY; iPlayerX += iDirX; iMoves++; iTotalMoves++; } } } } while (true); return iScore; }
// Pick up items at (pos). void Pickup::pick_up( const tripoint &pos, int min ) { int veh_root_part = 0; int cargo_part = -1; vehicle *veh = g->m.veh_at( pos, veh_root_part ); bool from_vehicle = false; if( min != -1 ) { switch( interact_with_vehicle( veh, pos, veh_root_part ) ) { case DONE: return; case ITEMS_FROM_CARGO: cargo_part = veh->part_with_feature( veh_root_part, "CARGO", false ); from_vehicle = cargo_part >= 0; break; case ITEMS_FROM_GROUND: // Nothing to change, default is to pick from ground anyway. if( g->m.has_flag( "SEALED", pos ) ) { return; } break; } } if( !from_vehicle ) { bool isEmpty = ( g->m.i_at( pos ).empty() ); // Hide the pickup window if this is a toilet and there's nothing here // but water. if( ( !isEmpty ) && g->m.furn( pos ) == f_toilet ) { isEmpty = true; for( auto maybe_water : g->m.i_at( pos ) ) { if( maybe_water.typeId() != "water" ) { isEmpty = false; break; } } } if( isEmpty && ( min != -1 || !OPTIONS["AUTO_PICKUP_ADJACENT"] ) ) { return; } } // which items are we grabbing? std::vector<item> here; if( from_vehicle ) { auto vehitems = veh->get_items( cargo_part ); here.resize( vehitems.size() ); std::copy( vehitems.rbegin(), vehitems.rend(), here.begin() ); } else { auto mapitems = g->m.i_at( pos ); here.resize( mapitems.size() ); std::copy( mapitems.rbegin(), mapitems.rend(), here.begin() ); } if( min == -1 ) { if( g->check_zone( "NO_AUTO_PICKUP", pos ) ) { here.clear(); } // Recursively pick up adjacent items if that option is on. if( OPTIONS["AUTO_PICKUP_ADJACENT"] && g->u.pos() == pos ) { //Autopickup adjacent direction adjacentDir[8] = {NORTH, NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, NORTHWEST}; for( auto &elem : adjacentDir ) { tripoint apos = tripoint( direction_XY( elem ), 0 ); apos += pos; if( g->m.has_flag( "SEALED", apos ) ) { continue; } if( g->check_zone( "NO_AUTO_PICKUP", apos ) ) { continue; } pick_up( apos, min ); } } } // Not many items, just grab them if( ( int )here.size() <= min && min != -1 ) { g->u.assign_activity( ACT_PICKUP, 0 ); g->u.activity.placement = pos - g->u.pos(); g->u.activity.values.push_back( from_vehicle ); // Only one item means index is 0. g->u.activity.values.push_back( 0 ); // auto-pickup means pick up all. g->u.activity.values.push_back( 0 ); return; } if( min != -1 ) { // don't bother if we're just autopickup-ing g->temp_exit_fullscreen(); } bool sideStyle = use_narrow_sidebar(); // Otherwise, we have Autopickup, 2 or more items and should list them, etc. int maxmaxitems = sideStyle ? TERMY : getmaxy( g->w_messages ) - 3; int itemsH = std::min( 25, TERMY / 2 ); int pickupBorderRows = 3; // The pickup list may consume the entire terminal, minus space needed for its // header/footer and the item info window. int minleftover = itemsH + pickupBorderRows; if( maxmaxitems > TERMY - minleftover ) { maxmaxitems = TERMY - minleftover; } const int minmaxitems = sideStyle ? 6 : 9; std::vector<pickup_count> getitem( here.size() ); int maxitems = here.size(); maxitems = ( maxitems < minmaxitems ? minmaxitems : ( maxitems > maxmaxitems ? maxmaxitems : maxitems ) ); int itemcount = 0; if( min == -1 ) { //Auto Pickup, select matching items if( !select_autopickup_items( here, getitem ) ) { // If we didn't find anything, bail out now. return; } } else { int pickupH = maxitems + pickupBorderRows; int pickupW = getmaxx( g->w_messages ); int pickupY = VIEW_OFFSET_Y; int pickupX = getbegx( g->w_messages ); int itemsW = pickupW; int itemsY = sideStyle ? pickupY + pickupH : TERMY - itemsH; int itemsX = pickupX; WINDOW *w_pickup = newwin( pickupH, pickupW, pickupY, pickupX ); WINDOW *w_item_info = newwin( itemsH, itemsW, itemsY, itemsX ); WINDOW_PTR w_pickupptr( w_pickup ); WINDOW_PTR w_item_infoptr( w_item_info ); std::string action; long raw_input_char = ' '; input_context ctxt( "PICKUP" ); ctxt.register_action( "UP" ); ctxt.register_action( "DOWN" ); ctxt.register_action( "RIGHT" ); ctxt.register_action( "LEFT" ); ctxt.register_action( "NEXT_TAB", _( "Next page" ) ); ctxt.register_action( "PREV_TAB", _( "Previous page" ) ); ctxt.register_action( "SCROLL_UP" ); ctxt.register_action( "SCROLL_DOWN" ); ctxt.register_action( "CONFIRM" ); ctxt.register_action( "SELECT_ALL" ); ctxt.register_action( "QUIT", _( "Cancel" ) ); ctxt.register_action( "ANY_INPUT" ); ctxt.register_action( "HELP_KEYBINDINGS" ); int start = 0, cur_it; player pl_copy = g->u; pl_copy.set_fake( true ); bool update = true; mvwprintw( w_pickup, 0, 0, _( "PICK UP" ) ); int selected = 0; int iScrollPos = 0; if( g->was_fullscreen ) { g->draw_ter(); } // Now print the two lists; those on the ground and about to be added to inv // Continue until we hit return or space do { const std::string pickup_chars = ctxt.get_available_single_char_hotkeys( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ:;" ); int idx = -1; for( int i = 1; i < pickupH; i++ ) { mvwprintw( w_pickup, i, 0, " " ); } if( action == "ANY_INPUT" && raw_input_char >= '0' && raw_input_char <= '9' ) { int raw_input_char_value = ( char )raw_input_char - '0'; itemcount *= 10; itemcount += raw_input_char_value; if( itemcount < 0 ) { itemcount = 0; } } else if( action == "SCROLL_UP" ) { iScrollPos--; } else if( action == "SCROLL_DOWN" ) { iScrollPos++; } else if( action == "PREV_TAB" ) { if( start > 0 ) { start -= maxitems; } else { start = ( int )( ( here.size() - 1 ) / maxitems ) * maxitems; } selected = start; mvwprintw( w_pickup, maxitems + 2, 0, " " ); } else if( action == "NEXT_TAB" ) { if( start + maxitems < ( int )here.size() ) { start += maxitems; } else { start = 0; } iScrollPos = 0; selected = start; mvwprintw( w_pickup, maxitems + 2, pickupH, " " ); } else if( action == "UP" ) { selected--; iScrollPos = 0; if( selected < 0 ) { selected = here.size() - 1; start = ( int )( here.size() / maxitems ) * maxitems; if( start >= ( int )here.size() ) { start -= maxitems; } } else if( selected < start ) { start -= maxitems; } } else if( action == "DOWN" ) { selected++; iScrollPos = 0; if( selected >= ( int )here.size() ) { selected = 0; start = 0; } else if( selected >= start + maxitems ) { start += maxitems; } } else if( selected >= 0 && ( ( action == "RIGHT" && !getitem[selected] ) || ( action == "LEFT" && getitem[selected] ) ) ) { idx = selected; } else if( action == "ANY_INPUT" && raw_input_char == '`' ) { std::string ext = string_input_popup( _( "Enter 2 letters (case sensitive):" ), 3, "", "", "", 2 ); if( ext.size() == 2 ) { int p1 = pickup_chars.find( ext.at( 0 ) ); int p2 = pickup_chars.find( ext.at( 1 ) ); if( p1 != -1 && p2 != -1 ) { idx = pickup_chars.size() + ( p1 * pickup_chars.size() ) + p2; } } } else if( action == "ANY_INPUT" ) { idx = ( raw_input_char <= 127 ) ? pickup_chars.find( raw_input_char ) : -1; iScrollPos = 0; } if( idx >= 0 && idx < ( int )here.size() ) { if( getitem[idx] ) { if( here[idx].count_by_charges() ) { if( getitem[idx].count == 0 ) { pl_copy.inv.find_item( getitem[idx].position ).charges -= here[idx].charges; } else { pl_copy.inv.find_item( getitem[idx].position ).charges -= getitem[idx].count; } } else { unsigned stack_size = pl_copy.inv.const_stack( getitem[idx].position ).size(); pl_copy.i_rem( getitem[idx].position ); //if the stack_was emptied, removing the item invalidated later positions- fix them if( stack_size == 1 ) { for( unsigned i = 0; i < here.size(); i++ ) { if( getitem[i] && getitem[i].position > getitem[idx].position ) { getitem[i].position--; } } } } } //end if getitem[idx] if( itemcount != 0 || getitem[idx].count == 0 ) { if( itemcount >= here[idx].charges || !here[idx].count_by_charges() ) { // Ignore the count if we pickup the whole stack anyway // or something that is not counted by charges (tools) itemcount = 0; } getitem[idx].count = itemcount; itemcount = 0; } // Note: this might not change the value of getitem[idx] at all! getitem[idx].pick = ( action == "RIGHT" ? true : ( action == "LEFT" ? false : !getitem[idx] ) ); if( action != "RIGHT" && action != "LEFT" ) { selected = idx; start = ( int )( idx / maxitems ) * maxitems; } if( getitem[idx] ) { item temp = here[idx]; if( getitem[idx].count != 0 && getitem[idx].count < here[idx].charges ) { temp.charges = getitem[idx].count; } item *added = &( pl_copy.i_add( temp ) ); getitem[idx].position = pl_copy.inv.position_by_item( added ); } else { getitem[idx].count = 0; } update = true; } werase( w_item_info ); if( selected >= 0 && selected <= ( int )here.size() - 1 ) { std::vector<iteminfo> vThisItem, vDummy; here[selected].info( true, vThisItem ); draw_item_info( w_item_info, "", "", vThisItem, vDummy, iScrollPos, true, true ); } draw_custom_border( w_item_info, false ); mvwprintw( w_item_info, 0, 2, "< " ); trim_and_print( w_item_info, 0, 4, itemsW - 8, c_white, "%s >", here[selected].display_name().c_str() ); wrefresh( w_item_info ); if( action == "SELECT_ALL" ) { int count = 0; for( size_t i = 0; i < here.size(); i++ ) { if( getitem[i] ) { count++; } else { item *added = &( pl_copy.i_add( here[i] ) ); getitem[i].position = pl_copy.inv.position_by_item( added ); } getitem[i].pick = true; } if( count == ( int )here.size() ) { for( size_t i = 0; i < here.size(); i++ ) { getitem[i].pick = false; } pl_copy = g->u; pl_copy.set_fake( true ); } update = true; } for( cur_it = start; cur_it < start + maxitems; cur_it++ ) { mvwprintw( w_pickup, 1 + ( cur_it % maxitems ), 0, " " ); if( cur_it < ( int )here.size() ) { nc_color icolor = here[cur_it].color_in_inventory(); if( cur_it == selected ) { icolor = hilite( icolor ); } if( cur_it < ( int )pickup_chars.size() ) { mvwputch( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor, char( pickup_chars[cur_it] ) ); } else if( cur_it < ( int )pickup_chars.size() + ( int )pickup_chars.size() * ( int )pickup_chars.size() ) { int p = cur_it - pickup_chars.size(); int p1 = p / pickup_chars.size(); int p2 = p % pickup_chars.size(); mvwprintz( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor, "`%c%c", char( pickup_chars[p1] ), char( pickup_chars[p2] ) ); } else { mvwputch( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor, ' ' ); } if( getitem[cur_it] ) { if( getitem[cur_it].count == 0 ) { wprintz( w_pickup, c_ltblue, " + " ); } else { wprintz( w_pickup, c_ltblue, " # " ); } } else { wprintw( w_pickup, " - " ); } std::string item_name = here[cur_it].display_name(); if( OPTIONS["ITEM_SYMBOLS"] ) { item_name = string_format( "%s %s", here[cur_it].symbol().c_str(), item_name.c_str() ); } trim_and_print( w_pickup, 1 + ( cur_it % maxitems ), 6, pickupW - 4, icolor, "%s", item_name.c_str() ); } } mvwprintw( w_pickup, maxitems + 1, 0, _( "[%s] Unmark" ), ctxt.get_desc( "LEFT", 1 ).c_str() ); center_print( w_pickup, maxitems + 1, c_ltgray, _( "[%s] Help" ), ctxt.get_desc( "HELP_KEYBINDINGS", 1 ).c_str() ); right_print( w_pickup, maxitems + 1, 0, c_ltgray, _( "[%s] Mark" ), ctxt.get_desc( "RIGHT", 1 ).c_str() ); mvwprintw( w_pickup, maxitems + 2, 0, _( "[%s] Prev" ), ctxt.get_desc( "PREV_TAB", 1 ).c_str() ); center_print( w_pickup, maxitems + 2, c_ltgray, _( "[%s] All" ), ctxt.get_desc( "SELECT_ALL", 1 ).c_str() ); right_print( w_pickup, maxitems + 2, 0, c_ltgray, _( "[%s] Next" ), ctxt.get_desc( "NEXT_TAB", 1 ).c_str() ); if( update ) { // Update weight & volume information update = false; for( int i = 9; i < pickupW; ++i ) { mvwaddch( w_pickup, 0, i, ' ' ); } mvwprintz( w_pickup, 0, 9, ( pl_copy.weight_carried() > g->u.weight_capacity() ? c_red : c_white ), _( "Wgt %.1f" ), convert_weight( pl_copy.weight_carried() ) + 0.05 ); // +0.05 to round up wprintz( w_pickup, c_white, "/%.1f", convert_weight( g->u.weight_capacity() ) ); mvwprintz( w_pickup, 0, 24, ( pl_copy.volume_carried() > g->u.volume_capacity() ? c_red : c_white ), _( "Vol %d" ), pl_copy.volume_carried() ); wprintz( w_pickup, c_white, "/%d", g->u.volume_capacity() ); } wrefresh( w_pickup ); action = ctxt.handle_input(); raw_input_char = ctxt.get_raw_input().get_first_input(); } while( action != "QUIT" && action != "CONFIRM" ); bool item_selected = false; // Check if we have selected an item. for( auto selection : getitem ) { if( selection ) { item_selected = true; } } if( action != "CONFIRM" || !item_selected ) { w_pickupptr.reset(); w_item_infoptr.reset(); add_msg( _( "Never mind." ) ); g->reenter_fullscreen(); g->refresh_all(); return; } } // At this point we've selected our items, register an activity to pick them up. g->u.assign_activity( ACT_PICKUP, 0 ); g->u.activity.placement = pos - g->u.pos(); g->u.activity.values.push_back( from_vehicle ); if( min == -1 ) { // Auto pickup will need to auto resume since there can be several of them on the stack. g->u.activity.auto_resume = true; } std::reverse( getitem.begin(), getitem.end() ); for( size_t i = 0; i < here.size(); i++ ) { if( getitem[i] ) { g->u.activity.values.push_back( i ); g->u.activity.values.push_back( getitem[i].count ); } } g->reenter_fullscreen(); }
void run_kernel( Input * I, Source * S, Table * table) { // Enter Parallel Region #pragma omp parallel default(none) shared(I, S, table) { #ifdef OPENMP int thread = omp_get_thread_num(); #else int thread = 0; #endif // Create Thread Local Random Seed unsigned int seed = time(NULL) * (thread+1); // Allocate Thread Local SIMD Vectors (align if using intel compiler) #ifdef INTEL SIMD_Vectors simd_vecs = aligned_allocate_simd_vectors(I); float * state_flux = (float *) _mm_malloc( I->egroups * sizeof(float), 64); #else SIMD_Vectors simd_vecs = allocate_simd_vectors(I); float * state_flux = (float *) malloc( I->egroups * sizeof(float)); #endif // Allocate Thread Local Flux Vector for( int i = 0; i < I->egroups; i++ ) state_flux[i] = (float) rand_r(&seed) / RAND_MAX; // Initialize PAPI Counters (if enabled) #ifdef PAPI int eventset = PAPI_NULL; int num_papi_events; #pragma omp critical { counter_init(&eventset, &num_papi_events, I); } #endif // Enter OMP For Loop over Segments #pragma omp for schedule(dynamic,100) for( long i = 0; i < I->segments; i++ ) { // Pick Random QSR int QSR_id = rand_r(&seed) % I->source_3D_regions; // Pick Random Fine Axial Interval int FAI_id = rand_r(&seed) % I->fine_axial_intervals; // Attenuate Segment attenuate_segment( I, S, QSR_id, FAI_id, state_flux, &simd_vecs, table); } // Stop PAPI Counters #ifdef PAPI if( thread == 0 ) { printf("\n"); border_print(); center_print("PAPI COUNTER RESULTS", 79); border_print(); printf("Count \tSmybol \tDescription\n"); } { #pragma omp barrier } counter_stop(&eventset, num_papi_events, I); #endif } }
int worldfactory::show_worldgen_tab_modselection(WINDOW *win, WORLDPTR world) { // Use active_mod_order of the world, // saves us from writting 'world->active_mod_order' all the time. std::vector<std::string> &active_mod_order = world->active_mod_order; { std::vector<std::string> tmp_mod_order; // clear active_mod_order and re-add all the mods, his ensures // that changes (like changing depencies) get updated tmp_mod_order.swap(active_mod_order); for(size_t i = 0; i < tmp_mod_order.size(); i++) { mman_ui->try_add(tmp_mod_order[i], active_mod_order); } } const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0; const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0; // lots of small windows so that each section can be drawn to independently of the others as necessary WINDOW *w_header1, *w_header2, *w_shift, *w_list, *w_active, *w_description; w_header1 = newwin(1, FULL_SCREEN_WIDTH / 2 - 5, 3 + iOffsetY, 1 + iOffsetX); w_header2 = newwin(1, FULL_SCREEN_WIDTH / 2 - 4, 3 + iOffsetY, FULL_SCREEN_WIDTH / 2 + 3 + iOffsetX); w_shift = newwin(13, 5, 3 + iOffsetY, FULL_SCREEN_WIDTH / 2 - 3 + iOffsetX); w_list = newwin(11, FULL_SCREEN_WIDTH / 2 - 4, 5 + iOffsetY, iOffsetX); w_active = newwin(11, FULL_SCREEN_WIDTH / 2 - 4, 5 + iOffsetY, FULL_SCREEN_WIDTH / 2 + 2 + iOffsetX); w_description = newwin(4, FULL_SCREEN_WIDTH - 2, 19 + iOffsetY, 1 + iOffsetX); draw_modselection_borders(win); std::vector<std::string> headers; headers.push_back(_("Mod List")); headers.push_back(_("Mod Load Order")); std::vector<WINDOW *> header_windows; header_windows.push_back(w_header1); header_windows.push_back(w_header2); int tab_output = 0; int last_active_header = 0; size_t active_header = 0; size_t useable_mod_count = mman_ui->usable_mods.size(); int startsel[2] = {0, 0}; int cursel[2] = {0, 0}; bool redraw_headers = true; bool redraw_shift = true; bool redraw_description = true; bool redraw_list = true; bool redraw_active = true; bool selection_changed = false; input_context ctxt("MODMANAGER_DIALOG"); ctxt.register_cardinal(); ctxt.register_action("HELP_KEYBINDINGS"); ctxt.register_action("QUIT"); ctxt.register_action("NEXT_TAB"); ctxt.register_action("PREV_TAB"); ctxt.register_action("CONFIRM"); ctxt.register_action("ADD_MOD"); ctxt.register_action("REMOVE_MOD"); ctxt.register_action("SAVE_DEFAULT_MODS"); while (tab_output == 0) { if (redraw_headers) { for (size_t i = 0; i < headers.size(); ++i) { werase(header_windows[i]); const int header_x = (getmaxx(header_windows[i]) - headers[i].size()) / 2; mvwprintz(header_windows[i], 0, header_x , c_cyan, "%s", headers[i].c_str()); if (active_header == i) { mvwputch(header_windows[i], 0, header_x - 3, c_red, '<'); mvwputch(header_windows[i], 0, header_x + headers[i].size() + 2, c_red, '>'); } wrefresh(header_windows[i]); } redraw_list = true; redraw_active = true; redraw_shift = true; redraw_headers = false; } if (selection_changed) { if (active_header == 0) { redraw_list = true; } if (active_header == 1) { redraw_shift = true; redraw_active = true; } selection_changed = false; redraw_description = true; } if (redraw_description) { werase(w_description); MOD_INFORMATION *selmod = NULL; if (mman_ui->usable_mods.empty()) { // Do nothing, leave selmod == NULL } else if (active_header == 0) { selmod = mman->mod_map[mman_ui->usable_mods[cursel[0]]]; } else if (!active_mod_order.empty()) { selmod = mman->mod_map[active_mod_order[cursel[1]]]; } if (selmod != NULL) { fold_and_print(w_description, 0, 1, getmaxx(w_description) - 1, c_white, mman_ui->get_information(selmod)); } redraw_description = false; wrefresh(w_description); } if (redraw_list) { werase(w_list); calcStartPos(startsel[0], cursel[0], getmaxy(w_list), useable_mod_count); if (useable_mod_count == 0) { center_print(w_list, 0, c_red, _("--NO AVAILABLE MODS--")); } else { std::stringstream list_output; for( size_t i = startsel[0], c = 0; i < useable_mod_count && c < getmaxy(w_list); ++i, ++c ) { if ((int)i != cursel[0]) { list_output << std::string(3, ' '); } else { if (active_header == 0) { list_output << "<color_yellow>"; } else { list_output << "<color_blue>"; } list_output << ">></color> "; } list_output << mman->mod_map[mman_ui->usable_mods[i]]->name << "\n"; } fold_and_print(w_list, 0, 1, getmaxx(w_list) - 1, c_white, list_output.str()); } draw_scrollbar(w_list, cursel[0], getmaxy(w_list), useable_mod_count, 0, 0); wrefresh(w_list); } if (redraw_active) { werase(w_active); const int active_count = active_mod_order.size(); calcStartPos(startsel[1], cursel[1], getmaxy(w_active), active_count); if (active_count == 0) { center_print(w_active, 0, c_red, _("--NO ACTIVE MODS--")); } else { std::stringstream list_output; for (int i = startsel[1], c = 0; i < active_count && c < getmaxy(w_active); ++i, ++c) { if (i != cursel[1]) { list_output << std::string(3, ' '); } else { if (active_header == 1) { list_output << "<color_yellow>"; } else { list_output << "<color_blue>"; } list_output << ">></color> "; } list_output << mman->mod_map[active_mod_order[i]]->name << "\n"; } fold_and_print(w_active, 0, 1, getmaxx(w_active) - 1, c_white, list_output.str()); } draw_scrollbar(w_active, cursel[1], getmaxy(w_active), active_count, 0, 0); wrefresh(w_active); } if (redraw_shift) { werase(w_shift); if (active_header == 1) { std::stringstream shift_display; // get shift information for whatever is visible in the active list for (size_t i = startsel[1], c = 0; i < active_mod_order.size() && c < getmaxy(w_active); ++i, ++c) { if (mman_ui->can_shift_up(i, active_mod_order)) { shift_display << "<color_blue>+</color> "; } else { shift_display << "<color_dkgray>+</color> "; } if (mman_ui->can_shift_down(i, active_mod_order)) { shift_display << "<color_blue>-</color>"; } else { shift_display << "<color_dkgray>-</color>"; } shift_display << "\n"; } fold_and_print(w_shift, 2, 1, getmaxx(w_shift), c_white, shift_display.str()); } redraw_shift = false; wrefresh(w_shift); } refresh(); last_active_header = active_header; const int next_header = (active_header == 1) ? 0 : 1; const int prev_header = (active_header == 0) ? 1 : 0; int selection = (active_header == 0) ? cursel[0] : cursel[1]; int last_selection = selection; unsigned int next_selection = selection + 1; int prev_selection = selection - 1; if (active_header == 0) { next_selection = (next_selection >= useable_mod_count) ? 0 : next_selection; prev_selection = (prev_selection < 0) ? useable_mod_count - 1 : prev_selection; } else { next_selection = (next_selection >= active_mod_order.size()) ? 0 : next_selection; prev_selection = (prev_selection < 0) ? active_mod_order.size() - 1 : prev_selection; } const std::string action = ctxt.handle_input(); if (action == "DOWN") { selection = next_selection; } else if (action == "UP") { selection = prev_selection; } else if (action == "RIGHT") { active_header = next_header; } else if (action == "LEFT") { active_header = prev_header; } else if (action == "CONFIRM") { if (active_header == 0 && !mman_ui->usable_mods.empty()) { // try-add mman_ui->try_add(mman_ui->usable_mods[cursel[0]], active_mod_order); redraw_active = true; redraw_shift = true; } else if (active_header == 1 && !active_mod_order.empty()) { // try-rem mman_ui->try_rem(cursel[1], active_mod_order); redraw_active = true; redraw_shift = true; if (active_mod_order.empty()) { // switch back to other list, we can't change // anything in the empty active mods list. active_header = 0; } } } else if (action == "ADD_MOD") { if (active_header == 1 && active_mod_order.size() > 1) { mman_ui->try_shift('+', cursel[1], active_mod_order); redraw_active = true; redraw_shift = true; } } else if (action == "REMOVE_MOD") { if (active_header == 1 && active_mod_order.size() > 1) { mman_ui->try_shift('-', cursel[1], active_mod_order); redraw_active = true; redraw_shift = true; } } else if (action == "NEXT_TAB") { tab_output = 1; } else if (action == "PREV_TAB") { tab_output = -1; } else if (action == "SAVE_DEFAULT_MODS") { if(mman->set_default_mods(active_mod_order)) { popup(_("Saved list of active mods as default")); draw_modselection_borders(win); redraw_headers = true; } } else if (action == "QUIT") { tab_output = -999; } // RESOLVE INPUTS if (last_active_header != (int)active_header) { redraw_headers = true; redraw_shift = true; redraw_description = true; } if (last_selection != selection) { if (active_header == 0) { redraw_list = true; cursel[0] = selection; } else { redraw_active = true; redraw_shift = true; cursel[1] = selection; } redraw_description = true; } if (active_mod_order.empty()) { redraw_active = true; cursel[1] = 0; } if (active_header == 1) { if (active_mod_order.empty()) { cursel[1] = 0; } else { if (cursel[1] < 0) { cursel[1] = 0; } else if (cursel[1] >= (int)active_mod_order.size()) { cursel[1] = active_mod_order.size() - 1; } } } // end RESOLVE INPUTS } werase(w_header1); werase(w_header2); werase(w_shift); werase(w_list); werase(w_active); werase(w_description); delwin(w_header1); delwin(w_header2); delwin(w_shift); delwin(w_list); delwin(w_active); delwin(w_description); return tab_output; }
void game::print_menu( WINDOW *w_open, int iSel, const int iMenuOffsetX, int iMenuOffsetY, bool bShowDDA ) { // Clear Lines werase( w_open ); // Define window size int window_width = getmaxx( w_open ); int window_height = getmaxy( w_open ); // Draw horizontal line for( int i = 1; i < window_width - 1; ++i ) { mvwputch( w_open, window_height - 2, i, c_white, LINE_OXOX ); } center_print( w_open, window_height - 1, c_red, _( "Please report bugs to [email protected] or post on the forums." ) ); int iLine = 0; const int iOffsetX = ( window_width - FULL_SCREEN_WIDTH ) / 2; const nc_color cColor1 = c_ltcyan; const nc_color cColor2 = c_ltblue; const nc_color cColor3 = c_ltblue; if( mmenu_title.size() > 1 ) { for( size_t i = 0; i < mmenu_title.size(); ++i ) { if( i == 6 ) { if( !bShowDDA ) { break; } if( FULL_SCREEN_HEIGHT > 24 ) { ++iLine; } } mvwprintz( w_open, iLine++, iOffsetX, i < 6 ? cColor1 : cColor2, mmenu_title[i].c_str() ); } } else { center_print( w_open, iLine++, cColor1, mmenu_title[0].c_str() ); } if( bShowDDA ) { iLine++; center_print( w_open, iLine++, cColor3, _( "Version: %s" ), getVersionString() ); } int menu_length = 0; for( size_t i = 0; i < vMenuItems.size(); ++i ) { menu_length += utf8_width( vMenuItems[i], true ) + 2; if( !vMenuHotkeys[i].empty() ) { menu_length += utf8_width( vMenuHotkeys[i][0] ); } } const int free_space = std::max( 0, window_width - menu_length - iMenuOffsetX ); const int spacing = free_space / ( ( int )vMenuItems.size() + 1 ); const int width_of_spacing = spacing * ( vMenuItems.size() + 1 ); const int adj_offset = std::max( 0, ( free_space - width_of_spacing ) / 2 ); const int final_offset = iMenuOffsetX + adj_offset + spacing; print_menu_items( w_open, vMenuItems, iSel, iMenuOffsetY, final_offset, spacing ); refresh(); wrefresh( w_open ); refresh(); }
void safemode::test_pattern( const int tab_in, const int row_in ) { std::vector<std::string> creature_list; auto &temp_rules = ( tab_in == GLOBAL_TAB ) ? global_rules : character_rules; if( temp_rules[row_in].rule.empty() ) { return; } if( g->u.name.empty() ) { popup( _( "No monsters loaded. Please start a game first." ) ); return; } //Loop through all monster mtypes for( const auto &mtype : MonsterGenerator::generator().get_all_mtypes() ) { std::string creature_name = mtype.nname(); if( wildcard_match( creature_name, temp_rules[row_in].rule ) ) { creature_list.push_back( creature_name ); } } const int offset_x = 15 + ( ( TERMX > FULL_SCREEN_WIDTH ) ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0 ); const int offset_y = 5 + ( ( TERMY > FULL_SCREEN_HEIGHT ) ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ); int start_pos = 0; const int content_height = FULL_SCREEN_HEIGHT - 8; const int content_width = FULL_SCREEN_WIDTH - 30; const catacurses::window w_test_rule_border = catacurses::newwin( content_height + 2, content_width, offset_y, offset_x ); const catacurses::window w_test_rule_content = catacurses::newwin( content_height, content_width - 2, 1 + offset_y, 1 + offset_x ); int nmatch = creature_list.size(); const std::string buf = string_format( ngettext( "%1$d monster matches: %2$s", "%1$d monsters match: %2$s", nmatch ), nmatch, temp_rules[row_in].rule.c_str() ); draw_border( w_test_rule_border, BORDER_COLOR, buf, hilite( c_white ) ); center_print( w_test_rule_border, content_height + 1, red_background( c_white ), _( "Lists monsters regardless of their attitude." ) ); wrefresh( w_test_rule_border ); int line = 0; input_context ctxt( "SAFEMODE_TEST" ); ctxt.register_updown(); ctxt.register_action( "QUIT" ); while( true ) { // Clear the lines for( int i = 0; i < content_height; i++ ) { for( int j = 0; j < 79; j++ ) { mvwputch( w_test_rule_content, i, j, c_black, ' ' ); } } calcStartPos( start_pos, line, content_height, creature_list.size() ); // display safe mode for( int i = start_pos; i < static_cast<int>( creature_list.size() ); i++ ) { if( i >= start_pos && i < start_pos + std::min( content_height, static_cast<int>( creature_list.size() ) ) ) { nc_color line_color = c_white; mvwprintz( w_test_rule_content, i - start_pos, 0, line_color, "%d", i + 1 ); mvwprintz( w_test_rule_content, i - start_pos, 4, line_color, "" ); wprintz( w_test_rule_content, c_yellow, ( line == i ) ? ">> " : " " ); wprintz( w_test_rule_content, ( line == i ) ? hilite( line_color ) : line_color, creature_list[i] ); } } wrefresh( w_test_rule_content ); const std::string action = ctxt.handle_input(); if( action == "DOWN" ) { line++; if( line >= static_cast<int>( creature_list.size() ) ) { line = 0; } } else if( action == "UP" ) { line--; if( line < 0 ) { line = creature_list.size() - 1; } } else { break; } } }
void game::print_menu(WINDOW *w_open, int iSel, const int iMenuOffsetX, int iMenuOffsetY, bool bShowDDA) { // Clear Lines werase(w_open); // Define window size int window_width = getmaxx(w_open); int window_height = getmaxy(w_open); // Draw horizontal line for (int i = 1; i < window_width - 1; ++i) { mvwputch(w_open, window_height - 2, i, c_white, LINE_OXOX); } center_print(w_open, window_height - 1, c_red, _("Please report bugs to [email protected] or post on the forums.")); int iLine = 0; const int iOffsetX1 = 3 + (window_width - FULL_SCREEN_WIDTH) / 2; const int iOffsetX2 = 4 + (window_width - FULL_SCREEN_WIDTH) / 2; const int iOffsetX3 = 18 + (window_width - FULL_SCREEN_WIDTH) / 2; const nc_color cColor1 = c_ltcyan; const nc_color cColor2 = c_ltblue; const nc_color cColor3 = c_ltblue; mvwprintz(w_open, iLine++, iOffsetX1, cColor1, "_________ __ .__ "); mvwprintz(w_open, iLine++, iOffsetX1, cColor1, "\\_ ___ \\ _____ _/ |_ _____ ____ | | ___.__ ______ _____ "); mvwprintz(w_open, iLine++, iOffsetX1, cColor1, "/ \\ \\/ \\__ \\ \\ __\\\\__ \\ _/ ___\\ | | < | | / ___/ / \\ "); mvwprintz(w_open, iLine++, iOffsetX1, cColor1, "\\ \\____ / __ \\_ | | / __ \\_\\ \\___ | |__ \\___ | \\___ \\ | Y Y \\"); mvwprintz(w_open, iLine++, iOffsetX1, cColor1, " \\______ /(____ / |__| (____ / \\___ >|____/ / ____|/____ >|__|_| /"); mvwprintz(w_open, iLine++, iOffsetX1, cColor1, " \\/ \\/ \\/ \\/ \\/ \\/ \\/ "); if (bShowDDA) { if (FULL_SCREEN_HEIGHT > 24) { ++iLine; } mvwprintz(w_open, iLine++, iOffsetX2, cColor2, "________ .__ ________ "); mvwprintz(w_open, iLine++, iOffsetX2, cColor2, "\\______ \\ _____ _______ | | __ \\______ \\ _____ ___.__ ______"); mvwprintz(w_open, iLine++, iOffsetX2, cColor2, " | | \\ \\__ \\ \\_ __ \\| |/ / | | \\ \\__ \\ < | | / ___/"); mvwprintz(w_open, iLine++, iOffsetX2, cColor2, " | ` \\ / __ \\_ | | \\/| < | ` \\ / __ \\_ \\___ | \\___ \\ "); mvwprintz(w_open, iLine++, iOffsetX2, cColor2, "/_______ /(____ / |__| |__|_ \\ /_______ /(____ / / ____|/____ >"); mvwprintz(w_open, iLine++, iOffsetX2, cColor2, " \\/ \\/ \\/ \\/ \\/ \\/ \\/ "); mvwprintz(w_open, iLine++, iOffsetX3, cColor3, " _____ .__ .___"); mvwprintz(w_open, iLine++, iOffsetX3, cColor3, " / _ \\ | |__ ____ _____ __| _/"); mvwprintz(w_open, iLine++, iOffsetX3, cColor3, " / /_\\ \\ | | \\ _/ __ \\ \\__ \\ / __ | "); mvwprintz(w_open, iLine++, iOffsetX3, cColor3, "/ | \\| Y \\\\ ___/ / __ \\_/ /_/ | "); mvwprintz(w_open, iLine++, iOffsetX3, cColor3, "\\____|__ /|___| / \\___ >(____ /\\____ | "); mvwprintz(w_open, iLine++, iOffsetX3, cColor3, " \\/ \\/ \\/ \\/ \\/ "); iLine++; center_print(w_open, iLine++, cColor3, _("Version: %s"), getVersionString()); } std::vector<std::string> vMenuItems; vMenuItems.push_back(pgettext("Main Menu", "<M>OTD")); vMenuItems.push_back(pgettext("Main Menu", "<N>ew Game")); vMenuItems.push_back(pgettext("Main Menu", "Lo<a>d")); vMenuItems.push_back(pgettext("Main Menu", "<W>orld")); vMenuItems.push_back(pgettext("Main Menu", "<S>pecial")); vMenuItems.push_back(pgettext("Main Menu", "<O>ptions")); vMenuItems.push_back(pgettext("Main Menu", "H<e>lp")); vMenuItems.push_back(pgettext("Main Menu", "<C>redits")); vMenuItems.push_back(pgettext("Main Menu", "<Q>uit")); int menu_length = 0; for (int pos = 0; pos < vMenuItems.size(); pos++) { // adds (width + 2) if there are no shortcut symbols "<" & ">", and just width otherwise menu_length += utf8_width(vMenuItems[pos].c_str()) + (vMenuItems[pos].find_first_of("<") == std::string::npos ? 2 : 0); } int spacing = (window_width - menu_length) / vMenuItems.size() - 1; spacing = (spacing < 1 ? 1 : spacing); const int adj_offset = (window_width - menu_length - spacing * vMenuItems.size() ) / 2 - 1; print_menu_items(w_open, vMenuItems, iSel, iMenuOffsetY, iMenuOffsetX + adj_offset, spacing); refresh(); wrefresh(w_open); refresh(); }
void run_event_based_simulation(Input input, CalcDataPtrs data, long * abrarov_result, long * alls_result, unsigned long * vhash_result ) { printf("Beginning event based simulation...\n"); long g_abrarov = 0; long g_alls = 0; unsigned long vhash = 0; #pragma omp parallel default(none) \ shared(input, data) \ reduction(+:g_abrarov, g_alls, vhash) { double * xs = (double *) calloc(4, sizeof(double)); int thread = omp_get_thread_num(); long abrarov = 0; long alls = 0; #ifdef PAPI int eventset = PAPI_NULL; int num_papi_events; #pragma omp critical { counter_init(&eventset, &num_papi_events); } #endif complex double * sigTfactors = (complex double *) malloc( input.numL * sizeof(complex double) ); // This loop is independent! // I.e., macroscopic cross section lookups in the event based simulation // can be executed in any order. #pragma omp for schedule(guided) for( int i = 0; i < input.lookups; i++ ) { // Particles are seeded by their particle ID unsigned long seed = ((unsigned long) i+ (unsigned long)1)* (unsigned long) 13371337; // Randomly pick an energy and material for the particle double E = rn(&seed); int mat = pick_mat(&seed); #ifdef STATUS if( thread == 0 && i % 2000 == 0 ) printf("\rCalculating XS's... (%.0lf%% completed)", (i / ( (double)input.lookups / (double) input.nthreads )) / (double) input.nthreads * 100.0); #endif double macro_xs[4] = {0}; calculate_macro_xs( macro_xs, mat, E, input, data, sigTfactors, &abrarov, &alls ); // Results are copied onto heap to avoid some compiler // flags (-flto) from optimizing out function call memcpy(xs, macro_xs, 4*sizeof(double)); // Verification hash calculation // This method provides a consistent hash accross // architectures and compilers. #ifdef VERIFICATION char line[256]; sprintf(line, "%.2le %d %.2le %.2le %.2le %.2le", E, mat, macro_xs[0], macro_xs[1], macro_xs[2], macro_xs[3]); unsigned long long vhash_local = hash(line, 10000); vhash += vhash_local; #endif } free(sigTfactors); // Accumulate global counters g_abrarov = abrarov; g_alls = alls; #ifdef PAPI if( thread == 0 ) { printf("\n"); border_print(); center_print("PAPI COUNTER RESULTS", 79); border_print(); printf("Count \tSmybol \tDescription\n"); } { #pragma omp barrier } counter_stop(&eventset, num_papi_events); #endif } *abrarov_result = g_abrarov; *alls_result = g_alls; *vhash_result = vhash; }
WORLDPTR worldfactory::pick_world( bool show_prompt ) { std::map<std::string, WORLDPTR> worlds = get_all_worlds(); std::vector<std::string> world_names = all_worldnames; // Filter out special worlds (TUTORIAL | DEFENSE) from world_names. for (std::vector<std::string>::iterator it = world_names.begin(); it != world_names.end();) { if (*it == "TUTORIAL" || *it == "DEFENSE") { it = world_names.erase(it); } else if (world_need_lua_build(*it)) { it = world_names.erase(it); } else { ++it; } } // If there is only one world to pick from, autoreturn it. if (world_names.size() == 1) { return worlds[world_names[0]]; } // If there are no worlds to pick from, immediately try to make one. else if (world_names.empty()) { return make_new_world( show_prompt ); } // If we're skipping prompts, just return the first one. else if( !show_prompt ) { return worlds[world_names[0]]; } const int iTooltipHeight = 3; const int iContentHeight = FULL_SCREEN_HEIGHT - 3 - iTooltipHeight; const unsigned int num_pages = world_names.size() / iContentHeight + 1; // at least 1 page const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0; const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0; std::map<int, bool> mapLines; mapLines[3] = true; std::map<int, std::vector<std::string> > world_pages; unsigned int worldnum = 0; for (size_t i = 0; i < num_pages; ++i) { for (int j = 0; j < iContentHeight && worldnum < world_names.size(); ++j) { world_pages[i].push_back(world_names[worldnum++]); } } unsigned int sel = 0, selpage = 0; WINDOW *w_worlds_border = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, iOffsetY, iOffsetX); WINDOW *w_worlds_tooltip = newwin(iTooltipHeight, FULL_SCREEN_WIDTH - 2, 1 + iOffsetY, 1 + iOffsetX); WINDOW *w_worlds_header = newwin(1, FULL_SCREEN_WIDTH - 2, 1 + iTooltipHeight + iOffsetY, 1 + iOffsetX); WINDOW *w_worlds = newwin(iContentHeight, FULL_SCREEN_WIDTH - 2, iTooltipHeight + 2 + iOffsetY, 1 + iOffsetX); draw_border(w_worlds_border); mvwputch(w_worlds_border, 4, 0, BORDER_COLOR, LINE_XXXO); // |- mvwputch(w_worlds_border, 4, FULL_SCREEN_WIDTH - 1, BORDER_COLOR, LINE_XOXX); // -| for( auto &mapLine : mapLines ) { mvwputch( w_worlds_border, FULL_SCREEN_HEIGHT - 1, mapLine.first + 1, BORDER_COLOR, LINE_XXOX ); // _|_ } center_print(w_worlds_border, 0, c_ltred, _(" WORLD SELECTION ")); wrefresh(w_worlds_border); for (int i = 0; i < 78; i++) { if (mapLines[i]) { mvwputch(w_worlds_header, 0, i, BORDER_COLOR, LINE_OXXX); } else { mvwputch(w_worlds_header, 0, i, BORDER_COLOR, LINE_OXOX); // Draw header line } } wrefresh(w_worlds_header); input_context ctxt("PICK_WORLD_DIALOG"); ctxt.register_updown(); ctxt.register_action("HELP_KEYBINDINGS"); ctxt.register_action("QUIT"); ctxt.register_action("NEXT_TAB"); ctxt.register_action("PREV_TAB"); ctxt.register_action("CONFIRM"); std::stringstream sTemp; while(true) { //Clear the lines for (int i = 0; i < iContentHeight; i++) { for (int j = 0; j < 79; j++) { if (mapLines[j]) { mvwputch(w_worlds, i, j, BORDER_COLOR, LINE_XOXO); } else { mvwputch(w_worlds, i, j, c_black, ' '); } if (i < iTooltipHeight) { mvwputch(w_worlds_tooltip, i, j, c_black, ' '); } } } //Draw World Names for (size_t i = 0; i < world_pages[selpage].size(); ++i) { sTemp.str(""); sTemp << i + 1; mvwprintz(w_worlds, i, 0, c_white, "%s", sTemp.str().c_str()); mvwprintz(w_worlds, i, 4, c_white, ""); std::string world_name = (world_pages[selpage])[i]; size_t saves_num = world_generator->all_worlds[world_name]->world_saves.size(); if (i == sel) { wprintz(w_worlds, c_yellow, ">> "); } else { wprintz(w_worlds, c_yellow, " "); } if (world_need_lua_build(world_name)) { wprintz(w_worlds, c_dkgray, "%s (%i)", world_name.c_str(), saves_num); } else { wprintz(w_worlds, c_white, "%s (%i)", world_name.c_str(), saves_num); } } //Draw Tabs mvwprintz(w_worlds_header, 0, 7, c_white, ""); for (size_t i = 0; i < num_pages; ++i) { nc_color tabcolor = (selpage == i) ? hilite(c_white) : c_white; if (!world_pages[i].empty()) { //skip empty pages wprintz(w_worlds_header, c_white, "["); wprintz(w_worlds_header, tabcolor, _("Page %d"), i + 1); wprintz(w_worlds_header, c_white, "]"); wputch(w_worlds_header, BORDER_COLOR, LINE_OXOX); } } wrefresh(w_worlds_header); fold_and_print(w_worlds_tooltip, 0, 0, 78, c_white, _("Pick a world to enter game")); wrefresh(w_worlds_tooltip); wrefresh(w_worlds); const std::string action = ctxt.handle_input(); if (action == "QUIT") { break; } else if (!world_pages[selpage].empty() && action == "DOWN") { sel++; if (sel >= world_pages[selpage].size()) { sel = 0; } } else if (!world_pages[selpage].empty() && action == "UP") { if (sel == 0) { sel = world_pages[selpage].size() - 1; } else { sel--; } } else if (action == "NEXT_TAB") { sel = 0; do { //skip empty pages selpage++; if (selpage >= world_pages.size()) { selpage = 0; } } while(world_pages[selpage].empty()); } else if (action == "PREV_TAB") { sel = 0; do { //skip empty pages if (selpage != 0) { selpage--; } else { selpage = world_pages.size() - 1; } } while(world_pages[selpage].empty()); } else if (action == "CONFIRM") { if (world_need_lua_build(world_pages[selpage][sel])) { popup(_("Can't start in world [%s]. Some of mods require Lua support."), world_pages[selpage][sel].c_str()); continue; } // we are wanting to get out of this by confirmation, so ask if we want to load the level [y/n prompt] and if yes exit if (query_yn(_("Do you want to start the game in world [%s]?"), world_pages[selpage][sel].c_str())) { werase(w_worlds); werase(w_worlds_border); werase(w_worlds_header); werase(w_worlds_tooltip); return all_worlds[world_pages[selpage][sel]];//sel + selpage * iContentHeight; } } } werase(w_worlds); werase(w_worlds_border); werase(w_worlds_header); werase(w_worlds_tooltip); return NULL; }
int main( int argc, char * argv[] ) { int version = 4; int mype = 0; #ifdef MPI int nranks; MPI_Status stat; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nranks); MPI_Comm_rank(MPI_COMM_WORLD, &mype); #endif #ifdef PAPI papi_serial_init(); #endif srand(time(NULL) * (mype+1)); Input input = set_default_input(); read_CLI( argc, argv, &input ); calculate_derived_inputs( &input ); if( mype == 0 ) logo(version); #ifdef OPENMP omp_set_num_threads(input.nthreads); #endif Params params = build_tracks( &input ); CommGrid grid = init_mpi_grid( input ); if( mype == 0 ) print_input_summary(input); float res; float keff = 1.0; int num_iters = 1; double time_transport = 0; double time_flux_exchange = 0; double time_renormalize_flux = 0; double time_update_sources = 0; double time_compute_keff = 0; double start, stop; if(mype==0) { center_print("SIMULATION", 79); border_print(); } for( int i = 0; i < num_iters; i++) { // Transport Sweep start = get_time(); transport_sweep(¶ms, &input); stop = get_time(); time_transport += stop-start; // Domain Boundary Flux Exchange (MPI) #ifdef MPI start = get_time(); fast_transfer_boundary_fluxes(params, input, grid); stop = get_time(); time_flux_exchange += stop-start; #endif // Flux Renormalization start = get_time(); renormalize_flux(params,input, grid); stop = get_time(); time_renormalize_flux += stop-start; // Update Source Regions start = get_time(); res = update_sources(params, input, keff); stop = get_time(); time_update_sources += stop-start; // Calculate K-Effective start = get_time(); keff = compute_keff(params, input, grid); stop = get_time(); time_compute_keff += stop-start; if( mype == 0 ) printf("keff = %f\n", keff); } double time_total = time_transport + time_flux_exchange + time_renormalize_flux + time_update_sources + time_compute_keff; if( mype == 0 ) { border_print(); center_print("RESULTS SUMMARY", 79); border_print(); printf("Transport Sweep Time: %6.2lf sec (%4.1lf%%)\n", time_transport, 100*time_transport/time_total); printf("Domain Flux Exchange Time: %6.2lf sec (%4.1lf%%)\n", time_flux_exchange, 100*time_flux_exchange/time_total); printf("Flux Renormalization Time: %6.2lf sec (%4.1lf%%)\n", time_renormalize_flux, 100*time_renormalize_flux/time_total); printf("Update Source Time: %6.2lf sec (%4.1lf%%)\n", time_update_sources, 100*time_update_sources/time_total); printf("K-Effective Calc Time: %6.2lf sec (%4.1lf%%)\n", time_compute_keff, 100*time_compute_keff/time_total); printf("Total Time: %6.2lf sec\n", time_total); } long tracks_per_second = 2 * input.ntracks/time_transport; #ifdef MPI MPI_Barrier(grid.cart_comm_3d); long global_tps = 0; MPI_Reduce( &tracks_per_second, // Send Buffer &global_tps, // Receive Buffer 1, // Element Count MPI_LONG, // Element Type MPI_SUM, // Reduciton Operation Type 0, // Master Rank grid.cart_comm_3d ); // MPI Communicator MPI_Barrier(grid.cart_comm_3d); tracks_per_second = global_tps; #endif if( mype == 0 ) { printf("Time per Intersection: "); printf("%.2lf ns\n", time_per_intersection( input, time_transport )); border_print(); } free_2D_tracks( params.tracks_2D ); free_tracks( params.tracks ); #ifdef MPI MPI_Finalize(); #endif return 0; }
void run_history_based_simulation(Input input, CalcDataPtrs data, long * abrarov_result, long * alls_result, unsigned long * vhash_result ) { printf("Beginning history based simulation...\n"); long g_abrarov = 0; long g_alls = 0; unsigned long vhash = 0; #pragma omp parallel default(none) \ shared(input, data) \ reduction(+:g_abrarov, g_alls, vhash) { double * xs = (double *) calloc(4, sizeof(double)); int thread = omp_get_thread_num(); long abrarov = 0; long alls = 0; #ifdef PAPI int eventset = PAPI_NULL; int num_papi_events; #pragma omp critical { counter_init(&eventset, &num_papi_events); } #endif complex double * sigTfactors = (complex double *) malloc( input.numL * sizeof(complex double) ); // This loop is independent! // I.e., particle histories can be executed in any order #pragma omp for schedule(guided) for( int p = 0; p < input.particles; p++ ) { // Particles are seeded by their particle ID unsigned long seed = ((unsigned long) p+ (unsigned long)1)* (unsigned long) 13371337; // Randomly pick an energy and material for the particle double E = rn(&seed); int mat = pick_mat(&seed); #ifdef STATUS if( thread == 0 && p % 35 == 0 ) printf("\rCalculating XS's... (%.0lf%% completed)", (p / ( (double)input.particles / (double) input.nthreads )) / (double) input.nthreads * 100.0); #endif // This loop is dependent! // I.e., This loop must be executed sequentially, // as each lookup depends on results from the previous lookup. for( int i = 0; i < input.lookups; i++ ) { double macro_xs[4] = {0}; calculate_macro_xs( macro_xs, mat, E, input, data, sigTfactors, &abrarov, &alls ); // Results are copied onto heap to avoid some compiler // flags (-flto) from optimizing out function call memcpy(xs, macro_xs, 4*sizeof(double)); // Verification hash calculation // This method provides a consistent hash accross // architectures and compilers. #ifdef VERIFICATION char line[256]; sprintf(line, "%.2le %d %.2le %.2le %.2le %.2le", E, mat, macro_xs[0], macro_xs[1], macro_xs[2], macro_xs[3]); unsigned long long vhash_local = hash(line, 10000); vhash += vhash_local; #endif // Randomly pick next energy and material for the particle // Also incorporates results from macro_xs lookup to // enforce loop dependency. // In a real MC app, this dependency is expressed in terms // of branching physics sampling, whereas here we are just // artificially enforcing this dependence based on altering // the seed for( int x = 0; x < 4; x++ ) { if( macro_xs[x] > 0 ) seed += 1337*p; else seed += 42; } E = rn(&seed); mat = pick_mat(&seed); } } free(sigTfactors); // Accumulate global counters g_abrarov = abrarov; g_alls = alls; #ifdef PAPI if( thread == 0 ) { printf("\n"); border_print(); center_print("PAPI COUNTER RESULTS", 79); border_print(); printf("Count \tSmybol \tDescription\n"); } { #pragma omp barrier } counter_stop(&eventset, num_papi_events); #endif } *abrarov_result = g_abrarov; *alls_result = g_alls; *vhash_result = vhash; }
int main( int argc, char* argv[] ) { // ===================================================================== // Initialization & Command Line Read-In // ===================================================================== int version = 13; int mype = 0; int max_procs = omp_get_num_procs(); int i, thread, mat; unsigned long seed; double omp_start, omp_end, p_energy; unsigned long long vhash = 0; int nprocs; #ifdef MPI MPI_Status stat; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); MPI_Comm_rank(MPI_COMM_WORLD, &mype); #endif // rand() is only used in the serial initialization stages. // A custom RNG is used in parallel portions. #ifdef VERIFICATION srand(26); #else srand(time(NULL)); #endif // Process CLI Fields -- store in "Inputs" structure Inputs in = read_CLI( argc, argv ); // Set number of OpenMP Threads omp_set_num_threads(in.nthreads); // Print-out of Input Summary if( mype == 0 ) print_inputs( in, nprocs, version ); // ===================================================================== // Prepare Nuclide Energy Grids, Unionized Energy Grid, & Material Data // ===================================================================== // Allocate & fill energy grids #ifndef BINARY_READ if( mype == 0) printf("Generating Nuclide Energy Grids...\n"); #endif NuclideGridPoint ** nuclide_grids = gpmatrix(in.n_isotopes,in.n_gridpoints); #ifdef VERIFICATION generate_grids_v( nuclide_grids, in.n_isotopes, in.n_gridpoints ); #else generate_grids( nuclide_grids, in.n_isotopes, in.n_gridpoints ); #endif // Sort grids by energy #ifndef BINARY_READ if( mype == 0) printf("Sorting Nuclide Energy Grids...\n"); sort_nuclide_grids( nuclide_grids, in.n_isotopes, in.n_gridpoints ); #endif // Prepare Unionized Energy Grid Framework #ifndef BINARY_READ GridPoint * energy_grid = generate_energy_grid( in.n_isotopes, in.n_gridpoints, nuclide_grids ); #else GridPoint * energy_grid = (GridPoint *)malloc( in.n_isotopes * in.n_gridpoints * sizeof( GridPoint ) ); int * index_data = (int *) malloc( in.n_isotopes * in.n_gridpoints * in.n_isotopes * sizeof(int)); for( i = 0; i < in.n_isotopes*in.n_gridpoints; i++ ) energy_grid[i].xs_ptrs = &index_data[i*in.n_isotopes]; #endif // Double Indexing. Filling in energy_grid with pointers to the // nuclide_energy_grids. #ifndef BINARY_READ set_grid_ptrs( energy_grid, nuclide_grids, in.n_isotopes, in.n_gridpoints ); #endif #ifdef BINARY_READ if( mype == 0 ) printf("Reading data from \"XS_data.dat\" file...\n"); binary_read(in.n_isotopes, in.n_gridpoints, nuclide_grids, energy_grid); #endif // Get material data if( mype == 0 ) printf("Loading Mats...\n"); int *num_nucs = load_num_nucs(in.n_isotopes); int **mats = load_mats(num_nucs, in.n_isotopes); #ifdef VERIFICATION double **concs = load_concs_v(num_nucs); #else double **concs = load_concs(num_nucs); #endif #ifdef BINARY_DUMP if( mype == 0 ) printf("Dumping data to binary file...\n"); binary_dump(in.n_isotopes, in.n_gridpoints, nuclide_grids, energy_grid); if( mype == 0 ) printf("Binary file \"XS_data.dat\" written! Exiting...\n"); return 0; #endif // ===================================================================== // Cross Section (XS) Parallel Lookup Simulation Begins // ===================================================================== // Outer benchmark loop can loop through all possible # of threads #ifdef BENCHMARK for( int bench_n = 1; bench_n <=omp_get_num_procs(); bench_n++ ) { in.nthreads = bench_n; omp_set_num_threads(in.nthreads); #endif if( mype == 0 ) { printf("\n"); border_print(); center_print("SIMULATION", 79); border_print(); } omp_start = omp_get_wtime(); //initialize papi with one thread (master) here #ifdef PAPI if ( PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT){ fprintf(stderr, "PAPI library init error!\n"); exit(1); } #endif // OpenMP compiler directives - declaring variables as shared or private #pragma omp parallel default(none) \ private(i, thread, p_energy, mat, seed) \ shared( max_procs, in, energy_grid, nuclide_grids, \ mats, concs, num_nucs, mype, vhash) { // Initialize parallel PAPI counters #ifdef PAPI int eventset = PAPI_NULL; int num_papi_events; #pragma omp critical { counter_init(&eventset, &num_papi_events); } #endif double macro_xs_vector[5]; double * xs = (double *) calloc(5, sizeof(double)); // Initialize RNG seeds for threads thread = omp_get_thread_num(); seed = (thread+1)*19+17; // XS Lookup Loop #pragma omp for schedule(dynamic) for( i = 0; i < in.lookups; i++ ) { // Status text if( INFO && mype == 0 && thread == 0 && i % 1000 == 0 ) printf("\rCalculating XS's... (%.0lf%% completed)", (i / ( (double)in.lookups / (double) in.nthreads )) / (double) in.nthreads * 100.0); // Randomly pick an energy and material for the particle #ifdef VERIFICATION #pragma omp critical { p_energy = rn_v(); mat = pick_mat(&seed); } #else p_energy = rn(&seed); mat = pick_mat(&seed); #endif // debugging //printf("E = %lf mat = %d\n", p_energy, mat); // This returns the macro_xs_vector, but we're not going // to do anything with it in this program, so return value // is written over. calculate_macro_xs( p_energy, mat, in.n_isotopes, in.n_gridpoints, num_nucs, concs, energy_grid, nuclide_grids, mats, macro_xs_vector ); // Copy results from above function call onto heap // so that compiler cannot optimize function out // (only occurs if -flto flag is used) memcpy(xs, macro_xs_vector, 5*sizeof(double)); // Verification hash calculation // This method provides a consistent hash accross // architectures and compilers. #ifdef VERIFICATION char line[256]; sprintf(line, "%.5lf %d %.5lf %.5lf %.5lf %.5lf %.5lf", p_energy, mat, macro_xs_vector[0], macro_xs_vector[1], macro_xs_vector[2], macro_xs_vector[3], macro_xs_vector[4]); unsigned long long vhash_local = hash(line, 10000); #pragma omp atomic vhash += vhash_local; #endif } // Prints out thread local PAPI counters #ifdef PAPI if( mype == 0 && thread == 0 ) { printf("\n"); border_print(); center_print("PAPI COUNTER RESULTS", 79); border_print(); printf("Count \tSmybol \tDescription\n"); } { #pragma omp barrier } counter_stop(&eventset, num_papi_events); #endif } #ifndef PAPI if( mype == 0) { printf("\n" ); printf("Simulation complete.\n" ); } #endif omp_end = omp_get_wtime(); // Print / Save Results and Exit print_results( in, mype, omp_end-omp_start, nprocs, vhash ); #ifdef BENCHMARK } #endif #ifdef MPI MPI_Finalize(); #endif return 0; }
void inventory_selector::display( const std::string &title, selector_mode mode ) const { werase(w_inv); mvwprintw(w_inv, 0, 0, title.c_str()); // Position of inventory columns is adaptive. They're aligned to the left if they occupy less than 2/3 of the screen. // Otherwise they're aligned symmetrically to the center of the screen. static const float min_ratio_to_center = 1.f / 3; const int free_space = getmaxx( w_inv ) - get_columns_width(); const bool center_align = std::abs( float( free_space ) / getmaxx( w_inv ) ) <= min_ratio_to_center; const int max_gap = ( columns.size() > 1 ) ? free_space / ( columns.size() - 1 ) : 0; const int gap = center_align ? max_gap : std::min<int>( max_gap, 4 ); const int gap_rounding_error = ( center_align && columns.size() > 1 ) ? free_space % ( columns.size() - 1 ) : 0; size_t x = 1; size_t y = 2; size_t active_x = 0; for( const auto &column : columns ) { if( &column == &columns.back() ) { x += gap_rounding_error; } if( !is_active_column( *column ) ) { column->draw( w_inv, x, y ); } else { active_x = x; } if( column->pages_count() > 1 ) { mvwprintw( w_inv, getmaxy( w_inv ) - 2, x, _( "Page %d/%d" ), column->page_index() + 1, column->pages_count() ); } x += column->get_width() + gap; } get_active_column().draw( w_inv, active_x, y ); if( mode == SM_PICK ) { mvwprintw(w_inv, 1, 61, _("Hotkeys: %d/%d "), u.allocated_invlets().size(), inv_chars.size()); } if (mode == SM_MULTIDROP) { // Make copy, remove to be dropped items from that // copy and let the copy recalculate the volume capacity // (can be affected by various traits). player tmp = u; // first round: remove weapon & worn items, start with larges worn index for( const auto &elem : dropping ) { if( elem.first == -1 && elem.second == -1 ) { tmp.remove_weapon(); } else if( elem.first == -1 && elem.second != -1 ) { tmp.weapon.charges -= elem.second; } else if( elem.first < 0 ) { tmp.i_rem( elem.first ); } } remove_dropping_items(tmp); print_inv_weight_vol(tmp.weight_carried(), tmp.volume_carried(), tmp.volume_capacity()); mvwprintw(w_inv, 1, 0, _("To drop x items, type a number and then the item hotkey.")); } else { print_inv_weight_vol(u.weight_carried(), u.volume_carried(), u.volume_capacity()); } if( empty() ) { center_print( w_inv, getmaxy( w_inv ) / 2, c_dkgray, _( "Your inventory is empty." ) ); } const std::string msg_str = ( navigation == navigation_mode::CATEGORY ) ? _( "Category selection; [TAB] switches mode, arrows select." ) : _( "Item selection; [TAB] switches mode, arrows select." ); const nc_color msg_color = ( navigation == navigation_mode::CATEGORY ) ? h_white : c_ltgray; if( center_align ) { center_print( w_inv, getmaxy( w_inv ) - 1, msg_color, msg_str.c_str() ); } else { trim_and_print( w_inv, getmaxy( w_inv ) - 1, 1, getmaxx( w_inv ), msg_color, msg_str.c_str() ); } wrefresh(w_inv); }
int main(int argc, char *argv[]) { Parameters *parameters; // user defined parameters Geometry *geometry; // homogenous cube geometry Material *material; // problem material Bank *source_bank; // array for particle source sites Tally *tally; // scalar flux tally double *keff; // effective multiplication factor double t1, t2; // timers #ifdef _OPENMP unsigned long counter = 0; //counter to decide the start pos of master bank copy from sub banks Bank *g_fission_bank; //global fission bank #endif // Get inputs: set parameters to default values, parse parameter file, // override with any command line inputs, and print parameters parameters = init_parameters(); parse_parameters(parameters); read_CLI(argc, argv, parameters); print_parameters(parameters); // Set initial RNG seed set_initial_seed(parameters->seed); set_stream(STREAM_INIT); // Create files for writing results to init_output(parameters); // Set up geometry geometry = init_geometry(parameters); // Set up material material = init_material(parameters); // Set up tallies tally = init_tally(parameters); // Create source bank and initial source distribution source_bank = init_source_bank(parameters, geometry); // Create fission bank #ifdef _OPENMP omp_set_num_threads(parameters->n_threads); // Set number of openmp threads printf("threads num: %d\n", parameters->n_threads); // Allocate one master fission bank g_fission_bank = init_bank(2*parameters->n_particles); #endif // Set up array for k effective keff = calloc(parameters->n_active, sizeof(double)); center_print("SIMULATION", 79); border_print(); printf("%-15s %-15s %-15s\n", "BATCH", "KEFF", "MEAN KEFF"); #ifdef _OPENMP // Start time t1 = omp_get_wtime(); run_eigenvalue(counter, g_fission_bank, parameters, geometry, material, source_bank, fission_bank, tally, keff); // Stop time t2 = omp_get_wtime(); #endif printf("Simulation time: %f secs\n", t2-t1); // Free memory #ifdef _OPENMP free_bank(g_fission_bank); #endif free(keff); free_tally(tally); free_bank(source_bank); free_material(material); free(geometry); free(parameters); return 0; }
int sokoban_game::start_game() { int iScore = 0; int iMoves = 0; iTotalMoves = 0; int iDirY, iDirX; const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0; const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0; parse_level(); WINDOW *w_sokoban = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, iOffsetY, iOffsetX); draw_border(w_sokoban); center_print(w_sokoban, 0, hilite(c_white), _("Sokoban")); std::vector<std::string> shortcuts; shortcuts.push_back(_("<+> next")); // '+': next shortcuts.push_back(_("<-> prev")); // '-': prev shortcuts.push_back(_("<r>eset")); // 'r': reset shortcuts.push_back(_("<q>uit")); // 'q': quit shortcuts.push_back(_("<u>ndo move")); // 'u': undo move int indent = 10; for (size_t i = 0; i < shortcuts.size(); i++) { indent = std::max(indent, utf8_width(shortcuts[i].c_str()) + 1); } indent = std::min(indent, 30); for (size_t i = 0; i < shortcuts.size(); i++) { shortcut_print(w_sokoban, i + 1, FULL_SCREEN_WIDTH - indent, c_white, c_ltgreen, shortcuts[i].c_str()); } int input = '.'; int iPlayerY = 0; int iPlayerX = 0; bool bNewLevel = true; bool bMoved = false; do { if (bNewLevel) { bNewLevel = false; iMoves = 0; vUndo.clear(); iPlayerY = mLevelInfo[iCurrentLevel]["PlayerY"]; iPlayerX = mLevelInfo[iCurrentLevel]["PlayerX"]; mLevel = vLevel[iCurrentLevel]; } print_score(w_sokoban, iScore, iMoves); if (check_win()) { //we won yay if (!mAlreadyWon[iCurrentLevel]) { iScore += 500; mAlreadyWon[iCurrentLevel] = true; } input = '+'; } else { draw_level(w_sokoban); wrefresh(w_sokoban); //Check input input = getch(); } bMoved = false; switch (input) { case KEY_UP: /* up */ iDirY = -1; iDirX = 0; bMoved = true; break; case KEY_DOWN: /* down */ iDirY = 1; iDirX = 0; bMoved = true; break; case KEY_LEFT: /* left */ iDirY = 0; iDirX = -1; bMoved = true; break; case KEY_RIGHT: /* right */ iDirY = 0; iDirX = 1; bMoved = true; break; case 'q': return iScore; break; case 'u': { int iPlayerYNew = 0; int iPlayerXNew = 0; bool bUndoSkip = false; //undo move if (vUndo.size() > 0) { //reset last player pos mLevel[iPlayerY][iPlayerX] = (mLevel[iPlayerY][iPlayerX] == "+") ? "." : " "; iPlayerYNew = vUndo[vUndo.size() - 1].iOldY; iPlayerXNew = vUndo[vUndo.size() - 1].iOldX; mLevel[iPlayerYNew][iPlayerXNew] = vUndo[vUndo.size() - 1].sTileOld; vUndo.pop_back(); bUndoSkip = true; } if (bUndoSkip && vUndo.size() > 0) { iDirY = vUndo[vUndo.size() - 1].iOldY; iDirX = vUndo[vUndo.size() - 1].iOldX; if (vUndo[vUndo.size() - 1].sTileOld == "$" || vUndo[vUndo.size() - 1].sTileOld == "*") { mLevel[iPlayerY][iPlayerX] = (mLevel[iPlayerY][iPlayerX] == ".") ? "*" : "$"; mLevel[iPlayerY + iDirY][iPlayerX + iDirX] = (mLevel[iPlayerY + iDirY][iPlayerX + iDirX] == "*") ? "." : " "; vUndo.pop_back(); } } if (bUndoSkip) { iPlayerY = iPlayerYNew; iPlayerX = iPlayerXNew; } } break; case 'r': //reset level bNewLevel = true; break; case '+': //next level clear_level(w_sokoban); iCurrentLevel++; if (iCurrentLevel >= iNumLevel) { iCurrentLevel = 0; } bNewLevel = true; break; case '-': //prev level clear_level(w_sokoban); iCurrentLevel--; if (iCurrentLevel < 0) { iCurrentLevel = iNumLevel - 1; } bNewLevel = true; break; default: break; } if (bMoved) { //check if we can move the player std::string sMoveTo = mLevel[iPlayerY + iDirY][iPlayerX + iDirX]; bool bMovePlayer = false; if (sMoveTo != "#") { if (sMoveTo == "$" || sMoveTo == "*") { //Check if we can move the package std::string sMovePackTo = mLevel[iPlayerY + (iDirY * 2)][iPlayerX + (iDirX * 2)]; if (sMovePackTo == "." || sMovePackTo == " ") { //move both bMovePlayer = true; mLevel[iPlayerY + (iDirY * 2)][iPlayerX + (iDirX * 2)] = (sMovePackTo == ".") ? "*" : "$"; vUndo.push_back(cUndo(iDirY, iDirX, sMoveTo)); iMoves--; } } else { bMovePlayer = true; } if (bMovePlayer) { //move player vUndo.push_back(cUndo(iPlayerY, iPlayerX, mLevel[iPlayerY][iPlayerX])); mLevel[iPlayerY][iPlayerX] = (mLevel[iPlayerY][iPlayerX] == "+") ? "." : " "; mLevel[iPlayerY + iDirY][iPlayerX + iDirX] = (sMoveTo == "." || sMoveTo == "*") ? "+" : "@"; iPlayerY += iDirY; iPlayerX += iDirX; iMoves++; iTotalMoves++; } } } } while (true); return iScore; }
// Pick up items at (pos). void Pickup::pick_up( const tripoint &pos, int min ) { int cargo_part = -1; const optional_vpart_position vp = g->m.veh_at( pos ); vehicle *const veh = veh_pointer_or_null( vp ); bool from_vehicle = false; if( min != -1 ) { switch( interact_with_vehicle( veh, pos, vp ? vp->part_index() : -1 ) ) { case DONE: return; case ITEMS_FROM_CARGO: { const cata::optional<vpart_reference> carg = vp.part_with_feature( "CARGO", false ); cargo_part = carg ? carg->part_index() : -1; } from_vehicle = cargo_part >= 0; break; case ITEMS_FROM_GROUND: // Nothing to change, default is to pick from ground anyway. if( g->m.has_flag( "SEALED", pos ) ) { return; } break; } } if( !from_vehicle ) { bool isEmpty = ( g->m.i_at( pos ).empty() ); // Hide the pickup window if this is a toilet and there's nothing here // but water. if( ( !isEmpty ) && g->m.furn( pos ) == f_toilet ) { isEmpty = true; for( auto maybe_water : g->m.i_at( pos ) ) { if( maybe_water.typeId() != "water" ) { isEmpty = false; break; } } } if( isEmpty && ( min != -1 || !get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) { return; } } // which items are we grabbing? std::vector<item> here; if( from_vehicle ) { auto vehitems = veh->get_items( cargo_part ); here.resize( vehitems.size() ); std::copy( vehitems.begin(), vehitems.end(), here.begin() ); } else { auto mapitems = g->m.i_at( pos ); here.resize( mapitems.size() ); std::copy( mapitems.begin(), mapitems.end(), here.begin() ); } if( min == -1 ) { // Recursively pick up adjacent items if that option is on. if( get_option<bool>( "AUTO_PICKUP_ADJACENT" ) && g->u.pos() == pos ) { //Autopickup adjacent direction adjacentDir[8] = {NORTH, NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, NORTHWEST}; for( auto &elem : adjacentDir ) { tripoint apos = tripoint( direction_XY( elem ), 0 ); apos += pos; pick_up( apos, min ); } } // Bail out if this square cannot be auto-picked-up if( g->check_zone( zone_type_id( "NO_AUTO_PICKUP" ), pos ) ) { return; } else if( g->m.has_flag( "SEALED", pos ) ) { return; } } // Not many items, just grab them if( ( int )here.size() <= min && min != -1 ) { g->u.assign_activity( activity_id( "ACT_PICKUP" ) ); g->u.activity.placement = pos - g->u.pos(); g->u.activity.values.push_back( from_vehicle ); // Only one item means index is 0. g->u.activity.values.push_back( 0 ); // auto-pickup means pick up all. g->u.activity.values.push_back( 0 ); return; } std::vector<std::list<item_idx>> stacked_here; for( size_t i = 0; i < here.size(); i++ ) { item &it = here[i]; bool found_stack = false; for( auto &stack : stacked_here ) { if( stack.begin()->_item.stacks_with( it ) ) { item_idx el = { it, i }; stack.push_back( el ); found_stack = true; break; } } if( !found_stack ) { std::list<item_idx> newstack; newstack.push_back( { it, i } ); stacked_here.push_back( newstack ); } } std::reverse( stacked_here.begin(), stacked_here.end() ); if( min != -1 ) { // don't bother if we're just autopickuping g->temp_exit_fullscreen(); } bool sideStyle = use_narrow_sidebar(); // Otherwise, we have Autopickup, 2 or more items and should list them, etc. int maxmaxitems = sideStyle ? TERMY : getmaxy( g->w_messages ) - 3; int itemsH = std::min( 25, TERMY / 2 ); int pickupBorderRows = 3; // The pickup list may consume the entire terminal, minus space needed for its // header/footer and the item info window. int minleftover = itemsH + pickupBorderRows; if( maxmaxitems > TERMY - minleftover ) { maxmaxitems = TERMY - minleftover; } const int minmaxitems = sideStyle ? 6 : 9; std::vector<pickup_count> getitem( stacked_here.size() ); int maxitems = stacked_here.size(); maxitems = ( maxitems < minmaxitems ? minmaxitems : ( maxitems > maxmaxitems ? maxmaxitems : maxitems ) ); int itemcount = 0; if( min == -1 ) { //Auto Pickup, select matching items if( !select_autopickup_items( stacked_here, getitem ) ) { // If we didn't find anything, bail out now. return; } } else { int pickupH = maxitems + pickupBorderRows; int pickupW = getmaxx( g->w_messages ); int pickupY = VIEW_OFFSET_Y; int pickupX = getbegx( g->w_messages ); int itemsW = pickupW; int itemsY = sideStyle ? pickupY + pickupH : TERMY - itemsH; int itemsX = pickupX; catacurses::window w_pickup = catacurses::newwin( pickupH, pickupW, pickupY, pickupX ); catacurses::window w_item_info = catacurses::newwin( itemsH, itemsW, itemsY, itemsX ); std::string action; long raw_input_char = ' '; input_context ctxt( "PICKUP" ); ctxt.register_action( "UP" ); ctxt.register_action( "DOWN" ); ctxt.register_action( "RIGHT" ); ctxt.register_action( "LEFT" ); ctxt.register_action( "NEXT_TAB", _( "Next page" ) ); ctxt.register_action( "PREV_TAB", _( "Previous page" ) ); ctxt.register_action( "SCROLL_UP" ); ctxt.register_action( "SCROLL_DOWN" ); ctxt.register_action( "CONFIRM" ); ctxt.register_action( "SELECT_ALL" ); ctxt.register_action( "QUIT", _( "Cancel" ) ); ctxt.register_action( "ANY_INPUT" ); ctxt.register_action( "HELP_KEYBINDINGS" ); ctxt.register_action( "FILTER" ); int start = 0; int cur_it = 0; bool update = true; mvwprintw( w_pickup, 0, 0, _( "PICK UP" ) ); int selected = 0; int iScrollPos = 0; std::string filter; std::string new_filter; std::vector<int> matches;//Indexes of items that match the filter bool filter_changed = true; if( g->was_fullscreen ) { g->draw_ter(); } // Now print the two lists; those on the ground and about to be added to inv // Continue until we hit return or space do { const std::string pickup_chars = ctxt.get_available_single_char_hotkeys( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ:;" ); int idx = -1; for( int i = 1; i < pickupH; i++ ) { mvwprintw( w_pickup, i, 0, " " ); } if( action == "ANY_INPUT" && raw_input_char >= '0' && raw_input_char <= '9' ) { int raw_input_char_value = ( char )raw_input_char - '0'; itemcount *= 10; itemcount += raw_input_char_value; if( itemcount < 0 ) { itemcount = 0; } } else if( action == "SCROLL_UP" ) { iScrollPos--; } else if( action == "SCROLL_DOWN" ) { iScrollPos++; } else if( action == "PREV_TAB" ) { if( start > 0 ) { start -= maxitems; } else { start = ( int )( ( matches.size() - 1 ) / maxitems ) * maxitems; } selected = start; mvwprintw( w_pickup, maxitems + 2, 0, " " ); } else if( action == "NEXT_TAB" ) { if( start + maxitems < ( int )matches.size() ) { start += maxitems; } else { start = 0; } iScrollPos = 0; selected = start; mvwprintw( w_pickup, maxitems + 2, pickupH, " " ); } else if( action == "UP" ) { selected--; iScrollPos = 0; if( selected < 0 ) { selected = matches.size() - 1; start = ( int )( matches.size() / maxitems ) * maxitems; if( start >= ( int )matches.size() ) { start -= maxitems; } } else if( selected < start ) { start -= maxitems; } } else if( action == "DOWN" ) { selected++; iScrollPos = 0; if( selected >= ( int )matches.size() ) { selected = 0; start = 0; } else if( selected >= start + maxitems ) { start += maxitems; } } else if( selected >= 0 && selected < int( matches.size() ) && ( ( action == "RIGHT" && !getitem[matches[selected]].pick ) || ( action == "LEFT" && getitem[matches[selected]].pick ) ) ) { idx = selected; } else if( action == "FILTER" ) { new_filter = filter; string_input_popup popup; popup .title( _( "Set filter" ) ) .width( 30 ) .edit( new_filter ); if( !popup.canceled() ) { filter_changed = true; } else { wrefresh( g->w_terrain ); } } else if( action == "ANY_INPUT" && raw_input_char == '`' ) { std::string ext = string_input_popup() .title( _( "Enter 2 letters (case sensitive):" ) ) .width( 3 ) .max_length( 2 ) .query_string(); if( ext.size() == 2 ) { int p1 = pickup_chars.find( ext.at( 0 ) ); int p2 = pickup_chars.find( ext.at( 1 ) ); if( p1 != -1 && p2 != -1 ) { idx = pickup_chars.size() + ( p1 * pickup_chars.size() ) + p2; } } } else if( action == "ANY_INPUT" ) { idx = ( raw_input_char <= 127 ) ? pickup_chars.find( raw_input_char ) : -1; iScrollPos = 0; } if( idx >= 0 && idx < ( int )matches.size() ) { size_t true_idx = matches[idx]; if( itemcount != 0 || getitem[true_idx].count == 0 ) { item &temp = stacked_here[true_idx].begin()->_item; int amount_available = temp.count_by_charges() ? temp.charges : stacked_here[true_idx].size(); if( itemcount >= amount_available ) { itemcount = 0; } getitem[true_idx].count = itemcount; itemcount = 0; } // Note: this might not change the value of getitem[idx] at all! getitem[true_idx].pick = ( action == "RIGHT" ? true : ( action == "LEFT" ? false : !getitem[true_idx].pick ) ); if( action != "RIGHT" && action != "LEFT" ) { selected = idx; start = ( int )( idx / maxitems ) * maxitems; } if( !getitem[true_idx].pick ) { getitem[true_idx].count = 0; } update = true; } if( filter_changed ) { matches.clear(); while( matches.empty() ) { auto filter_func = item_filter_from_string( new_filter ); for( size_t index = 0; index < stacked_here.size(); index++ ) { if( filter_func( stacked_here[index].begin()->_item ) ) { matches.push_back( index ); } } if( matches.empty() ) { popup( _( "Your filter returned no results" ) ); wrefresh( g->w_terrain ); // The filter must have results, or simply be emptied or canceled, // as this screen can't be reached without there being // items available string_input_popup popup; popup .title( _( "Set filter" ) ) .width( 30 ) .edit( new_filter ); if( popup.canceled() ) { new_filter = filter; filter_changed = false; } } } if( filter_changed ) { filter = new_filter; filter_changed = false; selected = 0; start = 0; iScrollPos = 0; } wrefresh( g->w_terrain ); } item &selected_item = stacked_here[matches[selected]].begin()->_item; werase( w_item_info ); if( selected >= 0 && selected <= ( int )stacked_here.size() - 1 ) { std::vector<iteminfo> vThisItem; std::vector<iteminfo> vDummy; selected_item.info( true, vThisItem ); draw_item_info( w_item_info, "", "", vThisItem, vDummy, iScrollPos, true, true ); } draw_custom_border( w_item_info, false ); mvwprintw( w_item_info, 0, 2, "< " ); trim_and_print( w_item_info, 0, 4, itemsW - 8, c_white, "%s >", selected_item.display_name().c_str() ); wrefresh( w_item_info ); if( action == "SELECT_ALL" ) { int count = 0; for( auto i : matches ) { if( getitem[i].pick ) { count++; } getitem[i].pick = true; } if( count == ( int )stacked_here.size() ) { for( size_t i = 0; i < stacked_here.size(); i++ ) { getitem[i].pick = false; } } update = true; } for( cur_it = start; cur_it < start + maxitems; cur_it++ ) { mvwprintw( w_pickup, 1 + ( cur_it % maxitems ), 0, " " ); if( cur_it < ( int )matches.size() ) { int true_it = matches[cur_it]; item &this_item = stacked_here[ true_it ].begin()->_item; nc_color icolor = this_item.color_in_inventory(); if( cur_it == selected ) { icolor = hilite( icolor ); } if( cur_it < ( int )pickup_chars.size() ) { mvwputch( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor, char( pickup_chars[cur_it] ) ); } else if( cur_it < ( int )pickup_chars.size() + ( int )pickup_chars.size() * ( int )pickup_chars.size() ) { int p = cur_it - pickup_chars.size(); int p1 = p / pickup_chars.size(); int p2 = p % pickup_chars.size(); mvwprintz( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor, "`%c%c", char( pickup_chars[p1] ), char( pickup_chars[p2] ) ); } else { mvwputch( w_pickup, 1 + ( cur_it % maxitems ), 0, icolor, ' ' ); } if( getitem[true_it].pick ) { if( getitem[true_it].count == 0 ) { wprintz( w_pickup, c_light_blue, " + " ); } else { wprintz( w_pickup, c_light_blue, " # " ); } } else { wprintw( w_pickup, " - " ); } std::string item_name; if( stacked_here[true_it].begin()->_item.ammo_type() == "money" ) { //Count charges //TODO: transition to the item_location system used for the inventory unsigned long charges_total = 0; for( const auto item : stacked_here[true_it] ) { charges_total += item._item.charges; } //Picking up none or all the cards in a stack if( !getitem[true_it].pick || getitem[true_it].count == 0 ) { item_name = stacked_here[true_it].begin()->_item.display_money( stacked_here[true_it].size(), charges_total ); } else { unsigned long charges = 0; int c = getitem[true_it].count; for( auto it = stacked_here[true_it].begin(); it != stacked_here[true_it].end() && c > 0; ++it, --c ) { charges += it->_item.charges; } item_name = string_format( _( "%s of %s" ), stacked_here[true_it].begin()->_item.display_money( getitem[true_it].count, charges ), format_money( charges_total ) ); } } else { item_name = this_item.display_name( stacked_here[true_it].size() ); } if( stacked_here[true_it].size() > 1 ) { item_name = string_format( "%d %s", stacked_here[true_it].size(), item_name.c_str() ); } if( get_option<bool>( "ITEM_SYMBOLS" ) ) { item_name = string_format( "%s %s", this_item.symbol().c_str(), item_name.c_str() ); } trim_and_print( w_pickup, 1 + ( cur_it % maxitems ), 6, pickupW - 4, icolor, item_name ); } } mvwprintw( w_pickup, maxitems + 1, 0, _( "[%s] Unmark" ), ctxt.get_desc( "LEFT", 1 ).c_str() ); center_print( w_pickup, maxitems + 1, c_light_gray, string_format( _( "[%s] Help" ), ctxt.get_desc( "HELP_KEYBINDINGS", 1 ).c_str() ) ); right_print( w_pickup, maxitems + 1, 0, c_light_gray, string_format( _( "[%s] Mark" ), ctxt.get_desc( "RIGHT", 1 ).c_str() ) ); mvwprintw( w_pickup, maxitems + 2, 0, _( "[%s] Prev" ), ctxt.get_desc( "PREV_TAB", 1 ).c_str() ); center_print( w_pickup, maxitems + 2, c_light_gray, string_format( _( "[%s] All" ), ctxt.get_desc( "SELECT_ALL", 1 ).c_str() ) ); right_print( w_pickup, maxitems + 2, 0, c_light_gray, string_format( _( "[%s] Next" ), ctxt.get_desc( "NEXT_TAB", 1 ).c_str() ) ); if( update ) { // Update weight & volume information update = false; for( int i = 9; i < pickupW; ++i ) { mvwaddch( w_pickup, 0, i, ' ' ); } units::mass weight_picked_up = 0; units::volume volume_picked_up = 0; for( size_t i = 0; i < getitem.size(); i++ ) { if( getitem[i].pick ) { item temp = stacked_here[i].begin()->_item; if( temp.count_by_charges() && getitem[i].count < temp.charges && getitem[i].count != 0 ) { temp.charges = getitem[i].count; } int num_picked = std::min( stacked_here[i].size(), getitem[i].count == 0 ? stacked_here[i].size() : getitem[i].count ); weight_picked_up += temp.weight() * num_picked; volume_picked_up += temp.volume() * num_picked; } } auto weight_predict = g->u.weight_carried() + weight_picked_up; auto volume_predict = g->u.volume_carried() + volume_picked_up; mvwprintz( w_pickup, 0, 9, weight_predict > g->u.weight_capacity() ? c_red : c_white, _( "Wgt %.1f" ), round_up( convert_weight( weight_predict ), 1 ) ); wprintz( w_pickup, c_white, "/%.1f", round_up( convert_weight( g->u.weight_capacity() ), 1 ) ); std::string fmted_volume_predict = format_volume( volume_predict ); mvwprintz( w_pickup, 0, 24, volume_predict > g->u.volume_capacity() ? c_red : c_white, _( "Vol %s" ), fmted_volume_predict.c_str() ); std::string fmted_volume_capacity = format_volume( g->u.volume_capacity() ); wprintz( w_pickup, c_white, "/%s", fmted_volume_capacity.c_str() ); }; wrefresh( w_pickup ); action = ctxt.handle_input(); raw_input_char = ctxt.get_raw_input().get_first_input(); } while( action != "QUIT" && action != "CONFIRM" ); bool item_selected = false; // Check if we have selected an item. for( auto selection : getitem ) { if( selection.pick ) { item_selected = true; } } if( action != "CONFIRM" || !item_selected ) { w_pickup = catacurses::window(); w_item_info = catacurses::window(); add_msg( _( "Never mind." ) ); g->reenter_fullscreen(); g->refresh_all(); return; } } // At this point we've selected our items, register an activity to pick them up. g->u.assign_activity( activity_id( "ACT_PICKUP" ) ); g->u.activity.placement = pos - g->u.pos(); g->u.activity.values.push_back( from_vehicle ); if( min == -1 ) { // Auto pickup will need to auto resume since there can be several of them on the stack. g->u.activity.auto_resume = true; } std::vector<std::pair<int, int>> pick_values; for( size_t i = 0; i < stacked_here.size(); i++ ) { const auto &selection = getitem[i]; if( !selection.pick ) { continue; } const auto &stack = stacked_here[i]; // Note: items can be both charged and stacked // For robustness, let's assume they can be both in the same stack bool pick_all = selection.count == 0; size_t count = selection.count; for( const item_idx &it : stack ) { if( !pick_all && count == 0 ) { break; } if( it._item.count_by_charges() ) { size_t num_picked = std::min( ( size_t )it._item.charges, count ); pick_values.push_back( { static_cast<int>( it.idx ), static_cast<int>( num_picked ) } ); count -= num_picked; } else { size_t num_picked = 1; pick_values.push_back( { static_cast<int>( it.idx ), 0 } ); count -= num_picked; } } } // The pickup activity picks up items last-to-first from its values list, so make sure the // higher indices are at the end. std::sort( pick_values.begin(), pick_values.end() ); for( auto &it : pick_values ) { g->u.activity.values.push_back( it.first ); g->u.activity.values.push_back( it.second ); } g->reenter_fullscreen(); }
void input_context::display_help() { inp_mngr.reset_timeout(); // Shamelessly stolen from help.cpp WINDOW *w_help = newwin( FULL_SCREEN_HEIGHT - 2, FULL_SCREEN_WIDTH - 2, 1 + ( int )( ( TERMY > FULL_SCREEN_HEIGHT ) ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ), 1 + ( int )( ( TERMX > FULL_SCREEN_WIDTH ) ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0 ) ); // has the user changed something? bool changed = false; // keybindings before the user changed anything. input_manager::t_action_contexts old_action_contexts( inp_mngr.action_contexts ); // current status: adding/removing/showing keybindings enum { s_remove, s_add, s_add_global, s_show } status = s_show; // copy of registered_actions, but without the ANY_INPUT and COORDINATE, which should not be shown std::vector<std::string> org_registered_actions( registered_actions ); org_registered_actions.erase( std::remove_if( org_registered_actions.begin(), org_registered_actions.end(), []( const std::string & a ) { return a == ANY_INPUT || a == COORDINATE; } ), org_registered_actions.end() ); // colors of the keybindings static const nc_color global_key = c_ltgray; static const nc_color local_key = c_ltgreen; static const nc_color unbound_key = c_ltred; // (vertical) scroll offset size_t scroll_offset = 0; // height of the area usable for display of keybindings, excludes headers & borders const size_t display_height = FULL_SCREEN_HEIGHT - 11 - 2; // -2 for the border // width of the legend const size_t legwidth = FULL_SCREEN_WIDTH - 4 - 2; // keybindings help std::ostringstream legend; legend << "<color_" << string_from_color( unbound_key ) << ">" << _( "Unbound keys" ) << "</color>\n"; legend << "<color_" << string_from_color( local_key ) << ">" << _( "Keybinding active only on this screen" ) << "</color>\n"; legend << "<color_" << string_from_color( global_key ) << ">" << _( "Keybinding active globally" ) << "</color>\n"; legend << _( "Press - to remove keybinding\nPress + to add local keybinding\nPress = to add global keybinding\n" ); input_context ctxt( "HELP_KEYBINDINGS" ); ctxt.register_action( "UP", _( "Scroll up" ) ); ctxt.register_action( "DOWN", _( "Scroll down" ) ); ctxt.register_action( "PAGE_DOWN" ); ctxt.register_action( "PAGE_UP" ); ctxt.register_action( "REMOVE" ); ctxt.register_action( "ADD_LOCAL" ); ctxt.register_action( "ADD_GLOBAL" ); ctxt.register_action( "QUIT" ); ctxt.register_action( "ANY_INPUT" ); if( category != "HELP_KEYBINDINGS" ) { // avoiding inception! ctxt.register_action( "HELP_KEYBINDINGS" ); } std::string hotkeys = ctxt.get_available_single_char_hotkeys( display_help_hotkeys ); std::vector<std::string> filtered_registered_actions = org_registered_actions; std::string filter_phrase; std::string action; long raw_input_char = 0; string_input_popup spopup; spopup.window( w_help, 4, 8, legwidth ) .max_length( legwidth ) .context( ctxt ); while( true ) { werase( w_help ); draw_border( w_help ); draw_scrollbar( w_help, scroll_offset, display_height, filtered_registered_actions.size(), 10, 0, c_white, true ); center_print( w_help, 0, c_ltred, _( "Keybindings" ) ); fold_and_print( w_help, 1, 2, legwidth, c_white, legend.str() ); for( size_t i = 0; i + scroll_offset < filtered_registered_actions.size() && i < display_height; i++ ) { const std::string &action_id = filtered_registered_actions[i + scroll_offset]; bool overwrite_default; const action_attributes &attributes = inp_mngr.get_action_attributes( action_id, category, &overwrite_default ); char invlet; if( i < hotkeys.size() ) { invlet = hotkeys[i]; } else { invlet = ' '; } if( status == s_add_global && overwrite_default ) { // We're trying to add a global, but this action has a local // defined, so gray out the invlet. mvwprintz( w_help, i + 10, 2, c_dkgray, "%c ", invlet ); } else if( status == s_add || status == s_add_global ) { mvwprintz( w_help, i + 10, 2, c_blue, "%c ", invlet ); } else if( status == s_remove ) { mvwprintz( w_help, i + 10, 2, c_blue, "%c ", invlet ); } else { mvwprintz( w_help, i + 10, 2, c_blue, " " ); } nc_color col; if( attributes.input_events.empty() ) { col = unbound_key; } else if( overwrite_default ) { col = local_key; } else { col = global_key; } mvwprintz( w_help, i + 10, 4, col, "%s: ", get_action_name( action_id ).c_str() ); mvwprintz( w_help, i + 10, 52, col, "%s", get_desc( action_id ).c_str() ); } // spopup.query_string() will call wrefresh( w_help ) refresh(); spopup.text( filter_phrase ); if( status == s_show ) { filter_phrase = spopup.query_string( false ); action = ctxt.input_to_action( ctxt.get_raw_input() ); } else { spopup.query_string( false, true ); action = ctxt.handle_input(); } raw_input_char = ctxt.get_raw_input().get_first_input(); filtered_registered_actions = filter_strings_by_phrase( org_registered_actions, filter_phrase ); if( scroll_offset > filtered_registered_actions.size() ) { scroll_offset = 0; } if( filtered_registered_actions.size() == 0 && action != "QUIT" ) { continue; } // In addition to the modifiable hotkeys, we also check for hardcoded // keys, e.g. '+', '-', '=', in order to prevent the user from // entering an unrecoverable state. if( action == "ADD_LOCAL" || raw_input_char == '+' ) { status = s_add; } else if( action == "ADD_GLOBAL" || raw_input_char == '=' ) { status = s_add_global; } else if( action == "REMOVE" || raw_input_char == '-' ) { status = s_remove; } else if( action == "ANY_INPUT" ) { const size_t hotkey_index = hotkeys.find_first_of( raw_input_char ); if( hotkey_index == std::string::npos ) { continue; } const size_t action_index = hotkey_index + scroll_offset; if( action_index >= filtered_registered_actions.size() ) { continue; } const std::string &action_id = filtered_registered_actions[action_index]; // Check if this entry is local or global. bool is_local = false; inp_mngr.get_action_attributes( action_id, category, &is_local ); const std::string name = get_action_name( action_id ); if( status == s_remove && ( !get_option<bool>( "QUERY_KEYBIND_REMOVAL" ) || query_yn( _( "Clear keys for %s?" ), name.c_str() ) ) ) { // If it's global, reset the global actions. std::string category_to_access = category; if( !is_local ) { category_to_access = default_context_id; } inp_mngr.remove_input_for_action( action_id, category_to_access ); changed = true; } else if( status == s_add_global && is_local ) { // Disallow adding global actions to an action that already has a local defined. popup( _( "There are already local keybindings defined for this action, please remove them first." ) ); } else if( status == s_add || status == s_add_global ) { const long newbind = popup_getkey( _( "New key for %s:" ), name.c_str() ); const input_event new_event( newbind, CATA_INPUT_KEYBOARD ); if( action_uses_input( action_id, new_event ) ) { popup_getkey( _( "This key is already used for %s." ), name.c_str() ); status = s_show; continue; } const std::string conflicts = get_conflicts( new_event ); const bool has_conflicts = !conflicts.empty(); bool resolve_conflicts = false; if( has_conflicts ) { resolve_conflicts = query_yn( _( "This key conflicts with %s. Remove this key from the conflicting command(s), and continue?" ), conflicts.c_str() ); } if( !has_conflicts || resolve_conflicts ) { if( resolve_conflicts ) { clear_conflicting_keybindings( new_event ); } // We might be adding a local or global action. std::string category_to_access = category; if( status == s_add_global ) { category_to_access = default_context_id; } inp_mngr.add_input_for_action( action_id, category_to_access, new_event ); changed = true; } } status = s_show; } else if( action == "DOWN" ) { if( filtered_registered_actions.size() > display_height && scroll_offset < filtered_registered_actions.size() - display_height ) { scroll_offset++; } } else if( action == "UP" ) { if( scroll_offset > 0 ) { scroll_offset--; } } else if( action == "PAGE_DOWN" ) { if( scroll_offset + display_height < filtered_registered_actions.size() ) { scroll_offset += std::min( display_height, filtered_registered_actions.size() - display_height - scroll_offset ); } else if( filtered_registered_actions.size() > display_height ) { scroll_offset = 0; } } else if( action == "PAGE_UP" ) { if( scroll_offset >= display_height ) { scroll_offset -= display_height; } else if( scroll_offset > 0 ) { scroll_offset = 0; } else if( filtered_registered_actions.size() > display_height ) { scroll_offset = filtered_registered_actions.size() - display_height; } } else if( action == "QUIT" ) { if( status != s_show ) { status = s_show; } else { break; } } else if( action == "HELP_KEYBINDINGS" ) { // update available hotkeys in case they've changed hotkeys = ctxt.get_available_single_char_hotkeys( display_help_hotkeys ); } } if( changed && query_yn( _( "Save changes?" ) ) ) { try { inp_mngr.save(); } catch( std::exception &err ) { popup( _( "saving keybindings failed: %s" ), err.what() ); } } else if( changed ) { inp_mngr.action_contexts.swap( old_action_contexts ); } werase( w_help ); wrefresh( w_help ); delwin( w_help ); }
// Stops the papi counters and prints results void counter_stop( int * eventset, int num_papi_events, Input * I ) { int * events = malloc(num_papi_events * sizeof(int)); int n = num_papi_events; PAPI_list_events( *eventset, events, &n ); PAPI_event_info_t info; long_long * values = malloc( num_papi_events * sizeof(long_long)); PAPI_stop(*eventset, values); int thread = omp_get_thread_num(); int nthreads = omp_get_num_threads(); static long LLC_cache_miss = 0; static long total_cycles = 0; static long FLOPS = 0; static long stall_any = 0; static long stall_SB = 0; static long stall_RS = 0; static long stall_OO = 0; static long tlb_load = 0; static long tlb_load_m = 0; static long tlb_store = 0; static long tlb_store_m = 0; #pragma omp master { I->vals_accum = malloc( num_papi_events * sizeof(long long)); for(int i=0; i < num_papi_events ; i ++) I->vals_accum[i] = 0; } #pragma omp barrier #pragma omp critical (papi) { printf("Thread %d\n", thread); for( int i = 0; i < num_papi_events; i++ ) { I->vals_accum[i] += values[i]; PAPI_get_event_info(events[i], &info); printf("%-15lld\t%s\t%s\n", values[i],info.symbol,info.long_descr); if( strcmp(info.symbol, "PAPI_L3_TCM") == 0 ) LLC_cache_miss += values[i]; if( strcmp(info.symbol, "PAPI_TOT_CYC") == 0 ) total_cycles += values[i]; if( strcmp(info.symbol, "PAPI_SP_OPS") == 0 ) FLOPS += values[i]; if( strcmp(info.symbol, "RESOURCE_STALLS:ANY") == 0 ) stall_any += values[i]; if( strcmp(info.symbol, "RESOURCE_STALLS:SB") == 0 ) stall_SB += values[i]; if( strcmp(info.symbol, "RESOURCE_STALLS:RS") == 0 ) stall_RS += values[i]; if( strcmp(info.symbol, "RESOURCE_STALLS2:OOO_RSRC") == 0 ) stall_OO += values[i]; if( strcmp(info.symbol, "perf::DTLB-LOADS") == 0 ) tlb_load += values[i]; if( strcmp(info.symbol, "perf::DTLB-LOAD-MISSES") == 0 ) tlb_load_m += values[i]; if( strcmp(info.symbol, "perf::DTLB-STORES") == 0 ) tlb_store += values[i]; if( strcmp(info.symbol, "perf::DTLB-STORE-MISSES") == 0 ) tlb_store_m += values[i]; } free(values); } { #pragma omp barrier } #pragma omp master { if( omp_get_num_threads() > 1){ printf("Thread Totals:\n"); for( int i = 0; i < num_papi_events; i++ ) { PAPI_get_event_info(events[i], &info); printf("%-15lld\t%s\t%s\n", I->vals_accum[i],info.symbol,info.long_descr); } } free( I->vals_accum ); border_print(); center_print("PERFORMANCE SUMMARY", 79); border_print(); long cycles = (long) (total_cycles / (double) nthreads); double bw = LLC_cache_miss*64./cycles*2.8e9/1024./1024./1024.; if( I->papi_event_set == 0 ) printf("GFLOPs: %.3lf\n", FLOPS / (double) cycles * 2.8 ); if( I->papi_event_set == 1 ) printf("Bandwidth: %.3lf (GB/s)\n", bw); if( I->papi_event_set == 2 ) { printf("%-30s %.2lf%%\n", "Store Buffer Full:", stall_SB / (double) stall_any * 100.); printf("%-30s %.2lf%%\n", "Reservation Station Full:", stall_RS / (double) stall_any * 100.); printf("%-30s %.2lf%%\n", "OO Pipeline Full:", stall_OO / (double) stall_any * 100.); } if( I->papi_event_set == 3 ) printf("CPU Stalled Cycles: %.2lf%%\n", stall_any / (double) total_cycles * 100.); if( I->papi_event_set == 7 ) { printf("%-30s %.2lf%%\n", "Data TLB Load Miss Rate: ", tlb_load_m / (double) tlb_load * 100 ); printf("%-30s %.2lf%%\n", "Data TLB Store Miss Rate: ", tlb_store_m / (double) tlb_store * 100 ); } border_print(); } free(events); }