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));
}
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));
}
awl::backends::windows::window::event::return_type
sge::dinput::processor::on_focus_out(
awl::backends::windows::window::event::object const &
)
{
FCPPT_LOG_DEBUG(
log_,
fcppt::log::_
<< FCPPT_TEXT("DirectInput: focus out")
);
has_focus_ =
sge::dinput::has_focus(
false
);
this->for_each_device(
std::bind(
&sge::dinput::device::object::unacquire,
std::placeholders::_1
)
);
return
awl::backends::windows::window::event::return_type();
}
void
sanguis::client::config::settings::object::save() const
{
FCPPT_LOG_DEBUG(
log_,
fcppt::log::_
<< FCPPT_TEXT("Trying to save settings to ")
<< fcppt::filesystem::path_to_string(
path_
)
);
if(
!sge::parse::ini::output::to_file(
path_,
start_
)
)
{
FCPPT_LOG_ERROR(
log_,
fcppt::log::_
<< FCPPT_TEXT("Writing the settings failed!")
);
}
}
void
gitbot::irc::client::commit_write_buffer()
{
if (!active_write_buffer_.empty() || passive_write_buffer_.empty())
return;
FCPPT_LOG_DEBUG(
mylogger,
fcppt::log::_
<< FCPPT_TEXT("-> ")
<< passive_write_buffer_
<< FCPPT_TEXT(" (")
<< passive_write_buffer_.size()
<< FCPPT_TEXT(" bytes)"));
active_write_buffer_.swap(
passive_write_buffer_);
boost::asio::async_write(
socket_,
boost::asio::buffer(
active_write_buffer_),
boost::bind(
&client::handle_write,
this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
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")
);
}
void
gitbot::irc::client::handle_timeout(
boost::system::error_code const &_e)
{
if (_e)
{
dead_ = true;
return;
}
fcppt::chrono::seconds::rep elapsed_time =
fcppt::chrono::duration_cast<fcppt::chrono::seconds>(
clock::now() - last_reception_).count();
FCPPT_LOG_DEBUG(
mylogger,
fcppt::log::_
<< FCPPT_TEXT("Got a timeout, time since last reception: ")
<< elapsed_time);
if (elapsed_time >= static_cast<fcppt::chrono::seconds::rep>(timeout_))
{
FCPPT_LOG_DEBUG(
mylogger,
fcppt::log::_
<< FCPPT_TEXT("Client is dead now"));
dead_ = true;
return;
}
FCPPT_LOG_DEBUG(
mylogger,
fcppt::log::_
<< FCPPT_TEXT("Client isn't dead yet, restarting timer"));
timer_.reset(
new boost::asio::deadline_timer(
timer_->get_io_service()));
timer_->expires_from_now(
boost::posix_time::seconds(
timeout_));
timer_->async_wait(
boost::bind(
&client::handle_timeout,
this,
boost::asio::placeholders::error));
}
sanguis::client::states::has_player::has_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("has_player")
}
)
},
action_handler_(
fcppt::make_unique_ptr<
sanguis::client::control::action_handler
>(
sanguis::client::make_send_callback(
this->context<
sanguis::client::machine
>()
),
this->context<
sanguis::client::states::running
>().control_environment(),
this->context<
sanguis::client::states::running
>().console().sge_console()
)
),
perk_state_(
fcppt::make_unique_ptr<
sanguis::client::perk::state
>(
sanguis::client::perk::send_callback{
std::bind(
&sanguis::client::states::has_player::send_perk_choose,
this,
std::placeholders::_1
)
}
)
)
{
FCPPT_LOG_DEBUG(
log_,
fcppt::log::_
<< FCPPT_TEXT("Entering has_player")
);
}
gitbot::irc::client::client(
boost::asio::io_service &_io_service,
timeout const &_timeout,
network const &_network,
port const &_port,
nick const &_nick,
user const &_user,
channel_sequence const &_channels)
:
socket_(
_io_service),
resolver_(
_io_service),
response_(),
timeout_(
_timeout),
timer_(
new boost::asio::deadline_timer(
_io_service)),
last_reception_(
clock::now()),
dead_(
false),
active_write_buffer_(),
passive_write_buffer_(),
nick_(
_nick),
user_(
_user),
channels_(
_channels)
{
boost::asio::ip::tcp::resolver::query q(
_network,
fcppt::lexical_cast<std::string>(
_port));
FCPPT_LOG_DEBUG(
mylogger,
fcppt::log::_ << FCPPT_TEXT("Beginning async_resolve..."));
resolver_.async_resolve(
q,
boost::bind(
&client::handle_resolve,
this,
boost::asio::placeholders::error,
boost::asio::placeholders::iterator));
}
int
main()
{
//! [logger_declaration]
fcppt::log::object logger(
fcppt::log::parameters::object()
.level_defaults(
fcppt::io::cout(),
fcppt::log::level::debug
)
.enabled(
true
)
// Create a special formatter for the whole logger
.formatter(
logger_formatter
)
// Create a special sink for the error log level that prints to
// cerr and also has a special formatter.
.level_stream(
fcppt::log::level::error,
fcppt::log::level_stream(
fcppt::io::cerr(),
error_formatter
)
)
);
//! [logger_declaration]
//! [log_print]
// Prints:
// 'This is a formatting test: debug: test'
// to cout.
FCPPT_LOG_DEBUG(
logger,
fcppt::log::_
<< FCPPT_TEXT("test")
);
// Prints:
// 'This is a formatting test: Horrible error, please fix: some error'
// to cerr.
FCPPT_LOG_ERROR(
logger,
fcppt::log::_
<< FCPPT_TEXT("some error")
);
//! [log_print]
}
void
alda::net::client::detail::object_impl::connect(
alda::net::host const &_host,
alda::net::port const _port
)
{
FCPPT_LOG_DEBUG(
log_,
fcppt::log::_
<< FCPPT_TEXT("resolving hostname ")
<< fcppt::from_std_string(
_host.get()
)
<< FCPPT_TEXT(" on port ")
<< _port
);
query_unique_ptr query(
fcppt::make_unique_ptr<
boost::asio::ip::tcp::resolver::query
>(
boost::asio::ip::tcp::v4(),
_host.get(),
fcppt::insert_to_std_string(
_port
)
)
);
// TODO: We should move the query through this function but
// asio makes it extremely difficult
resolver_.async_resolve(
*query,
std::bind(
&object_impl::resolve_handler,
this,
std::placeholders::_1,
std::placeholders::_2
)
);
query_ =
optional_query_unique_ptr(
std::move(
query
)
);
}
sge::evdev::device::optional_fd_unique_ptr
sge::evdev::device::create_fd(
fcppt::log::object &_log,
boost::filesystem::path const &_path
)
{
sge::evdev::device::fd_unique_ptr ret(
fcppt::make_unique_ptr<
sge::evdev::device::fd
>(
_path
)
);
if(
ret->valid()
)
return
sge::evdev::device::optional_fd_unique_ptr{
std::move(
ret
)
};
// Failure for some evdev files is expected.
FCPPT_LOG_DEBUG(
_log,
fcppt::log::_
<<
FCPPT_TEXT("Opening \"")
<<
fcppt::filesystem::path_to_string(
_path
)
<<
FCPPT_TEXT("\" failed: ")
<<
fcppt::error::strerrno()
);
return
sge::evdev::device::optional_fd_unique_ptr();
}
void
gitbot::irc::client::handle_read_line(
boost::system::error_code const &_e)
{
if (_e)
{
dead_ = true;
return;
}
std::istream s(
&response_);
std::string line;
std::getline(
s,
line,
'\n');
line.erase(
--line.end());
FCPPT_LOG_DEBUG(
mylogger,
fcppt::log::_
<< FCPPT_TEXT("<- ")
<< line);
last_reception_ =
clock::now();
process_line(
line);
boost::asio::async_read_until(
socket_,
response_,
"\r\n",
boost::bind(
&client::handle_read_line,
this,
boost::asio::placeholders::error));
}
void
gitbot::irc::client::handle_write(
boost::system::error_code const &_e,
std::size_t const _bytes_transferred)
{
if (_e)
{
dead_ = true;
return;
}
FCPPT_LOG_DEBUG(
mylogger,
fcppt::log::_
<< FCPPT_TEXT("Wrote ")
<< _bytes_transferred
<< FCPPT_TEXT(" bytes."));
active_write_buffer_.clear();
commit_write_buffer();
}
void
gitbot::irc::client::handle_resolve(
boost::system::error_code const &_e,
boost::asio::ip::tcp::resolver::iterator const _it)
{
GITBOT_IRC_CLIENT_HANDLE_ERROR(
_e,
"handle_resolve");
FCPPT_LOG_DEBUG(
mylogger,
fcppt::log::_ << FCPPT_TEXT("In handle_resolve, beginning async_connect..."));
socket_.async_connect(
*_it,
boost::bind(
&client::handle_connect,
this,
boost::asio::placeholders::error,
boost::next(
_it)));
}
void
alda::net::client::detail::object_impl::resolve_handler(
boost::system::error_code const &_error,
boost::asio::ip::tcp::resolver::iterator _iterator
)
{
if(
_error
)
{
this->handle_error(
FCPPT_TEXT("resolving address: "),
_error
);
return;
}
FCPPT_LOG_DEBUG(
log_,
fcppt::log::_
<< FCPPT_TEXT("resolved domain, trying to connect")
);
boost::asio::ip::tcp::endpoint const endpoint(
*_iterator
);
socket_.async_connect(
endpoint,
std::bind(
&object_impl::connect_handler,
this,
std::placeholders::_1,
++_iterator
)
);
}
void
alda::net::client::detail::object_impl::connect_handler(
boost::system::error_code const &_error,
boost::asio::ip::tcp::resolver::iterator _iterator
)
{
if(
_error
)
{
FCPPT_PP_PUSH_WARNING
#if defined(FCPPT_CONFIG_GNU_GCC_COMPILER)
FCPPT_PP_DISABLE_GCC_WARNING(-Wzero-as-null-pointer-constant)
#endif
// are we at the end of the endpoint list?
if(
_iterator == boost::asio::ip::tcp::resolver::iterator()
||
_error == boost::asio::error::operation_aborted
)
{
this->handle_error(
FCPPT_TEXT("exhausted endpoints or connection aborted: "),
_error
);
return;
}
FCPPT_PP_POP_WARNING
FCPPT_LOG_DEBUG(
log_,
fcppt::log::_
<< FCPPT_TEXT("resolving next endpoint")
);
boost::asio::ip::tcp::endpoint const endpoint(
*_iterator
);
socket_.async_connect(
endpoint,
std::bind(
&object_impl::connect_handler,
this,
std::placeholders::_1,
++_iterator
)
);
return;
}
FCPPT_LOG_DEBUG(
log_,
fcppt::log::_
<< FCPPT_TEXT("connected")
);
connect_signal_();
this->receive_data();
}
sanguis::client::config::settings::object::object(
fcppt::log::context &_log_context,
boost::filesystem::path const &_path
)
:
log_{
_log_context,
sanguis::client::config::log_location(),
sanguis::log_parameters(
fcppt::log::name{
FCPPT_TEXT("settings")
}
)
},
path_(
_path
),
start_()
{
FCPPT_LOG_DEBUG(
log_,
fcppt::log::_
<< FCPPT_TEXT("Trying to load settings from ")
<< fcppt::filesystem::path_to_string(
_path
)
);
try
{
// TODO: Direct initialization
if(
sge::parse::ini::parse_file(
path_,
start_
).result_code()
!=
sge::parse::result_code::ok
)
{
start_.sections.clear();
FCPPT_LOG_INFO(
log_,
fcppt::log::_
<< FCPPT_TEXT("Loading the settings failed!")
);
}
}
catch(
sge::parse::exception const &_error
)
{
FCPPT_LOG_INFO(
log_,
fcppt::log::_
<< FCPPT_TEXT("Loading the settings failed with: ")
<< _error.string()
);
}
}
sge::media::detail::muxer<
System,
File
>::muxer(
parameters const &_parameters
)
:
log_{
_parameters.log_context(),
sge::log::location(),
sge::log::default_parameters(
sge::media::impl::log_name()
)
},
plugins_(
fcppt::algorithm::map_optional<
plugin_system_pair_container
>(
_parameters.collection(),
[
this,
&_parameters
](
sge::plugin::context<
System
> const &_context
)
{
plugin_type plugin(
_context.load()
);
system_unique_ptr system_instance(
plugin.get()(
_parameters.log_context()
)
);
typedef
fcppt::optional::object<
plugin_system_pair
>
optional_plugin_system_pair;
optional_plugin_system_pair result(
fcppt::optional::maybe(
_parameters.extensions(),
fcppt::const_(
true
),
[
&system_instance
](
sge::media::extension_set const &_extensions
)
{
return
!fcppt::algorithm::set_intersection(
_extensions,
system_instance->extensions()
).empty();
}
)
?
optional_plugin_system_pair(
std::make_pair(
std::move(
plugin
),
std::move(
system_instance
)
)
)
:
optional_plugin_system_pair()
);
if(
!result.has_value()
)
FCPPT_LOG_DEBUG(
log_,
fcppt::log::_
<< FCPPT_TEXT("System ")
<< fcppt::type_name_from_info(
typeid(
system
)
)
<< FCPPT_TEXT(" didn't find plugin ")
<< fcppt::filesystem::path_to_string(
_context.path()
)
<< FCPPT_TEXT(" to be useful.")
);
return
result;
}
)
),
extensions_(
fcppt::algorithm::fold(
plugins_,
sge::media::extension_set(),
[](
plugin_system_pair const &_plugin,
sge::media::extension_set const &_state
)
{
return
fcppt::algorithm::set_union(
_plugin.second->extensions(),
_state
);
}
)
)
{
}
sge::projectile::shape::detail::scalar_container
sge::projectile::impl::shape::triangle_scalars(
fcppt::log::object &_log,
sge::projectile::shape::triangle_sequence const &_triangles
)
{
sge::projectile::shape::detail::scalar_container scalars(
_triangles.size() * 8u * 3u * 3u
);
FCPPT_LOG_DEBUG(
_log,
fcppt::log::_
<< FCPPT_TEXT("constructing triangle mesh with ")
<< _triangles.size()
<< FCPPT_TEXT(" triangles"));
sge::projectile::shape::detail::scalar_container::iterator current_scalar =
scalars.begin();
// TODO: Find a better way to express this
for(
sge::projectile::triangle const &triangle
:
_triangles
)
{
typedef std::array<
btScalar,
2
> extrusion_array;
extrusion_array const extrusion_depth{{
static_cast<btScalar>(-sge::projectile::impl::object_extrusion_depth()/2),
static_cast<btScalar>(sge::projectile::impl::object_extrusion_depth()/2)
}};
for(
btScalar const current_z
:
extrusion_depth
)
{
FCPPT_LOG_VERBOSE(
_log,
fcppt::log::_
<< FCPPT_TEXT("triangle begin"));
for(
auto const ¤t_triangle_point
:
triangle
)
{
FCPPT_LOG_VERBOSE(
_log,
fcppt::log::_
<< FCPPT_TEXT("adding point ")
<< current_triangle_point[0]
<< FCPPT_TEXT(',')
<< current_triangle_point[1]
<< FCPPT_TEXT(',')
<< current_z);
*current_scalar++ = current_triangle_point[0];
*current_scalar++ = current_triangle_point[1];
*current_scalar++ = current_z;
}
FCPPT_LOG_VERBOSE(
_log,
fcppt::log::_
<< FCPPT_TEXT("triangle end"));
}
}
return
scalars;
}
