C++ FCPPT_TEXT函数代码示例

sanguis::client::states::waiting_for_player::waiting_for_player(
    my_context _ctx
)
    :
    my_base(
       _ctx
    ),
    log_{
    this->context<
    sanguis::client::machine
    >().log_context(),
    sanguis::client::states::log_location(),
    sanguis::log_parameters(
    fcppt::log::name{
        FCPPT_TEXT("waiting_for_player")
    }
    )
}
{
    FCPPT_LOG_DEBUG(
        log_,
        fcppt::log::_
        << FCPPT_TEXT("Entering waiting_for_player")
    );
}

boost::filesystem::path
sanguis::load::model::make_path(
	sanguis::load::model::path const &_path
)
{
	boost::filesystem::path const path(
		sanguis::media_path()
		/
		FCPPT_TEXT("models")
		/
		_path.get()
	);

	if(
		!boost::filesystem::exists(
			path
		)
	)
		throw
			sanguis::exception{
				FCPPT_TEXT("Model ")
				+
				fcppt::filesystem::path_to_string(
					_path.get()
				)
				+
				FCPPT_TEXT(" not found!")
			};

	return
		path;
}

sanguis::aura_type
sanguis::client::load::auras::lookup_name(
	fcppt::string const &_name
)
{
	return
		fcppt::optional::to_exception(
			fcppt::enum_::index_of_array(
				aura_types,
				_name
			),
			[
				&_name
			]{
				return
					sanguis::exception{
						FCPPT_TEXT("auras::lookup_name ")
						+
						_name
						+
						FCPPT_TEXT(" failed!")
					};
			}
		);
}

void
gitbot::irc::client::process_line(
	std::string const &_s)
{
	if(
		!is_prefix(
			"PING :",
			_s))
	{
		FCPPT_LOG_DEBUG(
			mylogger,
			fcppt::log::_ 
				<< FCPPT_TEXT("Got a line, but it's not a ping, so doing nothing."));
		return;
	}

	FCPPT_LOG_DEBUG(
		mylogger,
		fcppt::log::_ 
			<< FCPPT_TEXT("Got a ping, sending back pong with: ")
			<< _s.substr(6));
			
	write(
		"PONG :"+
		_s.substr(
			6));
}

inline
fcppt::cast::bad_dynamic::bad_dynamic(
	std::type_index const &_source,
	std::type_index const &_destination
)
:
	fcppt::exception(
		FCPPT_TEXT("Invalid dynamic_cast from type \"")
		+
		fcppt::type_name_from_index(
			_source
		)
		+
		FCPPT_TEXT("\" to type \"")
		+
		fcppt::type_name_from_index(
			_destination
		)
		+
		FCPPT_TEXT('"')
	),
	source_(
		_source
	),
	destination_(
		_destination
	)
{
}

fruitapp::fruit::material::object const
fruitapp::fruit::material::from_json(
	sge::parse::json::object const &o)
{
	return
		material::object(
			material::diffuse_color(
				sge::parse::json::find_and_convert_member<material::diffuse_color::value_type>(
					o,
					sge::parse::json::path(
						FCPPT_TEXT("diffuse-color")))),
			material::diffuse_coefficient(
				sge::parse::json::find_and_convert_member<material::diffuse_coefficient::value_type>(
					o,
					sge::parse::json::path(
						FCPPT_TEXT("diffuse-coefficient")))),
			material::specular_color(
				sge::parse::json::find_and_convert_member<material::diffuse_color::value_type>(
					o,
					sge::parse::json::path(
						FCPPT_TEXT("specular-color")))),
			material::specular_coefficient(
				sge::parse::json::find_and_convert_member<material::specular_coefficient::value_type>(
					o,
					sge::parse::json::path(
						FCPPT_TEXT("specular-coefficient")))),
			material::specular_shininess(
				sge::parse::json::find_and_convert_member<material::specular_shininess::value_type>(
					o,
					sge::parse::json::path(
						FCPPT_TEXT("specular-shininess")))));
}

int main()
{
	fcppt::io::cout()
		<< FCPPT_TEXT("Current version is ")
		<< fcppt::version_string()
		<< FCPPT_TEXT('\n');
}

fcppt::string
sanguis::server::entities::enemies::pretty_name(
		sanguis::creator::enemy_type const _type
){
	switch(
			_type
		  )
	{
		case sanguis::creator::enemy_type::wolf_black:
			 return FCPPT_TEXT("Black Wolf");
		case sanguis::creator::enemy_type::wolf_brown:
			 return FCPPT_TEXT("Brown Wolf");
		case sanguis::creator::enemy_type::wolf_white:
			 return FCPPT_TEXT("White Wolf");
		case sanguis::creator::enemy_type::zombie00:
			 return FCPPT_TEXT("Shambler");
		case sanguis::creator::enemy_type::zombie01:
			 return FCPPT_TEXT("Runner");
		case sanguis::creator::enemy_type::spider:
			 return FCPPT_TEXT("Wasp Spider");
		case sanguis::creator::enemy_type::skeleton:
			 return FCPPT_TEXT("Skeleton");
		case sanguis::creator::enemy_type::ghost:
			 return FCPPT_TEXT("Ghost");
		case sanguis::creator::enemy_type::maggot:
			 return FCPPT_TEXT("Maggot");
		case sanguis::creator::enemy_type::reaper:
			 return FCPPT_TEXT("Grim Reaper");
	}
	FCPPT_ASSERT_UNREACHABLE;
}

awl::main::exit_code const
sgeroids::main(
	awl::main::function_context const &_main_function_context)
