read_inventory_preset( const player &p ) : pickup_inventory_preset( p ), p( p ) {
static const std::string unknown( _( "<color_dark_gray>?</color>" ) );
static const std::string martial_arts( _( "martial arts" ) );
append_cell( [ this, &p ]( const item_location & loc ) -> std::string {
if( loc->type->can_use( "MA_MANUAL" ) ) {
return martial_arts;
}
if( !is_known( loc ) ) {
return unknown;
}
const auto &book = get_book( loc );
if( book.skill && p.get_skill_level_object( book.skill ).can_train() ) {
return string_format( _( "%s to %d" ), book.skill->name().c_str(), book.level );
}
return std::string();
}, _( "TRAINS" ), unknown );
append_cell( [ this ]( const item_location & loc ) -> std::string {
if( !is_known( loc ) ) {
return unknown;
}
const auto &book = get_book( loc );
const int unlearned = book.recipes.size() - get_known_recipes( book );
return unlearned > 0 ? to_string( unlearned ) : std::string();
}, _( "RECIPES" ), unknown );
append_cell( [ this ]( const item_location & loc ) -> std::string {
if( !is_known( loc ) ) {
return unknown;
}
return good_bad_none( get_book( loc ).fun );
}, _( "FUN" ), unknown );
append_cell( [ this, &p ]( const item_location & loc ) -> std::string {
if( !is_known( loc ) ) {
return unknown;
}
std::vector<std::string> dummy;
const player *reader = p.get_book_reader( *loc, dummy );
if( reader == nullptr ) {
return std::string(); // Just to make sure
}
// Actual reading time (in turns). Can be penalized.
const int actual_turns = p.time_to_read( *loc, *reader ) / MOVES( 1 );
// Theoretical reading time (in turns) based on the reader speed. Free of penalties.
const int normal_turns = get_book( loc ).time * reader->read_speed() / MOVES( 1 );
const std::string duration = to_string_approx( time_duration::from_turns( actual_turns ), false );
if( actual_turns > normal_turns ) { // Longer - complicated stuff.
return string_format( "<color_light_red>%s</color>", duration.c_str() );
}
return duration; // Normal speed.
}, _( "CHAPTER IN" ), unknown );
}
/** @brief Splits a list into an even and an odd list
*
* @param list the List to be splitted (this list will retain de odd numbers)
* @return the list containing the even numbers
*/
List *split_by_parity(List *list){
List *odd_list = new_empty_list();
List *even_list = new_empty_list();
while(is_empty(list) != 1){
if(list->first->content % 2 != 0){
append_cell(odd_list, remove_by_idx(list, 0));
} else {
append_cell(even_list, remove_by_idx(list, 0));
}
}
list->first = even_list->first;
free(even_list);
return odd_list;
}
gunmod_inventory_preset( const player &p, const item &gunmod ) : p( p ), gunmod( gunmod ) {
append_cell( [ this ]( const item_location & loc ) {
const auto odds = get_odds( loc );
if( odds.first >= 100 ) {
return string_format( "<color_light_green>%s</color>", _( "always" ) );
}
return string_format( "<color_light_green>%d%%</color>", odds.first );
}, _( "SUCCESS CHANCE" ) );
append_cell( [ this ]( const item_location & loc ) {
return good_bad_none( get_odds( loc ).second );
}, _( "DAMAGE RISK" ) );
}
activatable_inventory_preset( const player &p ) : pickup_inventory_preset( p ), p( p ) {
if( get_option<bool>( "INV_USE_ACTION_NAMES" ) ) {
append_cell( [ this ]( const item_location & loc ) {
return string_format( "<color_ltgreen>%s</color>", get_action_name( loc ).c_str() );
}, _( "ACTION" ) );
}
}
int main(void) {
cell_t *head_cell = create_cell(0);
for(int i = 1; i < 11; i++) {
append_cell(head_cell, create_cell(i));
}
printCells(head_cell);
insert_nth(head_cell, create_cell(100), 3);
printCells(head_cell);
return 0;
}
disassemble_inventory_preset( const player &p, const inventory &inv ) :
pickup_inventory_preset( p ), p( p ), inv( inv ) {
append_cell( [ this ]( const item_location & loc ) {
const auto &req = get_recipe( loc ).disassembly_requirements();
if( req.is_empty() ) {
return std::string();
}
const auto components = req.get_components();
return enumerate_as_string( components.begin(), components.end(),
[]( const decltype( components )::value_type & comps ) {
return comps.front().to_string();
} );
}, _( "YIELD" ) );
append_cell( [ this ]( const item_location & loc ) {
return to_string_clipped( time_duration::from_turns( get_recipe( loc ).time / 100 ) );
}, _( "TIME" ) );
}
void enumerated_subrange<GRID,GT>::construct(CELLIT c)
{
REQUIRE_ALWAYS(cells.empty(), "enumerated_subrange<GRID>::construct: cells must be empty!",1);
while(! c.IsDone()) {
append_cell(c.handle());
++c;
}
init();
init_counts();
}
armor_inventory_preset( const std::string &color_in ) : color( color_in ) {
append_cell( [ this ]( const item_location & loc ) {
return get_number_string( loc->get_encumber() );
}, _( "ENCUMBRANCE" ) );
append_cell( [ this ]( const item_location & loc ) {
return loc->get_storage() > 0 ? string_format( "<%s>%s</color>", color,
format_volume( loc->get_storage() ) ) : std::string();
}, _( "STORAGE" ) );
append_cell( [ this ]( const item_location & loc ) {
return string_format( "<%s>%d%%</color>", color, loc->get_coverage() );
}, _( "COVERAGE" ) );
append_cell( [ this ]( const item_location & loc ) {
return get_number_string( loc->get_warmth() );
}, _( "WARMTH" ) );
append_cell( [ this ]( const item_location & loc ) {
return get_number_string( loc->bash_resist() );
}, _( "BASH" ) );
append_cell( [ this ]( const item_location & loc ) {
return get_number_string( loc->cut_resist() );
}, _( "CUT" ) );
append_cell( [ this ]( const item_location & loc ) {
return get_number_string( loc->acid_resist() );
}, _( "ACID" ) );
append_cell( [ this ]( const item_location & loc ) {
return get_number_string( loc->fire_resist() );
}, _( "FIRE" ) );
append_cell( [ this ]( const item_location & loc ) {
return get_number_string( loc->get_env_resist() );
}, _( "ENV" ) );
}
comestible_inventory_preset( const player &p ) : inventory_selector_preset(), p( p ) {
append_cell( [ p, this ]( const item_location & loc ) {
return good_bad_none( p.nutrition_for( get_comestible_item( loc ) ) );
}, _( "NUTRITION" ) );
append_cell( [ this ]( const item_location & loc ) {
return good_bad_none( get_edible_comestible( loc ).quench );
}, _( "QUENCH" ) );
append_cell( [ p, this ]( const item_location & loc ) {
return good_bad_none( p.fun_for( get_comestible_item( loc ) ).first );
}, _( "JOY" ) );
append_cell( [ this ]( const item_location & loc ) {
const int spoils = get_edible_comestible( loc ).spoils;
if( spoils > 0 ) {
return to_string_clipped( time_duration::from_turns( spoils ) );
}
return std::string();
}, _( "SPOILS IN" ) );
append_cell( [ this, &p ]( const item_location & loc ) {
std::string cbm_name;
switch( p.get_cbm_rechargeable_with( get_comestible_item( loc ) ) ) {
case rechargeable_cbm::none:
break;
case rechargeable_cbm::battery:
cbm_name = _( "Battery" );
break;
case rechargeable_cbm::reactor:
cbm_name = _( "Reactor" );
break;
case rechargeable_cbm::furnace:
cbm_name = _( "Furnace" );
break;
}
if( !cbm_name.empty() ) {
return string_format( "<color_cyan>%s</color>", cbm_name.c_str() );
}
return std::string();
}, _( "CBM" ) );
append_cell( [ this, &p ]( const item_location & loc ) {
return good_bad_none( p.get_acquirable_energy( get_comestible_item( loc ) ) );
}, _( "ENERGY" ) );
}
weapon_inventory_preset( const player &p ) : p( p ) {
append_cell( [ this ]( const item_location & loc ) {
if( !loc->is_gun() ) {
return std::string();
}
const int total_damage = loc->gun_damage( true );
if( loc->ammo_data() && loc->ammo_remaining() ) {
const int basic_damage = loc->gun_damage( false );
const int ammo_damage = loc->ammo_data()->ammo->damage;
return string_format( "%s<color_light_gray>+</color>%s <color_light_gray>=</color> %s",
get_damage_string( basic_damage, true ).c_str(),
get_damage_string( ammo_damage, true ).c_str(),
get_damage_string( total_damage, true ).c_str()
);
} else {
return get_damage_string( total_damage );
}
}, pgettext( "Shot as damage", "SHOT" ) );
append_cell( [ this ]( const item_location & loc ) {
return get_damage_string( loc->damage_melee( DT_BASH ) );
}, _( "BASH" ) );
append_cell( [ this ]( const item_location & loc ) {
return get_damage_string( loc->damage_melee( DT_CUT ) );
}, _( "CUT" ) );
append_cell( [ this ]( const item_location & loc ) {
return get_damage_string( loc->damage_melee( DT_STAB ) );
}, _( "STAB" ) );
append_cell( [ this ]( const item_location & loc ) {
if( deals_melee_damage( *loc ) ) {
return good_bad_none( loc->type->m_to_hit );
}
return std::string();
}, _( "MELEE" ) );
append_cell( [ this ]( const item_location & loc ) {
if( deals_melee_damage( *loc ) ) {
return string_format( "<color_yellow>%d</color>", this->p.attack_speed( *loc ) );
}
return std::string();
}, _( "MOVES" ) );
}
