void TCOD_console_set_color_control_wrapper(TCOD_colctrl_t con, colornum_t fore, colornum_t back) { TCOD_console_set_color_control (con, int_to_color(fore), int_to_color(back)); }
void it_artifact_armor::deserialize(JsonObject &jo) { id = jo.get_string("id"); name = jo.get_string("name"); description = jo.get_string("description"); sym = jo.get_int("sym"); color = int_to_color(jo.get_int("color")); price = jo.get_int("price"); m1 = jo.get_string("m1"); m2 = jo.get_string("m2"); volume = jo.get_int("volume"); weight = jo.get_int("weight"); melee_dam = jo.get_int("melee_dam"); melee_cut = jo.get_int("melee_cut"); m_to_hit = jo.get_int("m_to_hit"); item_tags = jo.get_tags("item_flags"); covers = jo.get_int("covers"); encumber = jo.get_int("encumber"); coverage = jo.get_int("coverage"); thickness = jo.get_int("material_thickness"); env_resist = jo.get_int("env_resist"); warmth = jo.get_int("warmth"); storage = jo.get_int("storage"); power_armor = jo.get_bool("power_armor"); JsonArray ja = jo.get_array("effects_worn"); while (ja.has_more()) { effects_worn.push_back((art_effect_passive)ja.next_int()); } }
void it_artifact_armor::deserialize(JsonObject &jo) { id = jo.get_string("id"); name = jo.get_string("name"); description = jo.get_string("description"); sym = jo.get_int("sym"); color = int_to_color(jo.get_int("color")); price = jo.get_int("price"); // LEGACY: Since it seems artifacts get serialized out to disk, and they're // dynamic, we need to allow for them to be read from disk for, oh, I guess // quite some time. Loading and saving once will write things out as a JSON // array. if (jo.has_string("m1")) { materials.push_back(jo.get_string("m1")); } if (jo.has_string("m2")) { materials.push_back(jo.get_string("m2")); } // Assumption, perhaps dangerous, that we won't wind up with m1 and m2 and // a materials array in our serialized objects at the same time. if (jo.has_array("materials")) { JsonArray jarr = jo.get_array("materials"); for (int i = 0; i < jarr.size(); ++i) { materials.push_back(jarr.get_string(i)); } } if (materials.size() == 0) { // I don't think we need this, but a lot of code seems to want at least // one material and I'm not sure I found every single corner case. materials.push_back("null"); } volume = jo.get_int("volume"); weight = jo.get_int("weight"); melee_dam = jo.get_int("melee_dam"); melee_cut = jo.get_int("melee_cut"); m_to_hit = jo.get_int("m_to_hit"); item_tags = jo.get_tags("item_flags"); jo.read( "covers", covers); encumber = jo.get_int("encumber"); coverage = jo.get_int("coverage"); thickness = jo.get_int("material_thickness"); env_resist = jo.get_int("env_resist"); warmth = jo.get_int("warmth"); storage = jo.get_int("storage"); power_armor = jo.get_bool("power_armor"); JsonArray ja = jo.get_array("effects_worn"); while (ja.has_more()) { effects_worn.push_back((art_effect_passive)ja.next_int()); } }
void it_artifact_tool::deserialize(JsonObject &jo) { id = jo.get_string("id"); name = jo.get_string("name"); description = jo.get_string("description"); sym = jo.get_int("sym"); color = int_to_color(jo.get_int("color")); price = jo.get_int("price"); m1 = jo.get_string("m1"); m2 = jo.get_string("m2"); volume = jo.get_int("volume"); weight = jo.get_int("weight"); melee_dam = jo.get_int("melee_dam"); melee_cut = jo.get_int("melee_cut"); m_to_hit = jo.get_int("m_to_hit"); item_tags = jo.get_tags("item_flags"); max_charges = jo.get_long("max_charges"); def_charges = jo.get_long("def_charges"); std::vector<int> rand_charges; JsonArray jarr = jo.get_array("rand_charges"); while (jarr.has_more()){ rand_charges.push_back(jarr.next_long()); } charges_per_use = jo.get_int("charges_per_use"); turns_per_charge = jo.get_int("turns_per_charge"); ammo = jo.get_string("ammo"); revert_to = jo.get_string("revert_to"); charge_type = (art_charge)jo.get_int("charge_type"); JsonArray ja = jo.get_array("effects_wielded"); while (ja.has_more()) { effects_wielded.push_back((art_effect_passive)ja.next_int()); } ja = jo.get_array("effects_activated"); while (ja.has_more()) { effects_activated.push_back((art_effect_active)ja.next_int()); } ja = jo.get_array("effects_carried"); while (ja.has_more()) { effects_carried.push_back((art_effect_passive)ja.next_int()); } }
float TCOD_color_get_saturation_ (colornum_t c) { return TCOD_color_get_saturation(int_to_color(c)); }
colornum_t TCOD_color_lerp_wrapper(colornum_t c1, colornum_t c2, float coef) { return color_to_int(TCOD_color_lerp (int_to_color(c1),int_to_color(c2), coef)); }
colornum_t TCOD_color_multiply_wrapper (colornum_t c1, colornum_t c2) { return color_to_int(TCOD_color_multiply (int_to_color(c1), int_to_color(c2))); }
colornum_t TCOD_color_add_wrapper (colornum_t c1, colornum_t c2) { return color_to_int(TCOD_color_add (int_to_color(c1), int_to_color(c2))); }
void TCOD_console_set_key_color_wrapper (TCOD_console_t con, colornum_t c) { TCOD_console_set_key_color(con, int_to_color(c)); }
void TCOD_image_put_pixel_wrapper(TCOD_image_t image,int x, int y, colornum_t col) { TCOD_image_put_pixel (image, x, y, int_to_color( col)); }
SDL_Color team::get_minimap_color(int side) { // Note: use mid() instead of rep() unless // high contrast is needed over a map or minimap! return int_to_color(get_side_color_range(side).rep()); }
SDL_Color team::get_side_color(int side) { return int_to_color(get_side_color_range(side).mid()); }
void game_display::draw_movement_info(const map_location& loc) { // Search if there is a mark here pathfind::marked_route::mark_map::iterator w = route_.marks.find(loc); boost::shared_ptr<wb::manager> wb = wb_.lock(); // Don't use empty route or the first step (the unit will be there) if(w != route_.marks.end() && !route_.steps.empty() && route_.steps.front() != loc) { const unit_map::const_iterator un = (wb && wb->get_temp_move_unit().valid()) ? wb->get_temp_move_unit() : dc_->units().find(route_.steps.front()); if(un != dc_->units().end()) { // Display the def% of this terrain int def = 100 - un->defense_modifier(get_map().get_terrain(loc)); std::stringstream def_text; def_text << def << "%"; SDL_Color color = int_to_color(game_config::red_to_green(def, false)); // simple mark (no turn point) use smaller font int def_font = w->second.turns > 0 ? 18 : 16; draw_text_in_hex(loc, LAYER_MOVE_INFO, def_text.str(), def_font, color); int xpos = get_location_x(loc); int ypos = get_location_y(loc); if (w->second.invisible) { drawing_buffer_add(LAYER_MOVE_INFO, loc, xpos, ypos, image::get_image("misc/hidden.png", image::SCALED_TO_HEX)); } if (w->second.zoc) { drawing_buffer_add(LAYER_MOVE_INFO, loc, xpos, ypos, image::get_image("misc/zoc.png", image::SCALED_TO_HEX)); } if (w->second.capture) { drawing_buffer_add(LAYER_MOVE_INFO, loc, xpos, ypos, image::get_image("misc/capture.png", image::SCALED_TO_HEX)); } //we display turn info only if different from a simple last "1" if (w->second.turns > 1 || (w->second.turns == 1 && loc != route_.steps.back())) { std::stringstream turns_text; turns_text << w->second.turns; draw_text_in_hex(loc, LAYER_MOVE_INFO, turns_text.str(), 17, font::NORMAL_COLOR, 0.5,0.8); } // The hex is full now, so skip the "show enemy moves" return; } } // When out-of-turn, it's still interesting to check out the terrain defs of the selected unit else if (selectedHex_.valid() && loc == mouseoverHex_) { const unit_map::const_iterator selectedUnit = resources::gameboard->find_visible_unit(selectedHex_,dc_->teams()[currentTeam_]); const unit_map::const_iterator mouseoveredUnit = resources::gameboard->find_visible_unit(mouseoverHex_,dc_->teams()[currentTeam_]); if(selectedUnit != dc_->units().end() && mouseoveredUnit == dc_->units().end()) { // Display the def% of this terrain int def = 100 - selectedUnit->defense_modifier(get_map().get_terrain(loc)); std::stringstream def_text; def_text << def << "%"; SDL_Color color = int_to_color(game_config::red_to_green(def, false)); // use small font int def_font = 16; draw_text_in_hex(loc, LAYER_MOVE_INFO, def_text.str(), def_font, color); } } if (!reach_map_.empty()) { reach_map::iterator reach = reach_map_.find(loc); if (reach != reach_map_.end() && reach->second > 1) { const std::string num = lexical_cast<std::string>(reach->second); draw_text_in_hex(loc, LAYER_MOVE_INFO, num, 16, font::YELLOW_COLOR); } } }
report generate_report(TYPE type, std::map<reports::TYPE, std::string> report_contents, const team ¤t_team, int current_side, int playing_side, const map_location& loc, const map_location& mouseover, const map_location& displayed_unit_hex, const std::set<std::string> &observers, const config& level, bool show_everything) { unit_map &units = *resources::units; gamemap &map = *resources::game_map; std::vector<team> &teams = *resources::teams; const unit *u = NULL; if((int(type) >= int(UNIT_REPORTS_BEGIN) && int(type) < int(UNIT_REPORTS_END)) || type == POSITION){ u = get_visible_unit(units, displayed_unit_hex, current_team, show_everything); if (!u && type != POSITION) { return report(); } } std::ostringstream str; switch(type) { case UNIT_NAME: str << "<b>" << u->name() << "</b>"; return report(str.str(), "", u->name()); case UNIT_TYPE: str << span_color(font::unit_type_color) << u->type_name() << naps; return report(str.str(), "", u->unit_description()); case UNIT_RACE: str << span_color(font::race_color) << u->race()->name(u->gender()) << naps; break; case UNIT_SIDE: { std::string flag_icon = teams[u->side() - 1].flag_icon(); std::string old_rgb = game_config::flag_rgb; std::string new_rgb = team::get_side_colour_index(u->side()); std::string mods = "~RC(" + old_rgb + ">" + new_rgb + ")"; if(flag_icon.empty()) { flag_icon = game_config::flag_icon_image; } image::locator flag_icon_img(flag_icon, mods); return report("", flag_icon_img, teams[u->side() - 1].current_player()); } case UNIT_LEVEL: str << u->level(); break; case UNIT_AMLA: { report res; const std::vector<std::pair<std::string,std::string> > &amla_icons=u->amla_icons(); for(std::vector<std::pair<std::string,std::string> >::const_iterator i=amla_icons.begin();i!=amla_icons.end();i++){ res.add_image(i->first,i->second); } return(res); } case UNIT_TRAITS: return report(u->traits_description(), "", u->modification_description("trait")); case UNIT_STATUS: { report res; if (map.on_board(displayed_unit_hex) && u->invisible(displayed_unit_hex, units, teams)) { add_status(res, "misc/invisible.png", N_("invisible: "), N_("This unit is invisible. It cannot be seen or attacked by enemy units.")); } if (u->get_state(unit::STATE_SLOWED)) { add_status(res, "misc/slowed.png", N_("slowed: "), N_("This unit has been slowed. It will only deal half its normal damage when attacking and its movement cost is doubled.")); } if (u->get_state(unit::STATE_POISONED)) { add_status(res, "misc/poisoned.png", N_("poisoned: "), N_("This unit is poisoned. It will lose 8 HP every turn until it can seek a cure to the poison in a village or from a friendly unit with the 'cures' ability.\n\nUnits cannot be killed by poison alone. The poison will not reduce it below 1 HP.")); } if (u->get_state(unit::STATE_PETRIFIED)) { add_status(res, "misc/petrified.png", N_("petrified: "), N_("This unit has been petrified. It may not move or attack.")); } return res; } case UNIT_ALIGNMENT: { const std::string &align = unit_type::alignment_description(u->alignment(), u->gender()); const std::string &align_id = unit_type::alignment_id(u->alignment()); std::stringstream ss; int cm = combat_modifier(units, displayed_unit_hex, u->alignment(), u->is_fearless()); ss << align << " (" << (cm >= 0 ? "+" : "−") << abs(cm) << "%)"; return report(ss.str(), "", string_table[align_id + "_description"]); } case UNIT_ABILITIES: { report res; const std::vector<std::string> &abilities = u->ability_tooltips(); for(std::vector<std::string>::const_iterator i = abilities.begin(); i != abilities.end(); ++i) { str << gettext(i->c_str()); if(i+2 != abilities.end()) str << ","; ++i; res.add_text(flush(str), *i); } return res; } case UNIT_HP: { std::ostringstream tooltip; str << span_color(u->hp_color()) << u->hitpoints() << '/' << u->max_hitpoints() << naps; std::set<std::string> resistances_table; string_map resistances = u->get_base_resistances(); bool att_def_diff = false; for(string_map::iterator resist = resistances.begin(); resist != resistances.end(); ++resist) { std::ostringstream line; line << gettext(resist->first.c_str()) << ": "; // Some units have different resistances when // attacking or defending. int res_att = 100 - u->resistance_against(resist->first, true, displayed_unit_hex); int res_def = 100 - u->resistance_against(resist->first, false, displayed_unit_hex); if (res_att == res_def) { line << res_def << "%\n"; } else { line << res_att << "% / " << res_def << "%\n"; att_def_diff = true; } resistances_table.insert(line.str()); } tooltip << _("Resistances: "); if (att_def_diff) tooltip << _("(Att / Def)"); tooltip << "\n"; // the STL set will give alphabetical sorting for(std::set<std::string>::iterator line = resistances_table.begin(); line != resistances_table.end(); ++line) { tooltip << (*line); } return report(str.str(), "", tooltip.str()); } case UNIT_XP: { std::ostringstream tooltip; str << span_color(u->xp_color()) << u->experience() << '/' << u->max_experience() << naps; tooltip << _("Experience Modifier: ") << ((level["experience_modifier"] != "") ? level["experience_modifier"] : "100") << "%"; return report(str.str(), "", tooltip.str()); } case UNIT_ADVANCEMENT_OPTIONS: { report res; const std::map<std::string,std::string> &adv_icons = u->advancement_icons(); for(std::map<std::string,std::string>::const_iterator i=adv_icons.begin();i!=adv_icons.end();i++){ res.add_image(i->first,i->second); } return res; } case UNIT_DEFENSE: { const t_translation::t_terrain terrain = map[displayed_unit_hex]; int def = 100 - u->defense_modifier(terrain); SDL_Color color = int_to_color(game_config::red_to_green(def)); str << span_color(color) << def << "%</span>"; break; } case UNIT_MOVES: { float movement_frac = 1.0; if (u->side() == playing_side) { movement_frac = static_cast<float>(u->movement_left()) / std::max(1.0f, static_cast<float>(u->total_movement())); if (movement_frac > 1.0) movement_frac = 1.0; } int grey = 128 + static_cast<int>((255-128) * movement_frac); SDL_Color c = { grey, grey, grey, 0 }; str << span_color(c) << u->movement_left() << '/' << u->total_movement() << naps; break; } case UNIT_WEAPONS: { report res; std::ostringstream tooltip; size_t team_index = u->side() - 1; if(team_index >= teams.size()) { std::cerr << "illegal team index in reporting: " << team_index << "\n"; return res; } foreach (const attack_type &at, u->attacks()) { at.set_specials_context(displayed_unit_hex, map_location(), *u); std::string lang_type = gettext(at.type().c_str()); str << span_color(font::weapon_color); if (u->get_state(unit::STATE_SLOWED)) { str << round_damage(at.damage(), 1, 2) << '-'; } else { str << at.damage() << '-'; } int nattacks = at.num_attacks(); // Compute swarm attacks: unit_ability_list swarm = at.get_specials("swarm"); if(!swarm.empty()) { int swarm_max_attacks = swarm.highest("swarm_attacks_max",nattacks).first; int swarm_min_attacks = swarm.highest("swarm_attacks_min").first; int hitp = u->hitpoints(); int mhitp = u->max_hitpoints(); nattacks = swarm_min_attacks + (swarm_max_attacks - swarm_min_attacks) * hitp / mhitp; } str << nattacks; str << ' ' << at.name() << ' ' << at.accuracy_parry_description(); tooltip << at.name() << "\n"; int effdmg; if (u->get_state(unit::STATE_SLOWED)) { effdmg = round_damage(at.damage(),1,2); } else { effdmg = at.damage(); } tooltip << effdmg << ' ' << _n("tooltip^damage", "damage", effdmg) << ", "; tooltip << nattacks << ' ' << _n("tooltip^attack", "attacks", nattacks); int accuracy = at.accuracy(); if(accuracy) { // Help xgettext with a directive to recognise the string as a non C printf-like string // xgettext:no-c-format tooltip << " " << (accuracy > 0 ? "+" : "") << accuracy << _("tooltip^% accuracy"); } int parry = at.parry(); if(parry) { // xgettext:no-c-format tooltip << " " << (parry > 0 ? "+" : "") << parry << _("tooltip^% parry"); } str << "</span>\n"; res.add_text(flush(str), flush(tooltip)); std::string range = gettext(at.range().c_str()); str << span_color(font::weapon_details_color) << " " << range << "--" << lang_type << "</span>\n"; tooltip << _("weapon range: ") << range <<"\n"; tooltip << _("damage type: ") << lang_type << "\n"; // Find all the unit types on the map, and // show this weapon's bonus against all the different units. // Don't show invisible units, except if they are in our team or allied. std::set<std::string> seen_units; std::map<int,std::vector<std::string> > resistances; for(unit_map::const_iterator u_it = units.begin(); u_it != units.end(); ++u_it) { if(teams[team_index].is_enemy(u_it->second.side()) && !current_team.fogged(u_it->first) && seen_units.count(u_it->second.type_id()) == 0 && ( !current_team.is_enemy(u_it->second.side()) || !u_it->second.invisible(u_it->first,units,teams))) { seen_units.insert(u_it->second.type_id()); int resistance = u_it->second.resistance_against(at, false, u_it->first) - 100; resistances[resistance].push_back(u_it->second.type_name()); } } for(std::map<int,std::vector<std::string> >::reverse_iterator resist = resistances.rbegin(); resist != resistances.rend(); ++resist) { std::sort(resist->second.begin(),resist->second.end()); tooltip << (resist->first >= 0 ? "+" : "") << resist->first << "% " << _("vs") << " "; for(std::vector<std::string>::const_iterator i = resist->second.begin(); i != resist->second.end(); ++i) { if(i != resist->second.begin()) { tooltip << ", "; } tooltip << *i; } tooltip << "\n"; } res.add_text(flush(str), flush(tooltip)); const std::vector<t_string> &specials = at.special_tooltips(); if(! specials.empty()) { for(std::vector<t_string>::const_iterator sp_it = specials.begin(); sp_it != specials.end(); ++sp_it) { str << span_color(font::weapon_details_color) << " " << *sp_it << "</span>\n"; ++sp_it; tooltip << *sp_it << '\n'; } res.add_text(flush(str), flush(tooltip)); } } return res; } case UNIT_IMAGE: { // const std::vector<Uint32>& old_rgb = u->second.team_rgb_range(); // color_range new_rgb = team::get_side_color_range(u->second.side()); return report("", image::locator(u->absolute_image(), u->image_mods()), ""); } case UNIT_PROFILE: return report("", u->profile(), ""); case TIME_OF_DAY: { time_of_day tod = resources::tod_manager->time_of_day_at(units, mouseover, *resources::game_map); const std::string tod_image = tod.image + (preferences::flip_time() ? "~FL(horiz)" : ""); // Don't show illuminated time on fogged/shrouded tiles if (current_team.fogged(mouseover) || current_team.shrouded(mouseover)) { tod = resources::tod_manager->get_time_of_day(false, mouseover); } std::stringstream tooltip; tooltip << tod.name << "\n" << _("Lawful units: ") << (tod.lawful_bonus > 0 ? "+" : "") << tod.lawful_bonus << "%\n" << _("Neutral units: ") << "0%\n" << _("Chaotic units: ") << (tod.lawful_bonus < 0 ? "+" : "") << (tod.lawful_bonus*-1) << "%"; return report("",tod_image,tooltip.str()); } case TURN: { str << resources::tod_manager->turn(); int nb = resources::tod_manager->number_of_turns(); if (nb != -1) str << '/' << nb; break; } // For the following status reports, show them in gray text // when it is not the active player's turn. case GOLD: { char const *end = naps; if (current_side != playing_side) str << span_color(font::GRAY_COLOUR); else if (current_team.gold() < 0) str << span_color(font::BAD_COLOUR); else end = ""; str << current_team.gold() << end; break; } case VILLAGES: { const team_data data = calculate_team_data(current_team,current_side,units); if (current_side != playing_side) str << span_color(font::GRAY_COLOUR); str << data.villages << '/'; if (current_team.uses_shroud()) { int unshrouded_villages = 0; std::vector<map_location>::const_iterator i = map.villages().begin(); for (; i != map.villages().end(); i++) { if (!current_team.shrouded(*i)) unshrouded_villages++; } str << unshrouded_villages; } else { str << map.villages().size(); } if (current_side != playing_side) str << naps; break; } case NUM_UNITS: { if (current_side != playing_side) str << span_color(font::GRAY_COLOUR); str << side_units(units, current_side); if (current_side != playing_side) str << naps; break; } case UPKEEP: { const team_data data = calculate_team_data(current_team,current_side,units); if (current_side != playing_side) str << span_color(font::GRAY_COLOUR); str << data.expenses << " (" << data.upkeep << ")"; if (current_side != playing_side) str << naps; break; } case EXPENSES: { const team_data data = calculate_team_data(current_team,current_side,units); if (current_side != playing_side) str << span_color(font::GRAY_COLOUR); str << data.expenses; if (current_side != playing_side) str << naps; break; } case INCOME: { team_data data = calculate_team_data(current_team, current_side, units); char const *end = naps; if (current_side != playing_side) str << span_color(font::GRAY_COLOUR); else if (data.net_income < 0) str << span_color(font::BAD_COLOUR); else end = ""; str << data.net_income << end; break; } case TERRAIN: { if(!map.on_board(mouseover) || current_team.shrouded(mouseover)) break; const t_translation::t_terrain terrain = map.get_terrain(mouseover); if (terrain == t_translation::OFF_MAP_USER) break; const t_translation::t_list& underlying = map.underlying_union_terrain(terrain); if(map.is_village(mouseover)) { int owner = village_owner(mouseover, teams) + 1; if(owner == 0 || current_team.fogged(mouseover)) { str << map.get_terrain_info(terrain).income_description(); } else if(owner == current_side) { str << map.get_terrain_info(terrain).income_description_own(); } else if(current_team.is_enemy(owner)) { str << map.get_terrain_info(terrain).income_description_enemy(); } else { str << map.get_terrain_info(terrain).income_description_ally(); } str << " "; } else { str << map.get_terrain_info(terrain).description(); } if(underlying.size() != 1 || underlying.front() != terrain) { str << " ("; for(t_translation::t_list::const_iterator i = underlying.begin(); i != underlying.end(); ++i) { str << map.get_terrain_info(*i).name(); if(i+1 != underlying.end()) { str << ","; } } str << ")"; } break; } case POSITION: { if(!map.on_board(mouseover)) { break; } const t_translation::t_terrain terrain = map[mouseover]; if (terrain == t_translation::OFF_MAP_USER) break; str << mouseover; if (!u) break; if(displayed_unit_hex != mouseover && displayed_unit_hex != loc) break; if(current_team.shrouded(mouseover)) break; int move_cost = u->movement_cost(terrain); int defense = 100 - u->defense_modifier(terrain); if(move_cost < unit_movement_type::UNREACHABLE) { str << " (" << defense << "%," << move_cost << ")"; } else if (mouseover == displayed_unit_hex) { str << " (" << defense << "%,-)"; } else { str << " (-)"; } break; } case SIDE_PLAYING: { std::string flag_icon = teams[playing_side-1].flag_icon(); std::string old_rgb = game_config::flag_rgb; std::string new_rgb = team::get_side_colour_index(playing_side); std::string mods = "~RC(" + old_rgb + ">" + new_rgb + ")"; if(flag_icon.empty()) { flag_icon = game_config::flag_icon_image; } image::locator flag_icon_img(flag_icon, mods); return report("",flag_icon_img,teams[playing_side-1].current_player()); } case OBSERVERS: { if(observers.empty()) { return report(); } str << _("Observers:") << "\n"; for(std::set<std::string>::const_iterator i = observers.begin(); i != observers.end(); ++i) { str << *i << "\n"; } return report("",game_config::observer_image,str.str()); } case SELECTED_TERRAIN: { std::map<TYPE, std::string>::const_iterator it = report_contents.find(SELECTED_TERRAIN); if (it != report_contents.end()) { return report(it->second); } else { return report(); } } case EDIT_LEFT_BUTTON_FUNCTION: { std::map<TYPE, std::string>::const_iterator it = report_contents.find(EDIT_LEFT_BUTTON_FUNCTION); if (it != report_contents.end()) { return report(it->second); } else { return report(); } } case REPORT_COUNTDOWN: { int min; int sec; if (current_team.countdown_time() > 0){ sec = current_team.countdown_time() / 1000; char const *end = naps; if (current_side != playing_side) str << span_color(font::GRAY_COLOUR); else if (sec < 60) str << "<span foreground=\"#c80000\">"; else if (sec < 120) str << "<span foreground=\"#c8c800\">"; else end = ""; min = sec / 60; str << min << ":"; sec = sec % 60; if (sec < 10) { str << "0"; } str << sec << end; break; } // Intentional fall-through to REPORT_CLOCK // if the time countdown isn't valid. // If there is no turn time limit, // then we display the clock instead. } case REPORT_CLOCK: { time_t t = std::time(NULL); struct tm *lt = std::localtime(&t); if (lt) { char temp[10]; size_t s = std::strftime(temp, 10, preferences::clock_format().c_str(), lt); if(s>0) { return report(temp); } else { return report(); } } else { return report(); } } default: assert(false); break; } return report(str.str()); }
robot_finds_kitten::robot_finds_kitten(WINDOW *w) { ret = false; char ktile[83] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#&()*+./:;=?![]{|}y"; int used_messages[MAXMESSAGES]; rfkLINES = 20; rfkCOLS = 60; const int numbogus = 20; const int maxcolor = 15; nummessages = 201; empty.x = -1; empty.y = -1; empty.color = (nc_color)0; empty.character = ' '; for (int c = 0; c < rfkCOLS; c++) { for (int c2 = 0; c2 < rfkLINES; c2++) { rfkscreen[c][c2] = EMPTY; } } /* Create an array to ensure we don't get duplicate messages. */ for (int c = 0; c < nummessages; c++) { used_messages[c] = 0; bogus_messages[c] = 0; bogus[c] = empty; } /* Now we initialize the various game OBJECTs. * Assign a position to the player. */ robot.x = rand() % rfkCOLS; robot.y = rand() % (rfkLINES - 3) + 3; robot.character = '#'; robot.color = int_to_color(1); rfkscreen[robot.x][robot.y] = ROBOT; /* Assign the kitten a unique position. */ do { kitten.x = rand() % rfkCOLS; kitten.y = rand() % (rfkLINES - 3) + 3; } while (rfkscreen[kitten.x][kitten.y] != EMPTY); /* Assign the kitten a character and a color. */ do { kitten.character = ktile[rand() % 82]; } while (kitten.character == '#' || kitten.character == ' '); kitten.color = int_to_color( ( rand() % (maxcolor - 2) ) + 2); rfkscreen[kitten.x][kitten.y] = KITTEN; /* Now, initialize non-kitten OBJECTs. */ for (int c = 0; c < numbogus; c++) { /* Assign a unique position. */ do { bogus[c].x = rand() % rfkCOLS; bogus[c].y = (rand() % (rfkLINES - 3)) + 3; } while (rfkscreen[bogus[c].x][bogus[c].y] != EMPTY); rfkscreen[bogus[c].x][bogus[c].y] = c + 2; /* Assign a character. */ do { bogus[c].character = ktile[rand() % 82]; } while (bogus[c].character == '#' || bogus[c].character == ' '); bogus[c].color = int_to_color((rand() % (maxcolor - 2)) + 2); /* Assign a unique message. */ int index = 0; do { index = rand() % nummessages; } while (used_messages[index] != 0); bogus_messages[c] = index; used_messages[index] = 1; } instructions(w); werase(w); mvwprintz (w, 0, 0, c_white, "robotfindskitten v22July2008"); for (int c = 0; c < rfkCOLS; c++) { mvwputch (w, 2, c, c_white, '_'); } wmove(w, kitten.y, kitten.x); draw_kitten(w); for (int c = 0; c < numbogus; c++) { mvwputch(w, bogus[c].y, bogus[c].x, bogus[c].color, bogus[c].character); } wmove(w, robot.y, robot.x); draw_robot(w); int old_x = robot.x; int old_y = robot.y; wrefresh(w); /* Now the fun begins. */ int input = '.'; input = getch(); while (input != 'q') { process_input(input, w); if(ret == true) { break; } /* Redraw robot, where avaliable */ if (!(old_x == robot.x && old_y == robot.y)) { wmove(w, old_y, old_x); wputch(w, c_white, ' '); wmove(w, robot.y, robot.x); draw_robot(w); rfkscreen[old_x][old_y] = EMPTY; rfkscreen[robot.x][robot.y] = ROBOT; old_x = robot.x; old_y = robot.y; wrefresh(w); } input = getch(); } }
void TCOD_image_clear_wrapper(TCOD_image_t image, colornum_t color) { TCOD_image_clear (image, int_to_color(color)); }
static void set_weapon_info(twindow& window, const std::vector<battle_context>& weapons, const int best_weapon) { tlistbox& weapon_list = find_widget<tlistbox>(&window, "weapon_list", false); window.keyboard_capture(&weapon_list); const config empty; const attack_type no_weapon(empty); FOREACH(const AUTO & weapon, weapons) { const battle_context_unit_stats& attacker = weapon.get_attacker_stats(); const battle_context_unit_stats& defender = weapon.get_defender_stats(); const attack_type& attacker_weapon = *attacker.weapon; const attack_type& defender_weapon = defender.weapon ? *defender.weapon : no_weapon; const SDL_Color a_cth_color = int_to_color(game_config::red_to_green(attacker.chance_to_hit)); const SDL_Color d_cth_color = int_to_color(game_config::red_to_green(defender.chance_to_hit)); const std::string& attw_name = !attacker_weapon.name().empty() ? attacker_weapon.name() : " "; const std::string& defw_name = !defender_weapon.name().empty() ? defender_weapon.name() : " "; std::string range = attacker_weapon.range().empty() ? defender_weapon.range() : attacker_weapon.range(); if (!range.empty()) { range = string_table["range_" + range]; } const std::string& attw_apecials = !attacker_weapon.weapon_specials().empty() ? " " + attacker_weapon.weapon_specials() : ""; const std::string& defw_specials = !defender_weapon.weapon_specials().empty() ? " " + defender_weapon.weapon_specials() : ""; std::stringstream attacker_stats, defender_stats; attacker_stats << "<b>" << attw_name << "</b>" << "\n" << attacker.damage << font::weapon_numbers_sep << attacker_weapon.num_attacks() << attw_apecials << "\n" << font::span_color(a_cth_color) << attacker.chance_to_hit << "%</span>" << "\n"; defender_stats << "<b>" << defw_name << "</b>" << "\n" << defender.damage << font::weapon_numbers_sep << defender_weapon.num_attacks() << defw_specials << "\n" << font::span_color(d_cth_color) << defender.chance_to_hit << "%</span>" << "\n"; std::map<std::string, string_map> data; string_map item; item["label"] = attacker_weapon.icon(); data.insert(std::make_pair("attacker_weapon_icon", item)); item["label"] = attacker_stats.str(); item["use_markup"] = "true"; data.insert(std::make_pair("attacker_weapon", item)); item["label"] = "<span color='#a69275'>" + utils::unicode_em_dash + " " + range + " " + utils::unicode_em_dash + "</span>"; item["use_markup"] = "true"; data.insert(std::make_pair("range", item)); item["label"] = defender_stats.str(); item["use_markup"] = "true"; data.insert(std::make_pair("defender_weapon", item)); item["label"] = defender_weapon.icon(); data.insert(std::make_pair("defender_weapon_icon", item)); weapon_list.add_row(data); } assert(best_weapon < static_cast<int>(weapon_list.get_item_count())); weapon_list.select_row(best_weapon); }
void TCOD_image_set_key_color_wrapper(TCOD_image_t image, colornum_t key_color) { TCOD_image_set_key_color (image, int_to_color(key_color)); }
void TCOD_console_set_default_foreground_wrapper(TCOD_console_t con, colornum_t col) { TCOD_console_set_default_foreground (con, int_to_color(col)); }
bool TCOD_color_equals_wrapper (colornum_t c1, colornum_t c2) { return TCOD_color_equals (int_to_color(c1), int_to_color(c2)); }
void TCOD_console_set_char_background_wrapper(TCOD_console_t con,int x, int y, colornum_t col, TCOD_bkgnd_flag_t flag) { TCOD_console_set_char_background (con, x, y, int_to_color(col), flag); }
colornum_t TCOD_color_subtract_wrapper (colornum_t c1, colornum_t c2) { return color_to_int(TCOD_color_subtract (int_to_color(c1), int_to_color(c2))); }
void TCOD_console_set_char_foreground_wrapper(TCOD_console_t con,int x, int y, colornum_t col) { TCOD_console_set_char_foreground (con, x, y, int_to_color(col)); }
colornum_t TCOD_color_multiply_scalar_wrapper (colornum_t c1, float value) { return color_to_int(TCOD_color_multiply_scalar (int_to_color(c1), value)); }
void TCOD_console_put_char_ex_wrapper(TCOD_console_t con, int x, int y, int c, colornum_t fore, colornum_t back) { TCOD_console_put_char_ex (con, x, y, c, int_to_color(fore), int_to_color(back)); }
void TCOD_color_get_HSV_wrapper(colornum_t c,float * h, float * s, float * v) { TCOD_color_get_HSV (int_to_color(c), h, s, v); }
void TCOD_console_set_fade_wrapper(uint8 val, colornum_t fade) { TCOD_console_set_fade (val, int_to_color(fade)); }
float TCOD_color_get_value_ (colornum_t c) { return TCOD_color_get_value(int_to_color(c)); }
void it_artifact_tool::deserialize(JsonObject &jo) { id = jo.get_string("id"); name = jo.get_string("name"); description = jo.get_string("description"); sym = jo.get_int("sym"); color = int_to_color(jo.get_int("color")); price = jo.get_int("price"); // LEGACY: Since it seems artifacts get serialized out to disk, and they're // dynamic, we need to allow for them to be read from disk for, oh, I guess // quite some time. Loading and saving once will write things out as a JSON // array. if (jo.has_string("m1")) { materials.push_back(jo.get_string("m1")); } if (jo.has_string("m2")) { materials.push_back(jo.get_string("m2")); } // Assumption, perhaps dangerous, that we won't wind up with m1 and m2 and // a materials array in our serialized objects at the same time. if (jo.has_array("materials")) { JsonArray jarr = jo.get_array("materials"); for (int i = 0; i < jarr.size(); ++i) { materials.push_back(jarr.get_string(i)); } } volume = jo.get_int("volume"); weight = jo.get_int("weight"); melee_dam = jo.get_int("melee_dam"); melee_cut = jo.get_int("melee_cut"); m_to_hit = jo.get_int("m_to_hit"); item_tags = jo.get_tags("item_flags"); max_charges = jo.get_long("max_charges"); def_charges = jo.get_long("def_charges"); std::vector<int> rand_charges; JsonArray jarr = jo.get_array("rand_charges"); while (jarr.has_more()) { rand_charges.push_back(jarr.next_long()); } charges_per_use = jo.get_int("charges_per_use"); turns_per_charge = jo.get_int("turns_per_charge"); ammo = jo.get_string("ammo"); revert_to = jo.get_string("revert_to"); charge_type = (art_charge)jo.get_int("charge_type"); JsonArray ja = jo.get_array("effects_wielded"); while (ja.has_more()) { effects_wielded.push_back((art_effect_passive)ja.next_int()); } ja = jo.get_array("effects_activated"); while (ja.has_more()) { effects_activated.push_back((art_effect_active)ja.next_int()); } ja = jo.get_array("effects_carried"); while (ja.has_more()) { effects_carried.push_back((art_effect_passive)ja.next_int()); } if( item_tags.count( "CHOP" ) > 0 ) { item_tags.insert( "SHEATH_SWORD" ); } if( item_tags.count( "STAB" ) > 0 ) { item_tags.insert( "SHEATH_KNIFE" ); } }