try
{
	sgeroids::state_machine::object machine(
		_main_function_context.argc(),
		_main_function_context.argv());

	fcppt::scoped_state_machine<sgeroids::state_machine::object> const scoped_machine(
		machine);

	return
		machine.run();
}
catch(
	fcppt::exception const &e)
{
	fcppt::io::cerr()
		<< FCPPT_TEXT("fcppt::exception: ")
		<< e.string()
		<< FCPPT_TEXT("\n");
	return awl::main::exit_failure();
}
catch(
	std::exception const &e)
{
	std::cerr
		<< "std::exception: "
		<< e.what()
		<< "\n";

	return awl::main::exit_failure();
}

inline
fcppt::cast::bad_truncation_check::bad_truncation_check(
	fcppt::string const &_source_value,
	std::type_index const &_source,
	std::type_index const &_destination
)
:
	fcppt::exception(
		FCPPT_TEXT("Invalid truncation_check_cast from ")
		+
		_source_value
		+
		FCPPT_TEXT(" of type \"")
		+
		fcppt::type_name_from_index(
			_source
		)
		+
		FCPPT_TEXT("\" to type \"")
		+
		fcppt::type_name_from_index(
			_destination
		)
		+
		FCPPT_TEXT('"')
	),
	source_(
		_source
	),
	destination_(
		_destination
	)
{
}

boost::statechart::result
insula::states::finished::react(
	events::render const &r)
{
	context<game_outer>().react(
		r);

	context<game_inner>().react(
		r);

	fcppt::string const s = 
		context<game_outer>().players_left()
		?
			FCPPT_TEXT("Press enter for next player")
		:
			FCPPT_TEXT("Press enter for the score board");

	sge::font::draw_text(
		context<game_outer>().large_font(),
		context<game_outer>().font_drawer(),
		FCPPT_TEXT("Great job!\n")+s,
		sge::font::pos::null(),
		fcppt::math::dim::structure_cast<sge::font::dim>(
			context<machine>().systems().renderer()->screen_size()),
		sge::font::align_h::center,
		sge::font::align_v::center,
		sge::font::flags::none);

	return discard_event();
}

fcppt::string
sanguis::tiles::impl::orientation_to_string(
	sanguis::tiles::orientation const _orientation
)
{
	return
		fcppt::algorithm::map<
			fcppt::string
		>(
			fcppt::enum_::make_range<
				sanguis::tiles::direction
			>(),
			[
				_orientation
			](
				sanguis::tiles::direction const _dir
			)
			{
				return
					_orientation[
						_dir
					]
					?
						FCPPT_TEXT('1')
					:
						FCPPT_TEXT('0')
					;
			}
		);
}

awl::main::exit_code const
fruitapp::main(
	awl::main::function_context const &_main_function_context)
try
{
	fruitlib::signal_stack_printer::object stack_printer;

	fruitapp::machine machine(
		_main_function_context.argc(),
		_main_function_context.argv());

	fcppt::scoped_state_machine<fruitapp::machine> scoped_state_machine(
		machine);

	return
		machine.run();
}
catch (fcppt::exception const &e)
{
	fruitlib::message_box(
		FCPPT_TEXT("fcppt::exception: ")+
		e.string());
	return awl::main::exit_failure();
}
catch (std::exception const &e)
{
	fruitlib::message_box(
		FCPPT_TEXT("std::exception: ")+
		fcppt::from_std_string(
			e.what()));
	return awl::main::exit_failure();
}

insula::physics::debug_drawer::debug_drawer(
	world &_world,
	sge::renderer::device_ptr const _renderer,
	graphics::camera::object &_camera)
:
	world_(
		_world),
	renderer_(
		_renderer),
	camera_(
		_camera),
	shader_(
		renderer_,
		media_path()/FCPPT_TEXT("debug_vertex.glsl"),
		media_path()/FCPPT_TEXT("debug_fragment.glsl"),
		graphics::shader::vf_to_string<vertex_format>(),
		{
			graphics::shader::variable(
				"mvp",
				graphics::shader::variable_type::uniform,
				graphics::mat4())
		},
		graphics::shader::sampler_sequence()),
	debug_mode_(
		btIDebugDraw::DBG_NoDebug) // should be zero
{
	world_.handle().setDebugDrawer(
		this);
}

void
gitbot::irc::client::handle_connect(
	boost::system::error_code const &_e,
	boost::asio::ip::tcp::resolver::iterator const _it)
{
	if (_e)
	{
		FCPPT_ASSERT_MESSAGE(
			_it == boost::asio::ip::tcp::resolver::iterator(),
			FCPPT_TEXT("Tried every endpoint and couldn't connect to any of them"));
			
		FCPPT_LOG_DEBUG(
			mylogger,
			fcppt::log::_ << FCPPT_TEXT("Tried endpoint, now starting another one..."));
	
		socket_.close();
		socket_.async_connect(
			*_it,
			boost::bind(
				&client::handle_connect,
					this,
					boost::asio::placeholders::error,
					boost::next(
						_it)));
		return;
	}
	
	FCPPT_LOG_DEBUG(
		mylogger,
		fcppt::log::_ << FCPPT_TEXT("In handle_connect, which was successful..."));
	
	passive_write_buffer_ += "NICK "+nick_+"\r\n";
	passive_write_buffer_ += "USER "+nick_+" 0 * :"+user_+"\r\n";
	BOOST_FOREACH(channel const &c,channels_)
		passive_write_buffer_ += "JOIN "+c+"\r\n";
		
	commit_write_buffer();
	
	timer_->expires_from_now(
		boost::posix_time::seconds(
			timeout_));
			
	last_reception_ = 
		clock::now();
	timer_->async_wait(
		boost::bind(
			&client::handle_timeout,
			this,
			boost::asio::placeholders::error));
	
	boost::asio::async_read_until(
		socket_,
		response_,
		"\r\n",
		boost::bind(
			&client::handle_read_line,
			this,
			boost::asio::placeholders::error));
}