| C__GLXEvent | |
| C_GPU_DEVICE | |
| C_rect | |
| Chelp::about_text_formatter | Class to be used as a function object when generating the about text |
| ►Cabstract_validator | Used in parsing config file |
| Cschema_validation::schema_validator | Realization of serialization/validator.hpp abstract validator |
| Cpreferences::acquaintance | |
| ►Cai::action_result | |
| Cai::attack_result | |
| Cai::move_result | |
| Cai::recall_result | |
| Cai::recruit_result | |
| Cai::stopunit_result | |
| Cai::synced_command_result | |
| Cai::actions | |
| Caddon_info | |
| Caddon_source | |
| Caddon_tracking_info | Stores additional status information about add-ons |
| Cmp_game_settings::addon_version_info | |
| Cpreferences::admin_authentication_reset | Used to reset is_authenticated flag after disconnecting |
| Cadvance_unit_params | Advances the unit at loc if it has enough experience, maximum 20 times |
| Cai_testing | |
| Cconfig::all_children_iterator | |
| Cvconfig::all_children_iterator | |
| Cunit_animator::anim_elem | |
| Canimated< T, T_void_value > | |
| Canimated< image::locator > | |
| ►Canimated< unit_frame > | |
| Cunit_animation::particule | |
| Canimation_branch | |
| Canimation_cursor | |
| Cconfig::any_child | |
| Cdetail::apply< Ret, T > | |
| Ctod_manager::area_time_of_day | |
| Cplugins_context::aReg | |
| Cconfig::all_children_iterator::arrow_helper | |
| Cai::aspect_attacks_lua_filter | |
| ►Cai::aspect_factory | |
| Cai::register_aspect_factory< ASPECT > | |
| Cai::aspect_type< T > | |
| Cai::aspect_type< ai::unit_advancements_aspect > | |
| Cai::aspect_type< attacks_vector > | |
| Cai::aspect_type< bool > | |
| Cai::aspect_type< config > | |
| Cai::aspect_type< double > | |
| Cai::aspect_type< int > | |
| Cai::aspect_type< std::string > | |
| Cai::aspect_type< std::vector< std::string > > | |
| Cai::aspect_type< terrain_filter > | |
| Cthreading::async_operation | |
| Cstatistics::attack_context | |
| Cai::default_recruitment::attack_simulation | For Combat Analysis |
| Cattack_type | |
| Cconfig::attribute_value | Variant for storing WML attributes |
| Cauto_resetter< T > | |
| Cstoryscreen::background_layer | |
| Cwesnothd::ban_manager | |
| Cnetwork::bandwidth_in | |
| Cnetwork::bandwidth_stats | |
| Cnetwork::bandwidth_stats_output | |
| Cwesnothd::banned | |
| Cwesnothd::banned_compare | We want to move the lowest value to the top |
| Cwesnothd::banned_compare_subnet | |
| Cbar | |
| ►Cgame_logic::base_breakpoint | |
| Cgame_logic::end_breakpoint | |
| Cgame_logic::next_breakpoint | |
| Cgame_logic::step_in_breakpoint | |
| Cgame_logic::step_out_breakpoint | |
| ►Cgame_logic::base_candidate_action | |
| ►Cgame_logic::candidate_action_with_filters | |
| Cgame_logic::attack_candidate_action | |
| Cgame_logic::move_candidate_action | |
| Cpreferences::base_manager | |
| ►Cai::base_property_handler | |
| Cai::aspect_property_handler< T > | |
| ►Cai::vector_property_handler< T > | |
| Cai::facets_property_handler< T > | |
| Cbattle_context | Computes the statistics of a battle between an attacker and a defender unit |
| Cbattle_context_unit_stats | Structure describing the statistics of a unit involved in the battle |
| Cgui::menu::imgsel_style::bg_cache | |
| Cfilesystem::binary_paths_manager | The paths manager is responsible for recording the various paths that binary files may be located at |
| Cblindfold | |
| CBlockCnt | |
| ►Cbool_ | |
| ►Clua_check_impl::is_container< T > | |
| Clua_check_impl::is_container< T & > | |
| ►Clua_check_impl::is_map< T > | |
| Clua_check_impl::is_map< T & > | |
| Clua_check_impl::is_container< T, Enable > | |
| Clua_check_impl::is_map< T, Enable > | |
| Clua_check_impl::is_pair< T, Enable > | |
| Ceditor::brush | Single brush – a set of relative locations around a "hotspot", and related info such as the icon image |
| Cbuffered_istream | Helper class for buffering a std::istream |
| Cterrain_builder::building_rule | The in-memory representation of a [terrain_graphics] WML rule |
| Cwb::side_actions_container::by_hex | Tag for action_set's hashed_non_unique index |
| Cwb::side_actions_container::by_unit | Tag for action_set's hashed_non_unique index |
| Ccache_item< T > | |
| Cimage::cache_type< T > | |
| Cai::default_recruitment::cached_combat_value | |
| Cgui2::tgenerator< minimum_selection, maximum_selection, placement, select_action >::calculate_order_helper | |
| Ccall_stack_manager | |
| CCallInfo | |
| CCallS | |
| Ccampaign_controller | |
| ►Cai::candidate_action_factory | |
| Cai::register_candidate_action_factory< CANDIDATE_ACTION > | |
| Ccarryover | |
| Ccarryover_info | |
| Ccave_map_generator::cave_map_generator_job | |
| CCClosure | |
| Ccfg_to_loc | |
| Ccave_map_generator::cave_map_generator_job::chamber | |
| Cchar_block_map | |
| Cmp::chat | This class memorizes a chat session |
| ►Cevents::chat_handler | |
| Cevents::menu_handler | |
| Cgui2::tlobby_main | |
| ►Cmp::ui | Base class for the different multiplayer base dialogs: game list, create game, wait game, game setup |
| Cmp::configure | |
| Cmp::connect | |
| Cmp::create | |
| Cmp::lobby | |
| Cmp::wait | |
| Cchat_log | This class memorizes a chat session |
| Cdisplay_chat_manager::chat_message | |
| Cchat_message | This class represents a single stored chat message |
| Cchat_msg | |
| Cgui::check_item | |
| ►Ccheckup | A class to check whether the results that were calculated in the replay match the results calculated during the original game |
| Cignored_checkup | |
| Cmp_debug_checkup | This checkup always compares the results in from different clients in a mp game but it also causes more network overhead |
| Csynced_checkup | This checkup compares whether the results calculated during the original game match the ones calculated during replay |
| Cconfig::child_iterator | |
| Cconfig::child_pos | |
| Cwb::side_actions_container::chronological | Tag for action_set's random_access index |
| Csound::chunk_load_exception | |
| CCKey | Class that keeps track of all the keys on the keyboard |
| Cschema_validation::class_error_container | Container of errors, which are generated while schema generator tool is parsing source files |
| Cschema_validation::class_key | Class_key is used to save the information about one key |
| Cschema_validation::class_source_parser | |
| Cschema_validation::class_tag | Stores information about tag |
| Cactions::clearer_info | Class that stores the part of a unit's data that is needed for fog clearing |
| Cclip_rect_setter | |
| Cutil::close_FILE | This class specializes the scoped_resource to implement scoped FILEs |
| CClosure | |
| Cevents::cmd_arg_parser | |
| Cimage::color_adjustment_resetter | |
| Ccolor_range | A color range definition is made of four reference RGB colors, used for calculating conversions from a source/key palette |
| Ccombatant::combat_slice | A struct to describe one possible combat scenario |
| Ccombatant | All combat-related info |
| Cevents::map_command_handler< Worker >::command | |
| Cevents::command_disabler | |
| ►Chotkey::command_executor | |
| Chelp::help_button | |
| ►Chotkey::command_executor_default | |
| Ceditor::editor_controller | Mouse and keyboard event handling routines for the editor |
| ►Cplay_controller::hotkey_handler | |
| ►Cplaysingle_controller::hotkey_handler | |
| Cplaymp_controller::hotkey_handler | |
| Cai::command_history_item | AI Command History Item |
| Clua_kernel_base::command_log | |
| Ccommandline_options | |
| Ccompare_samples_by_time | |
| Ccompare_samples_to_stringspan | |
| ►Cai::component | |
| Cai::ai_composite | |
| ►Cai::aspect | |
| ►Cai::typesafe_aspect< T > | |
| Cai::composite_aspect< T > | |
| Cai::lua_aspect< T > | |
| Cai::standard_aspect< T > | |
| ►Cai::typesafe_aspect< attacks_vector > | |
| ►Cai::ai_default_rca::aspect_attacks_base | |
| Cai::ai_default_rca::aspect_attacks | |
| Cai::aspect_attacks_lua | |
| ►Cai::typesafe_aspect< config > | |
| ►Cai::standard_aspect< config > | |
| Cai::default_recruitment::recruitment_aspect | |
| ►Cai::candidate_action | |
| Cai::ai_default_rca::combat_phase | |
| Cai::ai_default_rca::get_healing_phase | |
| Cai::ai_default_rca::get_villages_phase | |
| Cai::ai_default_rca::goto_phase | |
| Cai::ai_default_rca::leader_control_phase | |
| Cai::ai_default_rca::leader_shares_keep_phase | |
| Cai::ai_default_rca::move_leader_to_goals_phase | |
| Cai::ai_default_rca::move_leader_to_keep_phase | |
| Cai::ai_default_rca::move_to_targets_phase | |
| Cai::ai_default_rca::retreat_phase | |
| Cai::default_recruitment::recruitment | |
| Cai::fai_candidate_action_wrapper | |
| ►Cai::lua_candidate_action_wrapper_base | |
| ►Cai::lua_candidate_action_wrapper | |
| Cai::lua_sticky_candidate_action_wrapper | |
| Cai::lua_candidate_action_wrapper_external | |
| Cai::default_recruitment::recruit_job | |
| Cai::default_recruitment::recruit_limit | |
| ►Cai::engine | |
| Cai::engine_cpp | |
| Cai::engine_fai | |
| Cai::engine_lua | |
| ►Cai::goal | |
| Cai::lua_goal | |
| ►Cai::protect_goal | |
| Cai::protect_location_goal | |
| Cai::protect_unit_goal | |
| Cai::target_location_goal | |
| Cai::target_unit_goal | |
| ►Cai::stage | |
| Cai::ai_default_rca::candidate_action_evaluation_loop | |
| Cai::idle_stage | |
| Cai::lua_stage_wrapper | |
| Cai::stage_side_formulas | |
| Cai::stage_unit_formulas | |
| Cai::component_manager | |
| Ccomposer | |
| Cconfig | A config object defines a single node in a WML file, with access to child nodes |
| Cconfig_cache_fixture | |
| Cconfig_of | |
| Cai::config_value_translator< T > | |
| Cai::config_value_translator< bool > | |
| Cai::config_value_translator< config > | |
| Cai::config_value_translator< std::vector< std::string > > | |
| Cai::config_value_translator< terrain_filter > | |
| Cai::config_value_translator< unit_advancements_aspect > | |
| Cconfig_writer | Class for writing a config out to a file in pieces |
| Cconfigr_of | |
| Cai::configuration | |
| Cng::configure_engine | Configure_engine |
| ►Cng::connect_engine | |
| Ctest_connect_engine | |
| Cnetwork_asio::connection | A class that represents a TCP/IP connection |
| ►Cgui2::tnetwork_transmission::connection_data | |
| Cdialogs::connect_wesnothd_connection_data | |
| Cdialogs::read_wesnothd_connection_data | |
| Cread_addon_connection_data | |
| Cwrite_addon_connection_data | |
| Cwesnothd::server::connection_log | |
| Cnetwork::connection_stats | |
| CConsControl | |
| Cconfig::const_attribute_iterator | |
| Cconfig::const_child_iterator | |
| Cunit_map::const_iter_types | |
| Cutil::const_iterator_extend< Value, Container, Deref, Key > | This is a const_iterator class that extends an existing const_iterator by overriding dereference |
| Cconst_surface_lock | |
| Cutil::detail::contains_impl< Container, Value > | A struct that exists to implement a generic wrapper for std::find |
| Cutil::detail::contains_impl< Container, typename Container::key_type > | A struct that exists to implement a generic wrapper for the find() member of associative containers |
| Cevents::context | |
| Creports::context | |
| Ceditor::context_manager | |
| CContextData_GLES_1 | |
| CContextData_GLES_2 | |
| CContextData_OpenGL_1 | |
| CContextData_OpenGL_1_BASE | |
| CContextData_OpenGL_2 | |
| CContextData_OpenGL_3 | |
| Ccampaignd::control_line | Represents a server control line written to a communication socket |
| Cstoryscreen::controller | |
| Cgui2::tchat_log::controller | |
| Cgui2::tgamestate_inspector::controller | |
| Cgui2::tlua_interpreter::controller | The controller is responsible to hold all the input widgets, and a pointer to the model and view |
| Cgui2::tmp_change_control::controller | The controller acts upon the model |
| Cucs4_convert_impl::convert_impl< T_CHAR > | |
| Cucs4_convert_impl::convert_impl< ucs4::char_t > | |
| Cucs4_convert_impl::convert_impl< utf16::char_t > | |
| Cucs4_convert_impl::convert_impl< utf8::char_t > | |
| Ct_translation::coordinate | Contains an x and y coordinate used for starting positions in maps |
| ►Cpathfind::cost_calculator | |
| Cai::ai_default_rca::move_cost_calculator | |
| Clua_pathfind_cost_calculator | Cost function object relying on a Lua function |
| Cpassage_path_calculator | |
| Cpathfind::dummy_path_calculator | Function which doesn't take anything into account |
| Cpathfind::emergency_path_calculator | Function which only uses terrain, ignoring shroud, enemies, etc |
| Cpathfind::move_type_path_calculator | |
| Cpathfind::shortest_path_calculator | |
| Cschema_validation::schema_validator::counter | |
| Cng::create_engine | |
| Csavegame::create_save_info | |
| Chelp::create_section | |
| Ccutter | |
| Cai::default_recruitment::data | |
| Cmovetype::terrain_info::data | |
| Cwesnothd::handle_doc< Handler, ErrorHandler >::DataSize | |
| Cgame_logic::debug_info | |
| Cfont::decode_table | |
| Cdefault_map_generator_job | |
| Cai::defensive_position | |
| Cutil::delete_array | A helper policy for scoped_array |
| Cutil::delete_item | A helper policy for scoped_ptr |
| Chelp::delete_section | |
| Cai::ai_default_rca::desc_sorter_of_candidate_actions | |
| Cai::description | AI parameters |
| Cdialogs::unit_preview_pane::details | |
| ►Cgui::dialog | |
| Cdialogs::file_dialog | |
| Cstatistics_dialog | |
| ►Cgui::dialog_button_action | |
| Cattack_prediction_displayer | |
| Cgui::dialog_button_info | |
| Cgui::dialog_process_info | |
| Cgui::dialog_frame::dimension_measurements | |
| Cgui::dialog::dimension_measurements | |
| ►CDirectoryReader | |
| CPluginInstance::JSDirectoryReader | |
| Cdisplay_chat_manager | |
| ►Cdisplay_context | |
| Ceditor::dummy_editor_display_context | |
| Ceditor::map_context | This class wraps around a map to provide a concise interface for the editor to work with |
| Cgame_board | Game board class |
| Cpathfind::ignore_units_display_context | |
| Csimple_wml::document | |
| Cdisplay::drawing_buffer_key | In order to render a hex properly it needs to be rendered per row |
| CDumpState | |
| CDyndata | |
| ►Ceditor::editor_action | Base class for all editor actions |
| Ceditor::editor_action_apply_mask | |
| Ceditor::editor_action_chain | Container action wrapping several actions into one |
| Ceditor::editor_action_create_mask | |
| ►Ceditor::editor_action_extendable | Base class for actions that: 1) operate on an area 2) can be used as undo for a click-drag operation 3) can be extended so one undo action undos several actual drag actions |
| ►Ceditor::editor_action_area | Base class for area-affecting actions |
| Ceditor::editor_action_deselect | Deselect the given locations |
| Ceditor::editor_action_paint_area | Paint the same terrain on a number of locations on the map |
| Ceditor::editor_action_select | Select the given locations |
| Ceditor::editor_action_shuffle_area | Randomize terrain in an area |
| Ceditor::editor_action_paste | Paste a map fragment into the map |
| ►Ceditor::editor_action_location | Base class for actions which act on a specified location (and possibly on other locations that can be derived from the staring hex) |
| Ceditor::editor_action_item | Place a new item on the map |
| Ceditor::editor_action_item_delete | Remove a item from the map |
| Ceditor::editor_action_item_facing | |
| Ceditor::editor_action_item_replace | |
| Ceditor::editor_action_label | Set label action |
| Ceditor::editor_action_label_delete | |
| ►Ceditor::editor_action_location_terrain | Base class for actions which in addition to acting on a hex, act with one terrain type, i.e |
| Ceditor::editor_action_fill | Flood fill |
| Ceditor::editor_action_starting_position | Set starting position action |
| Ceditor::editor_action_unit | Place a new unit on the map |
| Ceditor::editor_action_unit_delete | Remove a unit from the map |
| Ceditor::editor_action_unit_facing | |
| Ceditor::editor_action_unit_replace | |
| Ceditor::editor_action_village | Sets the ownership of a village to the current side |
| Ceditor::editor_action_village_delete | Clears the ownership of a village |
| Ceditor::editor_action_resize_map | Resize the map |
| Ceditor::editor_action_select_all | Select the entire map |
| Ceditor::editor_action_select_inverse | Invert the selection |
| Ceditor::editor_action_select_none | Clear selection |
| Ceditor::editor_action_whole_map | Replace contents of the entire map, Useful as a fallback undo method when something else would be impractical |
| Ceditor::editor_toolkit | |
| Chalo::halo_impl::effect | |
| Cunit_abilities::effect | |
| ►Cvariable_info_detail::enable_if_non_const< vit > | |
| Cnon_const_variable_info< vit > | Extends variable_info with methods that can only be applied if vit != vit_const |
| Cvariable_info_detail::enable_if_non_const< vit_const > | |
| ►Cenable_shared_from_this | |
| ►Cwb::action | Abstract base class for all the whiteboard planned actions |
| Cdummy_action | |
| ►Cwb::move | A planned move, represented on the map by an arrow and a ghosted unit in the destination hex |
| Cwb::attack | |
| Cwb::recall | |
| Cwb::recruit | |
| Cwb::suppose_dead | A planned action that temporarily removes a unit from the map for planning purposes |
| Cwb::side_actions | This internal whiteboard class holds the planned action queues for a team, and offers many utility methods to create and manipulate them |
| Cucs4_convert_impl::enableif< Tret, Tcheck > | |
| Cend_level_data | Additional information on the game outcome which can be provided by WML |
| ►Cai::engine_factory | |
| Cai::register_engine_factory< ENGINE > | |
| Cenum_tag | |
| ►Cerror | |
| Cbad_commandline_resolution | |
| Cbad_commandline_tuple | |
| Cschema_validation::class_error_container::error_cache_element | Container to cache type errors |
| Cplugins_manager::event | |
| Cevents::event_context | |
| Cgame_events::event_handler | |
| ►Cexception | |
| ►Cconfig::error | |
| Cvconfig::recursion_error | |
| ►Cstd::exception | STL class |
| Cbad_enum_cast | |
| Cbad_lexical_cast | Thrown when a lexical_cast fails |
| Cbad_lexical_cast | Thrown when a lexical_cast fails |
| ►Cgame::error | Base class for all the errors encountered by the engine |
| Cabstract_validator::error | Used to manage with not initialized validators Supposed to be thrown from the constructor |
| Cconfig::error | |
| CCVideo::error | |
| ►Ceditor::editor_exception | |
| Ceditor::editor_action_exception | |
| Ceditor::editor_logic_exception | |
| Ceditor::editor_map_integrity_error | |
| Ceditor::editor_map_load_exception | |
| Ceditor::editor_map_operation_exception | |
| Ceditor::editor_map_save_exception | |
| Cfilesystem::io_exception | An exception object used when an IO error occurs |
| Cfont::manager::error | |
| ►Cgame::game_error | Error used for any general game error, e.g |
| Cunit_type::error | |
| Cgame::load_game_failed | Error used when game loading fails |
| Cgame::lua_error | Error used to report an error in a lua script or in the lua interpreter |
| Cgame::mp_server_error | |
| Cgame::save_game_failed | Error used when game saving fails |
| Cgame_logic::formula_error | |
| Cgui::button::error | |
| Cgui::tristate_button::error | |
| Chelp::parse_error | Thrown when the help system fails to parse something |
| Cincorrect_map_format_error | |
| Cmapgen_exception | |
| Cmp::lobby_reload_request_exception | |
| Cnetwork::error | |
| Cnetwork_asio::error | |
| Cpreproc_config::error | |
| Csdl::texception | |
| Csimple_wml::error | |
| Ct_translation::error | |
| Ctype_error | |
| Cuser_handler::error | |
| Cwb::action::ctor_err | |
| Cwesnothd::banned::error | |
| ►Cwesnothd_error | An error occured during when trying to coommunicate with the wesnothd server |
| Cingame_wesnothd_error | We received invalid data from wesnothd during a game This means we cannot continue with the game but we can stay connected to wesnothd and start a new game TODO: find a short name |
| Cwesnothd_connection_error | Error occured inside the underlying network comminication code (boost asio) TODO: find a short name |
| Cinvalid_variablename_exception | Information on a WML variable |
| Clibc_error | Exception type used to propagate C runtime errors across functions |
| Cquit_game_exception | |
| ►Cstd::logic_error | STL class |
| Cgui2::iterator::tlogic_error | Thrown when deferring an invalid iterator |
| ►Cstd::runtime_error | STL class |
| ►Cstd::range_error | STL class |
| Cgui2::iterator::trange_error | Thrown when moving an invalid iterator |
| Ctest_throw::bad_lexical_cast | Thrown when a lexical_cast fails |
| Cutf8::invalid_utf8_exception | Thrown by operations encountering invalid UTF-8 data |
| Cexpdesc | |
| Cexploder_failure | |
| Cexploder_point | |
| Cexploder_rect | |
| Cng::create_engine::extras_metadata | |
| Ctest_utils::fake_display_manager | |
| Cfake_unit_manager | Manages a list of fake units for the display object |
| Cfake_unit_ptr | Holds a temporary unit that can be drawn on the map without being placed in the unit_map |
| Cfallback_ai_to_human_exception | |
| Cfilesystem::file_tree_checksum | |
| Csavegame::filename_filter | |
| ►Cfilter_context | |
| ►Cdisplay | |
| Ceditor::editor_display | |
| Cgame_display | |
| Cgame_state | |
| Cpathfind::ignore_units_filter_context | |
| Cgui2::event::implementation::find< done > | Specialized class when itor == end |
| Cgui2::event::implementation::find< false > | Specialized class when itor != end |
| Cng::flg_manager | FLG stands for faction, leader and gender |
| Cstoryscreen::floating_image | Represents and contains information about image labels used in story screen parts |
| Cfont::floating_label | |
| ►Cfont::floating_label_context | Structure which will hide all current floating labels, and cause floating labels instantiated after it is created to be displayed |
| Cgui::dialog_manager | |
| Cmp::ui | Base class for the different multiplayer base dialogs: game list, create game, wait game, game setup |
| Cgui::floating_textbox | |
| Cfont_id | |
| Cformatter | Std::ostringstream wrapper |
| Cgame_logic::formula | |
| Cgame_logic::formula_debugger | |
| ►Cgame_logic::formula_expression | |
| ►Cgame_logic::function_expression | |
| Cgame_logic::formula_function_expression | |
| Cgame_logic::wrapper_formula | |
| ►Cgame_logic::formula_function | |
| Cgame_logic::builtin_formula_function< T > | |
| Cgame_logic::user_formula_function | |
| Cgame_logic::formula_input | |
| Canimated< T, T_void_value >::frame | |
| Cframe_builder | |
| Cframe_parameters | All parameters from a frame at a given instant |
| Cframe_parsed_parameters | Keep most parameters in a separate class to simplify handling of large number of parameters handling is common for frame level and animation level |
| Csurface::free_sdl_surface | |
| Cpathfind::full_cost_map | Structure which uses find_routes() to build a cost map This maps each hex to a the movements a unit will need to reach this hex |
| CFuncState | |
| Cdetail::function_base< F > | |
| Cdetail::function_base< Ret(*)(P...)> | |
| Cdetail::function_base< Ret(Class::*)(P...) const > | |
| Cdetail::function_base< Ret(Class::*)(P...) const volatile > | |
| Cdetail::function_base< Ret(Class::*)(P...) volatile > | |
| Cdetail::function_base< Ret(Class::*)(P...)> | |
| Cdetail::function_base< Ret(P...)> | |
| Cdetail::function_base< std::function< Ret(P...)> > | |
| ►Cgame_logic::function_symbol_table | |
| Cgame_logic::ai_function_symbol_table | |
| Cwb::future_map | Applies the planned unit map for the duration of the struct's life |
| Cwb::future_map_if | |
| Cwb::future_map_if_active | ONLY IF whiteboard is currently active, applies the planned unit map for the duration of the struct's life |
| Clua_formula_bridge::fwrapper | |
| Cwesnothd::game | |
| Cgame_classification | |
| Cgame_config_manager | |
| Ctest_utils::game_config_manager | |
| Cwesnothd::game_id_matches | |
| Cai::game_info | |
| Cgame_info | This class represents the info a client has about a game on the server |
| Cwesnothd::game_is_member | |
| Cmp::gamebrowser::game_item | |
| Cgame_launcher | |
| Cwesnothd::game_t | |
| ►Cgamemap | Encapsulates the map of the game |
| Ceditor::editor_map | This class adds extra editor-specific functionality to a normal gamemap |
| CGCheader | |
| CGCObject | |
| Creports::generator | |
| Cevents::generic_event | |
| Cglobal_State | |
| CGLXBufferClobberEventSGIX | |
| CGLXHyperpipeConfigSGIX | |
| CGLXHyperpipeNetworkSGIX | |
| CGLXPbufferClobberEvent | |
| CGLXPipeRect | |
| CGLXPipeRectLimits | |
| ►Cai::goal_factory | |
| Cai::register_goal_factory< GOAL > | |
| CGPU_Attribute | |
| CGPU_AttributeFormat | |
| CGPU_AttributeSource | |
| CGPU_BlendMode | |
| CGPU_Camera | |
| CGPU_Context | |
| CGPU_ErrorObject | |
| CGPU_Image | |
| CGPU_MatrixStack | |
| CGPU_Rect | |
| CGPU_Renderer | |
| CGPU_RendererID | |
| CGPU_ShaderBlock | |
| CGPU_Target | |
| CGPU_WindowMapping | |
| Cgreater< T > | |
| Chalo::halo_impl | |
| ►Cwesnothd::handle_doc< Handler, ErrorHandler > | |
| Cwesnothd::handle_receive_doc< Handler, ErrorHandler > | |
| Cgame_events::handler_list | This is a wrapper for a list of weak pointers to handlers |
| Chelp::has_id | To be used as a function object to locate sections and topics with a specified ID |
| Chelp::help_manager | |
| Cwb::highlighter | Class that handles highlighting planned actions as you hover over them and determine the right target for contextual execution |
| Cai::holder | Base class that holds the AI and current AI parameters |
| ►Chotkey::hotkey_base | This is the base class for hotkey event matching |
| Chotkey::hotkey_joystick | |
| Chotkey::hotkey_keyboard | This class is responsible for handling keys, not modifiers |
| Chotkey::hotkey_mouse | This class is responsible for handling mouse button presses |
| Chotkey::hotkey_void | This class is used to return non-valid results in order to save other people from null checks |
| Chotkey::hotkey_command | Stores all information related to functions that can be bound to hotkeys |
| Chotkey::hotkey_command_temp | Do not use this outside hotkeys.cpp |
| ►CHTTP2ProgressHandler | |
| CPluginInstance::ProgressHandler | |
| Chttp_file_info | |
| Chttp_pack_info | |
| Cn_unit::id_manager | |
| CImageData_GLES_1 | |
| CImageData_GLES_2 | |
| CImageData_OpenGL_1 | |
| CImageData_OpenGL_1_BASE | |
| CImageData_OpenGL_2 | |
| CImageData_OpenGL_3 | |
| Cunit_abilities::individual_effect | |
| Cgui2::tlua_interpreter::input_model | The input_model keeps track of what commands were executed before, and figures out what should be displayed when the user presses up / down arrows in the input |
| Cinput_stream | |
| ►CInstance | |
| CPluginInstance | |
| ►Cintegral_constant | |
| Cstd::is_placeholder< boost::arg< N > > | |
| Cboost::intrusive_ptr< T > | |
| Cboost::intrusive_ptr< const tbuilder_grid > | |
| Cboost::intrusive_ptr< const unit > | |
| Cboost::intrusive_ptr< map_formula_callable > | |
| Cboost::intrusive_ptr< tbuilder_grid > | |
| Cboost::intrusive_ptr< tbuilder_widget > | |
| Cboost::intrusive_ptr< tresolution_definition_ > | |
| Cboost::intrusive_ptr< unit > | |
| Cinvalid_pbl_exception | Exception thrown when the WML parser fails to read a .pbl file |
| Caddons_client::invalid_server_address | |
| ►Cstd::ios_base | STL class |
| ►Cstd::basic_ios< Char > | STL class |
| ►Cstd::basic_istream< Char > | STL class |
| Cpreprocessor_deleter | |
| Cfilesystem::iostream_path | |
| Cis_energy_color | |
| Chelp::help_text_area::item | An item that is displayed in the text area |
| Cgui::menu::item | |
| Chelp::help_text_area::item_at | Function object to find an item at the specified coordinates |
| Ceditor::item_group | Stores the info about the groups in a nice format |
| Cgame_events::manager::iteration | This class is similar to an input iterator through event handlers, except each instance knows its own end (determined when constructed) |
| Cgui2::tgrid::iterator | Iterator for the tchild items |
| Cgame_events::handler_list::iterator | Handler list iterators are rather limited |
| Cdisplay::rect_of_hexes::iterator | Very simple iterator to walk into the rect_of_hexes |
| Cutils::smart_list< Data >::iterator_base< Value, Reversed > | The base for the list's iterator classes |
| Cucs4::iterator_base< string_type, update_implementation > | |
| Cunit_map::iterator_base< iter_types > | |
| ►Cutils::smart_list< Data >::iterator_base< const Data, false > | |
| Cutils::smart_list< Data >::const_iterator | |
| ►Cutils::smart_list< Data >::iterator_base< const Data, true > | |
| Cutils::smart_list< Data >::const_reverse_iterator | |
| ►Cutils::smart_list< Data >::iterator_base< Data, false > | |
| Cutils::smart_list< Data >::iterator | |
| ►Cutils::smart_list< Data >::iterator_base< Data, true > | |
| Cutils::smart_list< Data >::reverse_iterator | |
| Cutil::iterator_extend< Value, Container, Deref, Key > | This is an iterator class that extends an existing iterator by overriding dereference |
| Cucs4_convert_impl::iteratorwriter< oitor_t > | Transforms an output iterator to a writer for ucs4_convert_impl functions |
| Cjoystick_manager | |
| Cjump_to_campaign_info | |
| Cgame_events::wmi_container::key | The key for interaction with our iterators |
| ►Cai::known_aspect | |
| Cai::typesafe_known_aspect< T > | |
| Cai::known_aspect_type< T > | |
| CLabeldesc | |
| CLabellist | |
| Clanguage_def | |
| CLClosure | |
| Cleave_synced_context | |
| ►Cng::level | |
| Cng::campaign | |
| ►Cng::scenario | |
| Cng::random_map | |
| Cng::user_map | |
| CLexState | |
| CLG | |
| CLHS_assign | |
| CLoadF | |
| Csavegame::loadgame | The class for loading a savefile |
| CLoadS | |
| CLoadState | |
| Cgui2::lobby_delay_gamelist_update_guard | |
| Clobby_info | This class represents the collective information the client has about the players and games on the server |
| Cimage::locator | |
| CLocVar | |
| Clg::log_domain | |
| Clg::logger | |
| Cwesnothd::server::login_log | |
| Cai::lua_ai_action_handler | Proxy class for calling AI action handlers defined in Lua |
| Cai::lua_ai_context | Proxy table for the AI context |
| Cai::lua_ai_load | |
| ►Cai::lua_aspect_factory | |
| Cai::register_lua_aspect_factory< ASPECT > | |
| Clua_context_backend | |
| Clua_Debug | |
| Clua_fileops::lua_filestream | |
| ►Clua_kernel_base | |
| Capplication_lua_kernel | |
| Cgame_lua_kernel | |
| Cmapgen_lua_kernel | |
| Clua_longjmp | |
| Cgui2::tlua_interpreter::lua_model | The lua model is responsible to interact with the lua kernel base and keep track of what should be displayed in the console |
| ►Cai::lua_object_base | |
| Cai::lua_object< T > | |
| Clua_State | |
| Clua_TValue | |
| Clua_unit | Storage for a unit, either owned by the Lua code (ptr != 0), a local variable unit (c_ptr != 0), on a recall list (side != 0), or on the map |
| Cluai_Cast | |
| CluaL_Buffer | |
| CluaL_Reg | |
| CluaL_Stream | |
| CLX | |
| Cfont::manager | |
| Chalo::manager | |
| Chotkey::manager | This class is initialized once at game start put all initialization and wipe code in the methods here |
| Cimage::manager | Image manager is responsible for setting up images, and destroying all images when the program exits |
| Cnetwork::manager | |
| Cnetwork_worker_pool::manager | |
| Cpathfind::manager | |
| Cai::manager | Class that manages AIs for all sides and manages AI redeployment |
| Cmp::options::manager | |
| Cpreferences::manager | |
| Ccursor::manager | |
| Cthreading::manager | |
| Ctooltips::manager | |
| Cevents::map_command_handler< Worker > | |
| ►Cevents::map_command_handler< chat_command_handler > | |
| ►Cevents::chat_command_handler | |
| Cevents::console_handler | |
| ►Cevents::map_command_handler< console_handler > | |
| Cevents::console_handler | |
| Ceditor::map_context_refresher | Utility class to properly refresh the display when the map context object is replaced without duplicating code |
| Ceditor::map_fragment | A map fragment – a collection of locations and information abut them |
| ►Cmap_generator | |
| Ccave_map_generator | |
| Cdefault_map_generator | |
| Clua_map_generator | |
| Cmap_labels | |
| ►Cmap_location | Encapsulates the map of the game |
| Cgame_events::entity_location | |
| Cmap_locker | |
| Cwb::mapbuilder | Class that collects and applies unit_map modifications from the actions it visits and reverts all changes on destruction |
| Cpathfind::marked_route::mark | |
| Cpathfind::marked_route | Structure which holds a single route and marks for special events |
| Ccutter::mask | |
| Cgui::match_begin | |
| CMatchState | |
| ►Cmaximum_selection | |
| Cgui2::tgenerator< minimum_selection, maximum_selection, placement, select_action > | Basic template class to generate new items |
| Cvariable_info_detail::maybe_const< vit, T > | |
| Cvariable_info_detail::maybe_const< vit_const, config::child_itors > | |
| Cvariable_info_detail::maybe_const< vit_const, T > | |
| CMbuffer | |
| CMD5 | |
| Cschema_validation::schema_validator::message_info | Messages are cached |
| Cmetrics | |
| Cmp::minimap_cache_item | |
| ►Cminimum_selection | |
| Cgui2::tgenerator< minimum_selection, maximum_selection, placement, select_action > | Basic template class to generate new items |
| CMLFixture | |
| Cgui2::tchat_log::model | |
| Cgui2::tgamestate_inspector::model | |
| Cgui2::tmp_change_control::model | The model is an interface defining the data to be displayed or otherwise acted upon in the user interface |
| ►Cimage::modification | Base abstract class for an image-path modification |
| Cimage::adjust_alpha_modification | Adjust Alpha (ADJUST_ALPHA) modification |
| Cimage::background_modification | Fill background with a color (BG) |
| Cimage::bl_modification | Gaussian-like blur (BL) modification |
| Cimage::blend_modification | Color blending (BLEND) modification |
| Cimage::blit_modification | Scale (BLIT) modification |
| Cimage::brighten_modification | Overlay with ToD brightening (BRIGHTEN) |
| Cimage::bw_modification | Black and white (BW) modification |
| Cimage::crop_modification | Crop (CROP) modification |
| Cimage::cs_modification | Color-shift (CS, R, G, B) modification |
| Cimage::darken_modification | Overlay with ToD darkening (DARKEN) |
| Cimage::fl_modification | Mirror (FL) modification |
| Cimage::gs_modification | Grayscale (GS) modification |
| Cimage::light_modification | LIGHT (L) modification |
| Cimage::mask_modification | Mask (MASK) modification |
| Cimage::negative_modification | Make an image negative (NEG) |
| Cimage::o_modification | Opacity (O) modification |
| Cimage::plot_alpha_modification | Plot Alpha (Alpha) modification |
| Cimage::rc_modification | Recolor (RC/TC/PAL) modification |
| Cimage::rotate_modification | Rotate (ROTATE) modification |
| ►Cimage::scale_modification | Scaling modifications base class |
| Cimage::scale_exact_modification | Scale exact modification |
| Cimage::scale_into_modification | Scale into (SCALE_INTO) modification |
| Cimage::sepia_modification | Give to the image a sepia tint (SEPIA) |
| Cimage::swap_modification | Channel swap (SWAP) |
| Cimage::wipe_alpha_modification | Wipe Alpha (Wipe_Alpha) modification |
| Cimage::xbrz_modification | XBRZ scale (xBRZ) modification |
| Cimage::modification_queue | A modified priority queue used to order image modifications |
| ►CModule | |
| CPepperModule | |
| ►Ceditor::mouse_action | A mouse action receives events from the controller, and responds to them by creating an appropriate editor_action object |
| ►Ceditor::brush_drag_mouse_action | A brush-drag mouse action base class which adds brush and drag processing to a basic mouse action |
| Ceditor::mouse_action_paint | Brush paint mouse action |
| Ceditor::mouse_action_select | Select (and deselect) action, by brush or "magic wand" (via keyboard modifier) |
| Ceditor::mouse_action_fill | Fill action |
| Ceditor::mouse_action_item | Item placement action class |
| Ceditor::mouse_action_map_label | Set map label action |
| Ceditor::mouse_action_paste | Paste action |
| Ceditor::mouse_action_starting_position | Set starting position action |
| Ceditor::mouse_action_unit | Unit placement action class |
| Ceditor::mouse_action_village | Editor mouse action class |
| ►Cevents::mouse_handler_base | |
| Ceditor::editor_controller | Mouse and keyboard event handling routines for the editor |
| Cevents::mouse_handler | |
| Cgame_logic::position_callable::move_map_backup | |
| Cactions::move_unit_spectator | |
| Cmovetype | The basic "size" of the unit - flying, small land, large land, etc |
| Cmp_campaign_info | |
| Cmp_connect_fixture | |
| Cmp_game_settings | |
| Cmp::chat::msg | |
| Crand_rng::mt_rng | |
| Csound::music_track | Internal representation of music tracks |
| ►Cname_generator | |
| Ccontext_free_grammar_generator | |
| Cmarkov_generator | |
| Cproxy_name_generator | |
| Cpersist_context::name_space | |
| Cwesnothd::name_t | |
| CNode | |
| Csimple_wml::node | |
| Csimple_wml::node::node_pos | |
| Cutils::smart_list< Data >::node_t | Nodes in the smart list |
| Cmp::configure::nolock_settings | |
| ►Cnoncopyable | |
| Cactions::shroud_clearer | Class to encapsulate fog/shroud clearing and the resultant sighted events |
| ►Cactions::undo_action_base | Records information to be able to undo an action |
| Cactions::undo::auto_shroud_action | |
| Cactions::undo::update_shroud_action | |
| ►Cactions::undo_action | Actions that are undoable (this does not include update_shroud and auto_shroud) |
| Cactions::undo::dismiss_action | |
| Cactions::undo::move_action | |
| Cactions::undo::recall_action | |
| Cactions::undo::recruit_action | |
| Cactions::undo_dummy_action | Entry for player actions that do not need any special code to be performed when undoing such as right-click menu items |
| Cactions::undo_list | Class to store the actions that a player can undo and redo |
| Caddons_client | Add-ons (campaignd) client class |
| Cai::formula_ai | |
| Capplication_lua_kernel::thread | |
| Carrow | Arrows destined to be drawn on the map |
| Ccampaignd::blacklist | Add-on blacklist table |
| Ccampaignd::server | Legacy add-ons server |
| CCVideo | |
| Ceditor::editor_controller | Mouse and keyboard event handling routines for the editor |
| Ceditor::map_context | This class wraps around a map to provide a concise interface for the editor to work with |
| Cfont::ttext | Text class |
| ►Cgame_config::config_cache | Singleton class to manage game config file caching |
| Ctest_config_cache | Used to make distinct singleton for testing it because other tests will need original one to load data |
| Cgame_config::config_cache_transaction | Used to share macros between cache objects You have to create transaction object to load all macros to memory and share them subsequent cache loads |
| Cgame_config::fake_transaction | Holds a fake cache transaction if no real one is used |
| Cgame_config::scoped_preproc_define_internal< T > | Used to set and unset scoped defines to preproc_map |
| Cgame_events::manager | The game event manager loads the scenario configuration object, and ensures that events are handled according to the scenario configuration for its lifetime |
| Cgui2::iterator::titerator< order > | The iterator class |
| ►Cgui2::twidget | Base class for all widgets |
| ►Cgui2::tcontrol | Base class for all visible items |
| Cgui2::tbutton | Simple push button |
| Cgui2::tcombobox | Simple push button |
| ►Cgui2::tcontainer_ | A generic container base class |
| Cgui2::tmulti_page | The multi page class |
| ►Cgui2::tpanel | Visible container to hold multiple widgets |
| Cgui2::ttoggle_panel | Class for a toggle button |
| Cgui2::twindow | Base class of top level items, the only item which needs to store the final canvases to draw on |
| ►Cgui2::tscrollbar_container | Base class for creating containers with one or two scrollbar(s) |
| Cgui2::tlistbox | The listbox class |
| Cgui2::tscroll_label | Label showing a text |
| Cgui2::tscrollbar_panel | Visible container to hold multiple widgets |
| Cgui2::ttree_view | |
| Cgui2::tstacked_widget | |
| Cgui2::tunit_preview_pane | |
| ►Cgui2::tcontrol_NEW< STATE > | |
| Cgui2::tmatrix | The matrix class |
| Cgui2::tdrawing | A widget to draw upon |
| Cgui2::timage | An image |
| Cgui2::tlabel | Label showing a text |
| Cgui2::tminimap | The basic minimap class |
| Cgui2::tprogress_bar | |
| Cgui2::trepeating_button | |
| ►Cgui2::tscrollbar_ | Base class for a scroll bar |
| Cgui2::thorizontal_scrollbar | A horizontal scrollbar |
| Cgui2::tslider | A slider |
| Cgui2::tvertical_scrollbar | A vertical scrollbar |
| Cgui2::tspacer | An empty widget |
| ►Cgui2::ttext_ | Abstract base class for text items |
| ►Cgui2::ttext_box | Class for a single line text area |
| Cgui2::tpassword_box | |
| Cgui2::ttoggle_button | Class for a toggle button |
| ►Cgui2::tgenerator_ | Abstract base class for the generator |
| Cgui2::policy::maximum_selection::tinfinite | No maximum amount of items to select |
| Cgui2::policy::maximum_selection::tone | May select only one item |
| Cgui2::policy::minimum_selection::tnone | No minimum selection |
| Cgui2::policy::minimum_selection::tone | Must select at least one item |
| Cgui2::policy::placement::thorizontal_list | Places the items in a horizontal row |
| Cgui2::policy::placement::tindependent | Places the items independent of each other |
| Cgui2::policy::placement::tmatrix | Places the items in a grid |
| Cgui2::policy::placement::tvertical_list | Places the items in a vertical column |
| Cgui2::policy::select_action::tselect | Select the item, this requires the grid to contain a tselectable_ |
| Cgui2::policy::select_action::tshow | Show the item |
| Cgui2::tgrid | Base container class |
| Cgui2::tpane | |
| Cgui2::ttree_view_node | |
| Cgui2::tviewport | |
| Cgui2::twidget::tredraw_action | Visibility set by the engine |
| Cgui2::twidget::tvisible | Visibility settings done by the user |
| Cgui::drop_group_manager | Used to create and destroy drop groups |
| ►Cgui::drop_target | Handles droping for drag able ui items |
| Cgui::combo_drag | |
| Ctest_drop_target | Specialized testing class so unit test can call protected member functions to simulate drop operation |
| Chalo::halo_record | RAII object which manages a halo |
| Cgame_config::scoped_preproc_define_internal< test_config_cache > | |
| Csdl::twindow | The wrapper class for the SDL_Window class |
| Cthreading::condition | |
| Cthreading::lock | |
| Cthreading::mutex | |
| Cthreading::thread | |
| Ctoptions | A singleton class containing the parsed command line parameters |
| Cttracer | Helper structure for gathering the tracing statistics |
| Cttracer::tprint | Helper structure to print the tracing statistics |
| Ctwesnothd_connection | A class that represents a TCP/IP connection to the wesnothd server |
| Cunit_display::unit_mover | A class to encapsulate the steps of drawing a unit's move |
| Cunit_movement_resetter | Object which temporarily resets a unit's movement |
| Cunit_type_data | |
| Cwb::manager | This class is the frontend of the whiteboard framework for the rest of the Wesnoth code |
| Cwesnothd::room_manager | The room manager manages the lobby and other rooms in the server, and related client message processing |
| Ccontext_free_grammar_generator::nonterminal | |
| Caddons_client::not_connected_to_server | |
| Cwb::side_actions::numbers_t | |
| ►Ctheme::object | |
| Ctheme::action | |
| Ctheme::label | |
| Ctheme::menu | |
| Ctheme::panel | |
| Ctheme::slider | |
| Ctheme::status_item | |
| ►Cevents::observer | |
| Cai::aspect | |
| Cai::default_recruitment::recruitment::recruit_situation_change_observer | |
| Cai::formula_ai::gamestate_change_observer | |
| Cai::gamestate_observer | |
| Cai::keeps_cache | |
| Cai::readonly_context_impl | |
| Cgui2::tsynced_choice_wait | |
| ►Cplay_controller | |
| ►Cplaysingle_controller | |
| Cplaymp_controller | |
| Creplay_controller | |
| Csoundsource::manager | |
| ►Cmp::options::option_display | |
| Cmp::options::checkbox_display | |
| Cmp::options::combo_display | |
| Cmp::options::entry_display | |
| Cmp::options::reset_display | |
| Cmp::options::slider_display | |
| Cmp::options::title_display | |
| Cgame_config::optional_feature | |
| ►Corder | |
| Cgui2::iterator::titerator< order > | The iterator class |
| Coverlay | |
| Cmovetype::terrain_info::parameters | The parameters used when calculating a terrain-based value |
| Cstoryscreen::part | Represents and contains information about a single storyscreen part |
| Ccave_map_generator::cave_map_generator_job::passage | |
| Cai::path_element | |
| Cai::path_element_matches< T > | |
| ►Cpathfind::paths | Object which contains all the possible locations a unit can move to, with associated best routes to those locations |
| Cpathfind::jamming_path | A refinement of paths for use when calculating jamming |
| Cpathfind::vision_path | A refinement of paths for use when calculating vision |
| Cnetwork::pending_statistics | |
| ►Cpersist_context | |
| Cpersist_file_context | |
| Cpersist_manager | |
| ►Cplacement | |
| Cgui2::tgenerator< minimum_selection, maximum_selection, placement, select_action > | Basic template class to generate new items |
| Cplacing_info | |
| Cpathfind::plain_route | Structure which holds a single route between one location and another |
| Cwesnothd::player | |
| Cwesnothd::player_record | |
| Cplayturn_network_adapter | |
| Cplugin | |
| Cplugins_context | |
| Cplugins_manager | |
| Cvconfig::all_children_iterator::pointer_proxy | |
| Csoundsource::positional_source | |
| Ccutter::positioned_surface | |
| Cpreproc_config | |
| Cpreproc_define | |
| ►Cpreprocessor | Base class for preprocessing an input |
| Cpreprocessor_data | Specialized preprocessor for handling any kind of input stream |
| Cpreprocessor_file | Specialized preprocessor for handling a file or a set of files |
| Cmp::configure::process_event_data | |
| Cmp::connect::process_event_data | |
| Cmp::create::process_event_data | |
| Cmp::lobby::process_event_data | |
| Cprogressive_< T > | |
| Cprogressive_< double > | |
| Cprogressive_< int > | |
| Cprogressive_image | |
| Cprogressive_string | |
| CProto | |
| Cptr_vector_pushback | |
| Cgame_events::pump_impl | |
| Cevents::pump_info | |
| ►Cevents::pump_monitor | |
| Ccountdown_clock | |
| Cgui2::tnetwork_transmission::pump_monitor | |
| Cgui::combo_drag | |
| Csound::music_thinker | |
| Cuser_choice_manager | |
| Cgame_events::queued_event | |
| ►Cquit_confirmation | Implements a quit confirmation dialog |
| Ceditor::editor_controller | Mouse and keyboard event handling routines for the editor |
| Cplay_controller | |
| Cai::ai_default_rca::rated_target | |
| Cai::ai_default_rca::rated_target_comparer | |
| Cwb::real_map | Ensures that the real unit map is active for the duration of the struct's life |
| Crecall_list_manager | |
| Cdisplay::rect_of_hexes | Rectangular area of hexes, allowing to decide how the top and bottom edges handles the vertical shift for each parity of the x coordinate |
| Cai::recursion_counter | |
| ►Creference_counted_object | |
| ►Cgame_logic::formula_callable | |
| Cai::attack_analysis | |
| Cai::formula_ai | |
| Cattack_type_callable | |
| Cconfig_callable | |
| Cgame_logic::attack_callable | |
| Cgame_logic::attack_map_callable | |
| Cgame_logic::fallback_callable | |
| Cgame_logic::formula_callable_no_ref_count | |
| Cgame_logic::formula_callable_with_backup | |
| Cgame_logic::formula_variant_callable_with_backup | |
| Cgame_logic::key_value_pair | |
| Cgame_logic::map_formula_callable | |
| Cgame_logic::move_callable | |
| Cgame_logic::move_map_callable | |
| Cgame_logic::move_partial_callable | |
| Cgame_logic::outcome_callable | |
| Cgame_logic::position_callable | |
| Cgame_logic::recall_callable | |
| Cgame_logic::recruit_callable | |
| Cgame_logic::safe_call_callable | |
| Cgame_logic::safe_call_result | |
| Cgame_logic::set_unit_var_callable | |
| Cgame_logic::set_var_callable | |
| Clocation_callable | |
| Clua_callable | |
| Cmock_char | |
| Cmock_party | |
| Cterrain_callable | |
| Cunit_callable | |
| Cunit_type_callable | |
| ►Cgui2::tbuilder_widget | Contains the info needed to instantiate a widget |
| ►Cgui2::implementation::tbuilder_control | |
| Cgui2::implementation::tbuilder_button | |
| Cgui2::implementation::tbuilder_combobox | |
| Cgui2::implementation::tbuilder_drawing | |
| Cgui2::implementation::tbuilder_horizontal_listbox | |
| Cgui2::implementation::tbuilder_horizontal_scrollbar | |
| Cgui2::implementation::tbuilder_image | |
| Cgui2::implementation::tbuilder_label | |
| Cgui2::implementation::tbuilder_listbox | |
| Cgui2::implementation::tbuilder_matrix | |
| Cgui2::implementation::tbuilder_minimap | |
| Cgui2::implementation::tbuilder_multi_page | |
| Cgui2::implementation::tbuilder_panel | |
| Cgui2::implementation::tbuilder_password_box | |
| Cgui2::implementation::tbuilder_progress_bar | |
| Cgui2::implementation::tbuilder_repeating_button | |
| Cgui2::implementation::tbuilder_scroll_label | |
| Cgui2::implementation::tbuilder_scrollbar_panel | |
| Cgui2::implementation::tbuilder_slider | |
| Cgui2::implementation::tbuilder_spacer | |
| Cgui2::implementation::tbuilder_stacked_widget | |
| Cgui2::implementation::tbuilder_text_box | |
| Cgui2::implementation::tbuilder_toggle_button | |
| Cgui2::implementation::tbuilder_toggle_panel | |
| Cgui2::implementation::tbuilder_tree_view | |
| Cgui2::implementation::tbuilder_unit_preview_pane | |
| Cgui2::implementation::tbuilder_vertical_scrollbar | |
| Cgui2::implementation::tbuilder_window | |
| Cgui2::implementation::tbuilder_instance | |
| Cgui2::implementation::tbuilder_pane | |
| Cgui2::implementation::tbuilder_viewport | |
| Cgui2::tbuilder_grid | |
| ►Cgui2::tcanvas::tshape | Abstract base class for all other shapes |
| Cgui2::timage | An image |
| ►Cgui2::tcontrol_definition | |
| Cgui2::tbutton_definition | |
| Cgui2::tcombobox_definition | |
| Cgui2::tdrawing_definition | |
| Cgui2::thorizontal_scrollbar_definition | |
| Cgui2::timage_definition | |
| Cgui2::tlabel_definition | |
| Cgui2::tlistbox_definition | |
| Cgui2::tmatrix_definition | |
| Cgui2::tminimap_definition | |
| Cgui2::tmulti_page_definition | |
| Cgui2::tpanel_definition | |
| Cgui2::tprogress_bar_definition | |
| Cgui2::trepeating_button_definition | |
| Cgui2::tscroll_label_definition | |
| Cgui2::tscrollbar_panel_definition | |
| Cgui2::tslider_definition | |
| Cgui2::tspacer_definition | |
| Cgui2::tstacked_widget_definition | |
| Cgui2::ttext_box_definition | |
| Cgui2::ttoggle_button_definition | |
| Cgui2::ttoggle_panel_definition | |
| Cgui2::ttree_view_definition | |
| Cgui2::tunit_preview_pane_definition | |
| Cgui2::tvertical_scrollbar_definition | |
| Cgui2::twindow_definition | |
| ►Cgui2::tresolution_definition_ | Base class of a resolution, contains the common keys for a resolution |
| Cgui2::tbutton_definition::tresolution | |
| Cgui2::tcombobox_definition::tresolution | |
| Cgui2::tdrawing_definition::tresolution | |
| Cgui2::thorizontal_scrollbar_definition::tresolution | |
| Cgui2::timage_definition::tresolution | |
| Cgui2::tlabel_definition::tresolution | |
| Cgui2::tlistbox_definition::tresolution | |
| Cgui2::tmatrix_definition::tresolution | |
| Cgui2::tminimap_definition::tresolution | |
| Cgui2::tmulti_page_definition::tresolution | |
| ►Cgui2::tpanel_definition::tresolution | |
| Cgui2::twindow_definition::tresolution | |
| Cgui2::tprogress_bar_definition::tresolution | |
| Cgui2::trepeating_button_definition::tresolution | |
| Cgui2::tscroll_label_definition::tresolution | |
| Cgui2::tscrollbar_panel_definition::tresolution | |
| Cgui2::tslider_definition::tresolution | |
| Cgui2::tspacer_definition::tresolution | |
| Cgui2::tstacked_widget_definition::tresolution | |
| Cgui2::ttext_box_definition::tresolution | |
| Cgui2::ttoggle_button_definition::tresolution | |
| Cgui2::ttoggle_panel_definition::tresolution | |
| Cgui2::ttree_view_definition::tresolution | |
| Cgui2::tunit_preview_pane_definition::tresolution | |
| Cgui2::tvertical_scrollbar_definition::tresolution | |
| Clua_cpp::Reg | |
| Cplugins_context::Reg | |
| Clua_check_impl::remove_constref< T > | |
| Cai::ai_default_rca::remove_wrong_targets | |
| Cstoryscreen::floating_image::render_input | |
| CRendererRegistration | |
| Creplay | |
| Creplay_helper | |
| Creplay_network_sender | |
| Creplay_recorder_base | |
| Creplay_controller::replay_stop_condition | |
| Creport_generator_helper | |
| Creports | |
| Ccampaignd::server::request | Client request information object |
| Cmp::required_addon | |
| Creset_gamestate_exception | |
| Cmovetype::resistances | Stores a set of resistances |
| ►Crandom_new::rng | This class does not give synced random results derived classes might do |
| Crandom_new::rng_deterministic | This rng is used when the normal synced rng is not available this is currently only he case at the very start of the scenario (random generation of starting units traits) |
| Crandom_new::synced_rng | |
| Cwesnothd::room | A room is a group of players that can communicate via messages |
| Croom_info | This class represents the information a client has about a room |
| Cterrain_builder::rule_image | Each terrain_graphics rule is associated a set of images, which are applied on the terrain if the rule matches |
| Cterrain_builder::tile::rule_image_rand | Represent a rule_image applied with a random seed |
| Cterrain_builder::rule_image_variant | An image variant |
| Cmetrics::sample | |
| Csave_blocker | While any instance of this class exists, attempts to save the game via any call to play_controller will be temporarily postponed: the call will return immediately without performing the save, but the save method will then be reinvoked from this class's destructor |
| Csave_id_equals | |
| Cevents::save_id_matches | |
| Csavegame::save_index_class | |
| Csavegame::save_info | Filename and modification date for a file list |
| Csavegame::save_info_less_time | A structure for comparing to save_info objects based on their modified time |
| Csave_blocker::save_unblocker | An exception-safe means of making sure that unblock() gets called after try_block() |
| Csaved_game | |
| ►Csavegame::savegame | The base class for all savegame stuff |
| ►Csavegame::ingame_savegame | Class for "normal" midgame saves |
| Csavegame::autosave_savegame | Class for autosaves |
| Csavegame::oos_savegame | |
| Csavegame::replay_savegame | Class for replay saves (either manually or automatically) |
| Csavegame::scenariostart_savegame | Class for start-of-scenario saves |
| Cxbrz::ScalerCfg | |
| Cstatistics::scenario_context | |
| Chotkey::scope_changer | |
| Clg::scope_logger | |
| Cgame_events::context::scoped | |
| Cfilesystem::scoped_istream | |
| Cfilesystem::scoped_ostream | |
| Cutil::scoped_resource< T, ReleasePolicy > | A class template, scoped_resource, designed to implement the Resource Acquisition Is Initialization (RAII) approach to resource management |
| ►Cutil::scoped_resource< gui::gui::button *, delete_item > | |
| Cutil::scoped_ptr< gui::gui::button > | |
| ►Cutil::scoped_resource< gui::gui::textbox *, delete_item > | |
| Cutil::scoped_ptr< gui::gui::textbox > | |
| Cutil::scoped_resource< SDL_Surface *, free_sdl_surface > | |
| ►Cutil::scoped_resource< surface_restorer *, delete_item > | |
| Cutil::scoped_ptr< surface_restorer > | |
| ►Cutil::scoped_resource< T *, delete_array > | |
| Cutil::scoped_array< T > | This class has identical behavior to scoped_ptr, except it manages heap-allocated arrays instead of heap-allocated single objects |
| ►Cutil::scoped_resource< T *, delete_item > | |
| Cutil::scoped_ptr< T > | A class which implements an approximation of template<typename T> typedef scoped_resource<T*,delete_item> scoped_ptr<T>; |
| Cplay_controller::scoped_savegame_snapshot | |
| ►Cscoped_wml_variable | |
| Cscoped_recall_unit | |
| Cscoped_weapon_info | |
| Cscoped_xy_unit | |
| Cgui::scrollpane::scrollpane_widget | |
| ►Cevents::sdl_handler | |
| CCVideo::video_event_handler | |
| Cgui2::event::thandler | This singleton class handles all events |
| ►Cgui::widget | |
| ►Ceditor::common_palette | |
| Ceditor::empty_palette | Empty palette |
| Ceditor::location_palette | |
| ►Ceditor::tristate_palette | |
| Ceditor::editor_palette< Item > | |
| ►Ceditor::editor_palette< overlay > | |
| Ceditor::item_palette | Palette where the terrain to be drawn can be selected |
| ►Ceditor::editor_palette< t_translation::t_terrain > | |
| Ceditor::terrain_palette | Palette where the terrain to be drawn can be selected |
| ►Ceditor::editor_palette< unit_type > | |
| Ceditor::unit_palette | Palette where the terrain to be drawn can be selected |
| Ceditor::palette_manager | Empty palette |
| ►Cgui::button | |
| ►Cgui::combo | |
| Cgui::combo_drag | |
| ►Cgui::dialog_button | |
| Cgui::standard_dialog_button | |
| Chelp::help_button | |
| Clocation_palette_button | |
| Cgui::dialog_image | |
| Cgui::label | |
| ►Cgui::preview_pane | |
| Cbattle_prediction_pane | |
| ►Cdialogs::unit_preview_pane | Show unit-stats in a side-pane to unit-list, recall-list, etc |
| Cdialogs::unit_types_preview_pane | |
| Cdialogs::units_list_preview_pane | |
| Cmp::wait::leader_preview_pane | |
| Cgui::progress_bar | |
| ►Cgui::scrollarea | |
| ►Cgui::menu | |
| Cgui::file_menu | A widget where the user may navigate through directories and choose a file |
| Cgui::multimenu | A widget that additionally to the normal menu contents also displays a checkbox in each row |
| Chelp::help_menu | The menu to the left in the help browser, where topics can be navigated through and chosen |
| Cmp::gamebrowser | |
| Cgui::scrollpane | Scrollpane |
| ►Cgui::textbox | |
| ►Cgui::dialog_textbox | |
| Cgui::filter_textbox | |
| Chelp::help_text_area | The area where the content is shown in the help browser |
| Cgui::scrollbar | Scrollbar |
| ►Cgui::slider | |
| Cgui::list_slider< T > | |
| Cgui::zoom_slider | |
| Cgui::tristate_button | |
| Chelp::help_browser | A help browser widget |
| Clocation_palette_item | |
| Cmp::ui | Base class for the different multiplayer base dialogs: game list, create game, wait game, game setup |
| Chotkey::basic_handler | |
| Cpreferences::prefs_event_handler | |
| Cstoryscreen::part_ui | Storyscreen part user interface |
| ►Cvideo2::draw_layering | |
| ►Ccontroller_base | |
| Ceditor::editor_controller | Mouse and keyboard event handling routines for the editor |
| Cplay_controller | |
| Cdisplay | |
| Cgui2::event::tdistributor::layer | |
| Cgui::dialog_frame | |
| Chelp::section | A section contains topics and sections along with title and ID |
| Chelp::section_less | To be used as a function object when sorting section lists on the title |
| ►Cselect_action | |
| Cgui2::tgenerator< minimum_selection, maximum_selection, placement, select_action > | Basic template class to generate new items |
| CSemInfo | |
| Csendfile_param | |
| Cwesnothd::server | |
| Csynced_context::server_choice | |
| Cgame_config::server_info | |
| Cnetwork::server_manager | A server manager causes listening on a given port to occur for the duration of its lifetime |
| Crandom_new::set_random_determinstic | RAII class to use rng_deterministic in the current scope |
| ►Cset_scontext_synced_base | |
| Cset_scontext_synced | |
| Cset_scontext_unsynced | Object to leave the synced context during draw or unsynced wml items when we don’t know whether we are in a synced context or not |
| ►Ccursor::setter | |
| Cgui2::twindow | Base class of top level items, the only item which needs to store the final canvases to draw on |
| Cgui::dialog_manager | |
| Csha1_hash | |
| Cshared_node< T > | |
| Cshared_object< T, node > | |
| Cboost::shared_ptr< T > | |
| Cboost::shared_ptr< ai::default_recruitment::recruit_job > | |
| Cboost::shared_ptr< ai::default_recruitment::recruit_limit > | |
| Cboost::shared_ptr< ai::formula_ai > | |
| Cboost::shared_ptr< ai::lua_ai_action_handler > | |
| Cboost::shared_ptr< ai::lua_ai_context > | |
| Cboost::shared_ptr< ai::lua_object< ai::aspect_attacks_lua_filter > > | |
| Cboost::shared_ptr< ai::lua_object< attacks_vector > > | |
| Cboost::shared_ptr< ai::lua_object< config > > | |
| Cboost::shared_ptr< ai::lua_object< T > > | |
| Cboost::shared_ptr< ai::typesafe_aspect< T > > | |
| Cboost::shared_ptr< ai_composite > | |
| Cboost::shared_ptr< arrow > | |
| Cboost::shared_ptr< attacks_vector > | |
| Cboost::shared_ptr< bandwidth_stats > | |
| Cboost::shared_ptr< base_breakpoint > | |
| Cboost::shared_ptr< bool > | |
| Cboost::shared_ptr< boost::asio::ip::tcp::socket > | |
| Cboost::shared_ptr< combo_drag > | |
| Cboost::shared_ptr< config > | |
| Cboost::shared_ptr< const config > | |
| Cboost::shared_ptr< const formula > | |
| Cboost::shared_ptr< const std::vector< boost::intrusive_ptr > > | |
| Cboost::shared_ptr< const t_string_base > | |
| Cboost::shared_ptr< drop_group_manager > | |
| Cboost::shared_ptr< formula_expression > | |
| Cboost::shared_ptr< game_logic::base_candidate_action > | |
| Cboost::shared_ptr< game_logic::formula > | |
| Cboost::shared_ptr< gui2::tchat_log::view > | |
| Cboost::shared_ptr< gui2::tgamestate_inspector::view > | |
| Cboost::shared_ptr< gui2::tmp_change_control::view > | |
| Cboost::shared_ptr< halo::halo_impl > | |
| Cboost::shared_ptr< halo_record > | |
| Cboost::shared_ptr< move_result > | |
| Cboost::shared_ptr< movetype::terrain_info::data > | |
| Cboost::shared_ptr< name_generator > | |
| Cboost::shared_ptr< pathfind::plain_route > | |
| Cboost::shared_ptr< random_new::rng > | |
| Cboost::shared_ptr< reports::generator > | |
| Cboost::shared_ptr< side_actions > | |
| Cboost::shared_ptr< side_controller > | |
| Cboost::shared_ptr< side_engine > | |
| Cboost::shared_ptr< simple_wml::document > | |
| Cboost::shared_ptr< single_mode_controller > | |
| Cboost::shared_ptr< terrain_filter > | |
| Cboost::shared_ptr< terrain_type_data > | |
| Cboost::shared_ptr< unit_filter > | |
| Cboost::shared_ptr< unit_filter_abstract_impl > | |
| Cboost::shared_ptr< variant > | |
| Cboost::shared_ptr< wb::highlighter > | |
| Cboost::shared_ptr< wb::manager > | |
| Cboost::shared_ptr< wb::side_actions > | |
| Cboost::shared_ptr< wesnothd::game > | |
| Cboost::shared_ptr< wesnothd::handle_doc::DataSize > | |
| ►Cactions::shroud_clearing_action | Base class for classes that clear srhoud (move/recruit/recall) |
| Cactions::undo::move_action | |
| Cactions::undo::recall_action | |
| Cactions::undo::recruit_action | |
| Cteam::shroud_map | |
| Cmp::connect::side | |
| Cwb::side_actions_container | Datastructure holding the actions of a side on multiple turns |
| ►Cai::side_context | |
| ►Cai::readonly_context | |
| Cai::readonly_context_impl | |
| ►Cai::readonly_context_proxy | |
| Cai::aspect | |
| Cai::formula_ai | |
| Cai::goal | |
| Cai::readwrite_context_impl | |
| ►Cai::readwrite_context_proxy | |
| Cai::default_ai_context_impl | |
| ►Cai::default_ai_context_proxy | |
| Cai::ai_composite | |
| ►Cai::ai_context_proxy | |
| ►Cai::rca_context_proxy | |
| Cai::candidate_action | |
| Cai::stage | |
| ►Cai::readwrite_context | |
| ►Cai::default_ai_context | |
| ►Cai::ai_context | |
| Cai::ai_composite | |
| Cai::ai_context_proxy | |
| ►Cai::rca_context | |
| Cai::ai_default_rca::candidate_action_evaluation_loop | |
| Cai::candidate_action_context | |
| Cai::rca_context_proxy | |
| Cai::default_ai_context_impl | |
| Cai::default_ai_context_proxy | |
| Cai::readwrite_context_impl | |
| Cai::readwrite_context_proxy | |
| Cai::side_context_impl | |
| ►Cai::side_context_proxy | |
| Cai::readonly_context_impl | |
| Cai::readonly_context_proxy | |
| Cgui2::side_controller | |
| Cng::side_engine | |
| Cside_filter | |
| Cactions::shroud_clearer::sight_data | A record of a sighting event |
| ►Cgui2::single_mode_controller | |
| Cgui2::event_mode_controller | Controller for WML event and menu item handler views |
| Cgui2::team_mode_controller | |
| Cgui2::unit_mode_controller | |
| Cgui2::variable_mode_controller | |
| Cutils::smart_list< Data > | This is a variant on a list that never invalidates iterators (unless, of course, the list ceases to exist) |
| Cutils::smart_list< internal_ptr > | |
| Cwesnothd::socket_t | |
| ►Cgui::menu::sorter | |
| ►Cgui::menu::basic_sorter | |
| Cmp::lobby::lobby_sorter | |
| Csoundsource::sourcespec | Sound source info class |
| CSParser | |
| ►Cai::stage_factory | |
| Cai::register_stage_factory< STAGE > | |
| Cunit_map::standard_iter_types | |
| ►CSTATE | |
| Cgui2::tcontrol_NEW< STATE > | |
| Cgame_events::context::state | State when processing a particular flight of events or commands |
| ►Cstatic_visitor | |
| Cai::lua_aspect_visitor | |
| Cconfig::attribute_value::equality_visitor | Visitor handling equality checks |
| Cconfig::attribute_value::string_visitor | Visitor for converting a variant to a string |
| Cfai_variant_visitor | |
| Cnetwork::statistics | |
| Cstatistics::stats | |
| Cstbi_io_callbacks | |
| Cpathfind::paths::step | |
| Chelp::string_less | |
| Csimple_wml::string_span | |
| Cstringtable | |
| Cgui::dialog_frame::style | |
| ►Cgui::menu::style | |
| Cgui::menu::imgsel_style | |
| Cfont::subset_descriptor | |
| Csurface | |
| Csurface_lock | Helper class for pinning SDL surfaces into memory |
| Csurface_restorer | |
| Csymbol_table | |
| Csynced_command | |
| Csynced_context | |
| ►Csyncmp_handler | |
| Cplaymp_controller | |
| Csyncmp_registry | |
| Cgame_events::t_event_handlers | |
| Ct_translation::t_match | This structure can be used for matching terrain strings |
| Cgame_events::t_pump | |
| Cn_ref_counter::t_ref_counter< T_integral > | T_ref_counter is a reference counter |
| Cn_ref_counter::t_ref_counter< signed int > | |
| Ct_string | |
| Ct_string_base | |
| Ct_translation::t_terrain | A terrain string which is converted to a terrain is a string with 1 or 2 layers the layers are separated by a caret and each group consists of 2 to 4 characters if no second layer is defined it is stored as 0xFFFFFFFF, if the second layer is empty (needed for matching) the layer has the value 0 |
| CTable | |
| Ctag_name_manager | |
| Cai::target | |
| CTargetData_GLES_1 | |
| CTargetData_GLES_2 | |
| CTargetData_OpenGL_1 | |
| CTargetData_OpenGL_1_BASE | |
| CTargetData_OpenGL_2 | |
| CTargetData_OpenGL_3 | |
| Cdisplay::tblit | Helper structure for rendering the terrains |
| Ctheme::tborder | |
| Cgui2::tmessage::tbutton_status | |
| Cgui2::tcanvas | A simple canvas which can be drawn upon |
| Cgui2::tgrid::tchild | Child item of the grid |
| ►Cgui2::tclickable_ | Small concept class |
| Cgui2::tbutton | Simple push button |
| Cgui2::trepeating_button | |
| Ctconfig_implementation | |
| Cutils::tconst_clone< D, S, E > | Helper struct to clone the constness of one type to another |
| Cutils::tconst_clone< D, S, typename boost::enable_if< boost::is_const< typename boost::remove_pointer< typename boost::remove_reference< S >::type >::type > >::type > | The specialised version of tconst_clone |
| ►Cgui2::tdialog | Abstract base class for all dialogs |
| Cgui2::taddon_connect | Addon connect dialog |
| Cgui2::taddon_description | |
| Cgui2::taddon_filter_options | |
| Cgui2::taddon_list | Shows the list of addons on the server |
| Cgui2::taddon_uninstall_list | |
| Cgui2::tadvanced_graphics_options | |
| Cgui2::tcampaign_difficulty | |
| Cgui2::tcampaign_selection | |
| Cgui2::tcampaign_settings | |
| Cgui2::tchat_log | |
| Cgui2::tcore_selection | |
| Cgui2::tcustom_tod | |
| Cgui2::tdepcheck_confirm_change | |
| Cgui2::tdepcheck_select_new | |
| Cgui2::tdrop_down_list | Used by the combobox widget |
| Cgui2::tedit_label | |
| Cgui2::tedit_text | |
| Cgui2::teditor_edit_label | |
| Cgui2::teditor_edit_scenario | |
| Cgui2::teditor_edit_side | |
| Cgui2::teditor_generate_map | The dialog for selecting which random generator to use in the editor |
| Cgui2::teditor_new_map | |
| Cgui2::teditor_resize_map | |
| Cgui2::teditor_set_starting_position | |
| Cgui2::tfolder_create | |
| Cgui2::tformula_debugger | |
| Cgui2::tgame_cache_options | |
| Cgui2::tgame_delete | |
| Cgui2::tgame_load | |
| Cgui2::tgame_save | |
| Cgui2::tgame_save_message | |
| Cgui2::tgame_save_oos | |
| Cgui2::tgame_version | |
| Cgui2::tgamestate_inspector | |
| Cgui2::tlabel_settings | |
| Cgui2::tlanguage_selection | |
| Cgui2::tloadscreen | |
| Cgui2::tlobby_main | |
| Cgui2::tlobby_player_info | |
| Cgui2::tlogging | |
| Cgui2::tlua_interpreter | |
| Cgui2::tmessage | Main class to show messages to the user |
| Cgui2::tmp_alerts_options | |
| Cgui2::tmp_change_control | |
| Cgui2::tmp_cmd_wrapper | |
| Cgui2::tmp_connect | |
| Cgui2::tmp_create_game | |
| Cgui2::tmp_create_game_set_password | |
| Cgui2::tmp_host_game_prompt | |
| Cgui2::tmp_join_game_password_prompt | |
| Cgui2::tmp_login | |
| Cgui2::tmp_method_selection | |
| Cgui2::tnetwork_transmission | Dialog that tracks network transmissions |
| Cgui2::tpreferences | |
| Cgui2::tscreenshot_notification | |
| Cgui2::tselect_orb_colors | |
| Cgui2::tsimple_item_selector | |
| Cgui2::tsynced_choice_wait | |
| Cgui2::ttheme_list | |
| Cgui2::ttitle_screen | This class implements the title screen |
| Cgui2::ttransient_message | Shows a transient message |
| Cgui2::tunit_attack | |
| Cgui2::tunit_create | |
| Cgui2::tunit_recruit | |
| Cgui2::twml_error | WML preprocessor/parser error report dialog |
| ►Cgui2::twml_message_ | Base class for the wml generated messages |
| Cgui2::twml_message_left | Shows a dialog with the portrait on the left side |
| Cgui2::twml_message_right | Shows a dialog with the portrait on the right side |
| ►Cgui2::event::tdispatcher | Base class for event handling |
| Cgui2::twidget | Base class for all widgets |
| Cgui2::event::tdispatcher_implementation | |
| Cteam | This class stores all the data for a single 'side' (in game nomenclature) |
| Cteam_builder | |
| Cteam_data | |
| Cteam::team_info | |
| Cpathfind::teleport_group | |
| Cpathfind::teleport_map | |
| Cwb::temporary_unit_hider | |
| Ctemporary_unit_mover | This object is used to temporary move a unit in the unit map, swapping out any unit that is already there |
| Ctemporary_unit_placer | This object is used to temporary place a unit in the unit map, swapping out any unit that is already there |
| Ctemporary_unit_remover | This object is used to temporary remove a unit from the unit map |
| Cterrain_builder | The class terrain_builder is constructed from a config object, and a gamemap object |
| Cterrain_builder::terrain_constraint | The in-memory representation of a [tile] WML rule inside of a [terrain_graphics] WML rule |
| Cmovetype::terrain_defense | Stores a set of defense levels |
| Cterrain_filter::terrain_filter_cache | |
| Cterrain_filterimpl | |
| ►Cmovetype::terrain_info | Stores a set of data based on terrain |
| Cmovetype::terrain_costs | Stores a set of terrain costs (for movement, vision, or "jamming") |
| Cterrain_label | To store label data Class implements logic for rendering |
| Cterrain_type | |
| Cterrain_type_data | |
| ►Cgui2::tevent_executor | Event execution calls |
| Cgui2::twidget | Base class for all widgets |
| Cgui2::event::tevent_in_set | Helper class to do a runtime test whether an event is in a set |
| Cgui2::texecutor | Helper to make removing a timer in a callback safe |
| Ctexit | This exception when throw should terminate the application |
| Ctext_chunk | |
| ►Cgui2::tfield_ | Abstract base class for the fields |
| Cgui2::tfield< T, W, CT > | Template class to implement the generic field implementation |
| ►Cgui2::tfield< bool, tselectable_ > | |
| Cgui2::tfield_bool | Specialized field class for boolean |
| ►Cgui2::tfield< std::string, tcontrol, const std::string & > | |
| Cgui2::tfield_label | Specialized field class for a control, used for labels and images |
| ►Cgui2::tfield< std::string, ttext_, const std::string & > | |
| Cgui2::tfield_text | Specialized field class for text |
| Ctfilter | Contains the definition of a filter |
| Ctfilter_description | Helper structure to describe what a filter does |
| Cfloating_point_emulation::tfloat< T, S > | Template class for the emulation |
| Cfloating_point_emulation::detail::tfloor< T, S > | |
| Cfloating_point_emulation::detail::tfloor< double, S > | |
| Cfloating_point_emulation::detail::tfloor< Sint32, S > | |
| Cgui2::tformula< T > | Template class can hold a value or a formula to calculate the value |
| Cgui2::tformula< bool > | |
| Cgui2::tformula< unsigned > | |
| Cgui2::tgrid_implementation | Helper to implement private functions without modifying the header |
| Cgui2::tgroup< T > | |
| Cgui2::tgroup< ADDON_SORT > | |
| Cgui2::tgroup< ADDON_SORT_DIRECTION > | |
| Cgui2::tgroup< preferences::LOBBY_JOINS > | |
| Cgui2::tgroup< SCALING_ALGORITHM > | |
| Cgui2::tgroup< std::string > | |
| Cgui2::tgroup< team::CONTROLLER > | |
| Cgui2::tgroup< team::SHARE_VISION > | |
| Cgui2::tgroup< unit_race::GENDER > | |
| Cgui2::tgui_definition | |
| Cgui2::event::tdispatcher_implementation::thas_handler | A helper class to find out whether dispatcher has an handler for a certain event |
| Ctheme | |
| Ctheme_info | |
| Cthrow_end_level | |
| Cfloating_point_emulation::detail::tidiv< T, S > | |
| Cfloating_point_emulation::detail::tidiv< T, 8 > | |
| Cterrain_builder::tile | Represents a tile of the game map, with all associated builder-specific parameters: flags, images attached to this tile, etc |
| Ceditor::tile_info | This represents a tile along with information about it, namely the terrain, possibly other information |
| Cterrain_builder::tilemap | The map of "tile" structures corresponding to the level map |
| Ctime_of_day | Object which defines a time of day with associated bonuses, image, sounds etc |
| ►Cgui2::tinteger_selector_ | Small abstract helper class |
| Cgui2::tslider | A slider |
| Cgui2::twindow::tinvalidate_layout_blocker | Helper class to block invalidate_layout |
| Cgui2::tpane::titem | |
| Cgui2::tgenerator< minimum_selection, maximum_selection, placement, select_action >::titem | Definition of an item |
| Chelp::title_less | To be used as a function object when sorting topic lists on the title |
| CTKey | |
| Cgui2::tkey | Key type for the cache |
| ►Cgui2::tlayout_exception_resize_failed | Basic exception when the layout doesn't fit |
| Cgui2::tlayout_exception_height_resize_failed | Exception thrown when the height resizing has failed |
| Cgui2::tlayout_exception_width_resize_failed | Exception thrown when the width resizing has failed |
| Cgui2::tlayout_exception_width_modified | Exception thrown when the width has been modified during resizing |
| Cgui2::tlegacy_menu_item | Implements simple parsing of legacy GUI1 item markup |
| Ctest_throw::implementation::tlexical_cast< To, From, ToEnable, FromEnable > | Base class for the conversion |
| Cimplementation::tlexical_cast< To, From, ToEnable, FromEnable > | Base class for the conversion |
| Cimplementation::tlexical_cast< long long, From, void, typename boost::enable_if< boost::mpl::has_key< boost::mpl::set< char *, const char * >, From > >::type > | Specialized conversion class |
| Ctest_throw::implementation::tlexical_cast< long long, From, void, typename boost::enable_if< boost::mpl::has_key< boost::mpl::set< char *, const char * >, From > >::type > | Specialized conversion class |
| Cimplementation::tlexical_cast< long long, std::string > | Specialized conversion class |
| Ctest_throw::implementation::tlexical_cast< long long, std::string > | Specialized conversion class |
| Cimplementation::tlexical_cast< std::string, From, void, typename boost::enable_if< boost::is_integral< typename boost::remove_pointer< From >::type > >::type > | Specialized conversion class |
| Ctest_throw::implementation::tlexical_cast< std::string, From, void, typename boost::enable_if< boost::is_integral< typename boost::remove_pointer< From >::type > >::type > | Specialized conversion class |
| Cimplementation::tlexical_cast< To, From, typename boost::enable_if< boost::is_signed< To > >::type, typename boost::enable_if< boost::mpl::has_key< boost::mpl::set< char *, const char * >, From > >::type > | Specialized conversion class |
| Ctest_throw::implementation::tlexical_cast< To, From, typename boost::enable_if< boost::is_signed< To > >::type, typename boost::enable_if< boost::mpl::has_key< boost::mpl::set< char *, const char * >, From > >::type > | Specialized conversion class |
| Cimplementation::tlexical_cast< To, From, typename boost::enable_if< boost::is_unsigned< To > >::type, typename boost::enable_if< boost::mpl::has_key< boost::mpl::set< char *, const char * >, From > >::type > | Specialized conversion class |
| Ctest_throw::implementation::tlexical_cast< To, From, typename boost::enable_if< boost::is_unsigned< To > >::type, typename boost::enable_if< boost::mpl::has_key< boost::mpl::set< char *, const char * >, From > >::type > | Specialized conversion class |
| Ctest_throw::implementation::tlexical_cast< To, std::string, typename boost::enable_if< boost::is_signed< To > >::type > | Specialized conversion class |
| Cimplementation::tlexical_cast< To, std::string, typename boost::enable_if< boost::is_signed< To > >::type > | Specialized conversion class |
| Cimplementation::tlexical_cast< To, std::string, typename boost::enable_if< boost::is_unsigned< To > >::type > | Specialized conversion class |
| Ctest_throw::implementation::tlexical_cast< To, std::string, typename boost::enable_if< boost::is_unsigned< To > >::type > | Specialized conversion class |
| Ctest_throw::implementation::tlexical_cast< unsigned long long, From, void, typename boost::enable_if< boost::mpl::has_key< boost::mpl::set< char *, const char * >, From > >::type > | Specialized conversion class |
| Cimplementation::tlexical_cast< unsigned long long, From, void, typename boost::enable_if< boost::mpl::has_key< boost::mpl::set< char *, const char * >, From > >::type > | Specialized conversion class |
| Cimplementation::tlexical_cast< unsigned long long, std::string > | Specialized conversion class |
| Ctest_throw::implementation::tlexical_cast< unsigned long long, std::string > | Specialized conversion class |
| Cgui2::twindow_builder::tresolution::tlinked_group | |
| Cgui2::twindow::tlinked_size | Helper struct to force widgets the have the same size |
| Cgui2::tlobby_chat_window | |
| Cgui2::event::tlock | SDL_AddTimer() callback for the hover event |
| ►Ctlua_jailbreak_exception | Base class for exceptions that want to be thrown 'through' lua |
| CCVideo::quit | |
| Cgame::load_game_exception | Exception used to signal that the user has decided to abort a game, and to load another game instead |
| Cgui2::iterator::tlogic_error | Thrown when deferring an invalid iterator |
| Cgui2::iterator::trange_error | Thrown when moving an invalid iterator |
| Cimage::modification::texception | Exception thrown by the operator() when an error occurs |
| Cingame_wesnothd_error | We received invalid data from wesnothd during a game This means we cannot continue with the game but we can stay connected to wesnothd and start a new game TODO: find a short name |
| Cquit_game_exception | |
| Ctwml_exception | Helper class, don't construct this directly |
| Cwesnothd_connection_error | Error occured inside the underlying network comminication code (boost asio) TODO: find a short name |
| Cgui2::event::tmanager | |
| Ctmatrix< T, S, D > | Emulates a matrix |
| ►Cgui2::event::tmessage | The message callbacks hold a reference to a message |
| Cgui2::event::tmessage_show_helptip | The message for MESSAGE_SHOW_HELPTIP |
| Cgui2::event::tmessage_show_tooltip | The message for MESSAGE_SHOW_TOOLTIP |
| Cgui2::tmessage_implementation | Helper to implement private functions without modifying the header |
| ►Cgui2::event::tmouse_motion | |
| ►Cgui2::event::tmouse_button< sdl_button_down, sdl_button_up, button_down, button_up, button_click, button_double_click > | |
| Cgui2::event::tdistributor | The event handler class for the widget library |
| Cgui2::event::tdistributor | The event handler class for the widget library |
| Cgui2::event::tdistributor | The event handler class for the widget library |
| Cterrain_filterimpl::tno_filter | |
| Cterrain_filterimpl::tno_start_set_yet | |
| Cgui2::tnotifiee< FUNCTOR > | Helper class to implement callbacks with lifetime management |
| Cgui2::tnotifiee< tfunctor > | |
| Cgui2::tnotifier< FUNCTOR > | Helper class to implement callbacks with lifetime management |
| Cgui2::tnotifier< tfunctor > | |
| Ctod_color | Small struct to store and manipulate ToD colors |
| Ctod_manager | |
| CToken | |
| Cformula_tokenizer::token | |
| Ctoken | |
| Cpreprocessor_data::token_desc | Description of a preprocessing chunk |
| Cformula_tokenizer::token_error | |
| Ctokenizer | Abstract baseclass for the tokenizer |
| Chelp::topic | A topic contains a title, an id and some text |
| ►Chelp::topic_generator | Generate a topic text on the fly |
| Chelp::terrain_topic_generator | |
| Chelp::text_topic_generator | |
| Chelp::unit_topic_generator | |
| Chelp::topic_text | The text displayed in a topic |
| Cgui2::tpane_implementation | Helper to implement private functions without modifying the header |
| Ctfilter_description::tparameter | Describes a filter parameter |
| ►Cgui2::tplacer_ | Base class for the placement helper |
| Cgui2::implementation::tplacer_horizontal_list | The placement class for a horizontal list |
| Cgui2::implementation::tplacer_vertical_list | The placement class for a vertical list |
| Cgui2::tplayer_list | |
| Cgui2::tpoint | Holds a 2D point |
| ►Cgui2::tpopup | The popup class shows windows that are shown non-modal |
| Cgui2::tdebug_clock | Clock to test the draw events |
| Cgui2::ttip | The tips of day structure |
| Ctransient_end_level | The non-persistent part of end_level_data |
| Clg::tredirect_output_setter | Helper class to redirect the output of the logger in a certain scope |
| Ctregister_filter | Helper structure to register a filter to the filters |
| Cgui2::twindow_builder::tresolution | |
| Cconfig::attribute_value::true_false | A wrapper for bool to get the correct streaming ("true"/"false") |
| Cfloating_point_emulation::detail::tscale< T, S, E > | |
| Cfloating_point_emulation::detail::tscale< double, S, typename boost::enable_if_c< S!=0 >::type > | |
| Cfloating_point_emulation::detail::tscale< Sint32, S, typename boost::enable_if_c< S!=0 >::type > | |
| Cfloating_point_emulation::detail::tscale< T, 0 > | |
| Cgui2::tscrollbar_container_implementation | Helper to implement private functions without modifying the header |
| Ctsdl | |
| ►Cgui2::tselectable_ | Small abstract helper class |
| Cgui2::tcombobox | Simple push button |
| Cgui2::ttoggle_button | Class for a toggle button |
| Cgui2::ttoggle_panel | Class for a toggle button |
| Cgui2::event::tdispatcher::tsignal< T > | Helper struct to generate the various signal types |
| Cgui2::event::tdispatcher::tsignal< tsignal_function > | |
| Cgui2::event::tdispatcher::tsignal< tsignal_keyboard_function > | |
| Cgui2::event::tdispatcher::tsignal< tsignal_message_function > | |
| Cgui2::event::tdispatcher::tsignal< tsignal_mouse_function > | |
| Cgui2::event::tdispatcher::tsignal< tsignal_notification_function > | |
| Cgui2::event::tdispatcher::tsignal_queue< T > | Helper struct to generate the various event queues |
| Cgui2::event::tdispatcher::tsignal_queue< tsignal_function > | |
| Cgui2::event::tdispatcher::tsignal_queue< tsignal_keyboard_function > | |
| Cgui2::event::tdispatcher::tsignal_queue< tsignal_message_function > | |
| Cgui2::event::tdispatcher::tsignal_queue< tsignal_mouse_function > | |
| Cgui2::event::tdispatcher::tsignal_queue< tsignal_notification_function > | |
| ►Cgui2::iterator::policy::visit::tskip | This policy skips the current level |
| Cgui2::iterator::policy::tvisit< false, level > | Specialized to select the visit::tskip policy |
| Clocation_palette_item::tstate | |
| Cgui2::tstate_default | |
| Cgui2::tstate_definition | Contains the state info for a resolution |
| CTString | |
| Cgui2::tsub_player_list | |
| Cgui2::ttext_history | Class for text input history |
| Cttext_input | |
| Cttf_record | |
| Cgui2::tdebug_clock::ttime | Helper struct to keep track of the time |
| Cgui2::ttimer | |
| Cgui2::twindow_builder::tresolution::ttip | Helper struct to store information about the tips |
| Cgui2::implementation::ttree_node | |
| Cgui2::ttree_view_node_implementation | |
| Cgui2::event::ttrigger | Helper struct to wrap the functor call |
| Cgui2::event::ttrigger_keyboard | Helper struct to wrap the functor call |
| Cgui2::event::ttrigger_message | Helper struct to wrap the functor call |
| Cgui2::event::ttrigger_mouse | Helper struct to wrap the functor call |
| Cgui2::event::ttrigger_notification | Helper struct to wrap the functor call |
| Cgui2::tunit_test_access_only | Special helper class to get the list of registered windows |
| ►Ctuple | |
| Ctwo_strings | |
| Cturn_info | TODO: rename this class since it isn't that much related to turns |
| Cgui2::tvalue | Value type for the cache |
| Ctvector< T, S > | Emulates a vector |
| Cgui2::tviewport_implementation | Helper to implement private functions without modifying the header |
| Cgui2::iterator::policy::tvisit< bool, level > | Helper class to select to visit or skip a level |
| ►Cgui2::iterator::policy::visit::tvisit< level > | This policy tries to visit the current level |
| Cgui2::iterator::policy::tvisit< true, level > | Specialized to select the visit::tvisit policy |
| ►Cgui2::iterator::policy::tvisit< visit_child, twalker_::child > | |
| Cgui2::iterator::policy::order::tbottom_up< visit_widget, visit_grid, visit_child > | |
| Cgui2::iterator::policy::order::ttop_down< visit_widget, visit_grid, visit_child > | |
| ►Cgui2::iterator::policy::tvisit< visit_grid, twalker_::grid > | |
| Cgui2::iterator::policy::order::tbottom_up< visit_widget, visit_grid, visit_child > | |
| Cgui2::iterator::policy::order::ttop_down< visit_widget, visit_grid, visit_child > | |
| ►Cgui2::iterator::policy::tvisit< visit_widget, twalker_::widget > | |
| Cgui2::iterator::policy::order::tbottom_up< visit_widget, visit_grid, visit_child > | |
| Cgui2::iterator::policy::order::ttop_down< visit_widget, visit_grid, visit_child > | |
| ►Cgui2::iterator::twalker_ | The walker abstract base class |
| Cgui2::iterator::tgrid | A walker for a gui2::tgrid |
| Cgui2::iterator::walker::twidget | A walker for a gui2::tcontrol |
| Cgui2::twindow_builder | |
| Cgui2::twindow_builder_invalid_id | Helper struct to signal that get_window_builder failed |
| Cgui2::twindow_implementation | Helper to implement private functions without modifying the header |
| Cgui2::twml_message_option | Helper class for message options |
| CUdata | |
| ►Cunary_function | |
| ►Cgame_filter_base | |
| Cgame_filter_general_string_part | |
| Cgame_filter_not< T > | |
| ►Cgame_filter_stack | |
| Cgame_filter_and_stack | |
| Cgame_filter_value< T, member, OP > | |
| ►Cxy_pred | |
| Cterrain_filter | |
| Cactions::undo_event | |
| Cutil::unique_ptr< T > | |
| Cunit | |
| Cunit_ability_list | |
| Cai::unit_advancements_aspect | |
| Cunit_animation | |
| Cunit_animation_component | |
| Cunit_animator | |
| Cunit_creator | |
| Cunit_drawer | |
| Cunit_experience_accelerator | |
| Cunit_filter | |
| ►Cunit_filter_abstract_impl | |
| Cbasic_unit_filter_impl | The basic unit filter gives a generic implementation of the match fcn |
| Cnull_unit_filter_impl | Null unit filter is built when the input config is null |
| Cgame_logic::unit_formula_compare | |
| Cunit_formula_manager | |
| Cunit_frame | Describe a unit's animation sequence |
| Cn_unit::unit_id | |
| Cunit_map | Container associating units to locations |
| Cunit_map::unit_pod | The pointer to the unit and a reference counter to record the number of extant iterators pointing to this unit |
| Cunit_race | |
| Cunit_type | |
| Cupdate_locker | |
| Cunit::upkeep_full | |
| Cunit::upkeep_loyal | |
| CUpVal | |
| CUpvaldesc | |
| Csuh::user | |
| ►Cmp_sync::user_choice | Interface for querying local choices |
| Cpersist_choice | |
| Caddons_client::user_exit | |
| ►Cuser_handler | An interface class to handle nick registration To activate it put a [user_handler] section into the server configuration file |
| Cfuh | A user_handler implementation to link the server with a phpbb3 forum |
| Csuh | An example of how to implement user_handler |
| Cuser_info | This class represents the information a client has about another player |
| Cmp::ui::user_info | |
| Cuser_sorter_name | |
| Cuser_sorter_relation | |
| Cuser_sorter_relation_name | |
| Cucs4_convert_impl::utf16_impl | |
| Cucs4_convert_impl::utf32_impl | |
| Cucs4_convert_impl::utf8_impl | |
| CValue | |
| Cimage::locator::value | |
| CVardesc | |
| Cwb::variable_finalizer< T > | Finalizer class to help with exception safety sets variable to value on destruction |
| ►Cvariable_info< vit > | |
| Cnon_const_variable_info< vit > | Extends variable_info with methods that can only be applied if vit != vit_const |
| Cvariable_info_detail::variable_info_state< vit > | |
| ►Cvariable_set | |
| Cgame_data | |
| Cutils::string_map_variable_set | |
| Cvariant | |
| Cvariant_iterator | Iterator class for the variant |
| Cvariant_list | |
| Cvariant_map | |
| Cvariant_string | |
| Cai::variant_value_translator< T > | |
| Cai::variant_value_translator< attacks_vector > | |
| Cai::variant_value_translator< bool > | |
| Cai::variant_value_translator< int > | |
| Cai::variant_value_translator< std::string > | |
| Cai::variant_value_translator< terrain_filter > | |
| Cvconfig | A variable-expanding proxy for the config class |
| ►Cstd::vector< T > | STL class |
| Cpathfind::paths::dest_vect | Ordered vector of possible destinations |
| Cversion_info | Represents version numbers |
| Cgui2::tlua_interpreter::view | |
| Cgui2::tmp_change_control::view | The view is an interface that displays data (the model) and routes user commands to the controller to act upon that data |
| Cgui2::tchat_log::view | |
| Cgui2::tgamestate_inspector::view | |
| Chelp::help_menu::visible_item | Information about an item that is visible in the menu |
| ►Cwb::visitor | Abstract base class for all the visitors (cf GoF Visitor Design Pattern) the whiteboard uses |
| Cwb::highlighter::highlight_main_visitor | |
| Cwb::highlighter::highlight_secondary_visitor | |
| Cwb::highlighter::unhighlight_visitor | |
| Cvoid_value< T > | |
| ►Cthreading::waiter | |
| Cconnect_aborter | |
| Ct_string_base::walker | |
| Cwesnoth_global_fixture | |
| Cwindows_tray_notification | |
| Cgame_events::wmi_container | A container of wml_menu_item |
| Cwmi_pager | |
| Cgame_events::wml_action | |
| Cgame_events::wml_menu_item | |
| Cconfig::attribute_value::yes_no | A wrapper for bool to get the correct streaming ("yes"/"no") |
| CZio | |
| ►Cstreambuf | |
| Cpreprocessor_streambuf | Target for sending preprocessed output |
1.8.8