eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-21 12:29:18 +02:00
Code Issues 123 Wiki Activity

reformat: use auto on certain types

Browse Source
This commit is contained in:
jerrrrycho
2026-07-04 05:22:52 +02:00
parent f61068ff89
commit 20e7a99516
118 changed files with 2118 additions and 2063 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
network/backend/asio.cpp
View File

@@ -52,13 +52,13 @@ void network::tcp::connection::handle_header(const asio::error_code &err, size_t
return;
}
uint32_t sig = sn_utils::ld_uint32(header);
const uint32_t sig = sn_utils::ld_uint32(header);
if (sig != NETWORK_MAGIC) {
disconnect();
return;
}
uint32_t len = sn_utils::ld_uint32(header);
const uint32_t len = sn_utils::ld_uint32(header);
m_body_buffer.resize(len);
if (len > MAX_MSG_SIZE) {
disconnect();
@@ -82,7 +82,7 @@ void network::tcp::connection::handle_data(const asio::error_code &err, size_t b
}
std::istringstream stream(m_body_buffer);
std::shared_ptr<message> msg = deserialize_message(stream);
const std::shared_ptr<message> msg = deserialize_message(stream);
if (message_handler)
message_handler(*msg);
@@ -91,14 +91,14 @@ void network::tcp::connection::handle_data(const asio::error_code &err, size_t b
void network::tcp::connection::write_message(const message &msg, std::ostream &stream)
{
size_t beg = (size_t)stream.tellp();
const size_t beg = (size_t)stream.tellp();
sn_utils::ls_uint32(stream, NETWORK_MAGIC);
sn_utils::ls_uint32(stream, 0);
serialize_message(msg, stream);
size_t size = (size_t)stream.tellp() - beg - 8;
const size_t size = (size_t)stream.tellp() - beg - 8;
if (size > MAX_MSG_SIZE) {
ErrorLog("net: message too big", logtype::net);
return;
@@ -136,7 +136,7 @@ void network::tcp::connection::send_message(const message &msg)
network::tcp::server::server(std::shared_ptr<std::istream> buf, asio::io_context &io_ctx, const std::string &host, uint32_t port)
: network::server(buf), m_acceptor(io_ctx), m_io_ctx(io_ctx)
{
auto endpoint = asio::ip::tcp::endpoint(asio::ip::make_address(host), port);
const auto endpoint = asio::ip::tcp::endpoint(asio::ip::make_address(host), port);
m_acceptor.open(endpoint.protocol());
m_acceptor.set_option(asio::socket_base::reuse_address(true));
m_acceptor.set_option(asio::ip::tcp::no_delay(true));
@@ -185,7 +185,7 @@ void network::tcp::client::connect()
auto conn = std::make_shared<connection>(io_ctx, true, resume_frame_counter);
conn->set_handler(std::bind(&client::handle_message, this, conn, std::placeholders::_1));
asio::ip::tcp::endpoint endpoint(
const asio::ip::tcp::endpoint endpoint(
asio::ip::make_address(host), port);
conn->m_socket.open(endpoint.protocol());
conn->m_socket.set_option(asio::ip::tcp::no_delay(true));

10
network/manager.cpp
View File

@@ -21,7 +21,7 @@ command_queue::commands_map network::server_manager::pop_commands()
{
command_queue::commands_map map;
for (auto srv : servers)
for (const auto srv : servers)
add_to_dequemap(map, srv->pop_commands());
return map;
@@ -38,7 +38,7 @@ void network::server_manager::push_delta(double render_dt, double dt, double syn
msg.sync = sync;
msg.commands = commands;
for (auto srv : servers)
for (const auto srv : servers)
srv->push_delta(msg);
serialize_message(msg, *backbuffer.get());
@@ -46,7 +46,7 @@ void network::server_manager::push_delta(double render_dt, double dt, double syn
void network::server_manager::create_server(const std::string &backend, const std::string &conf)
{
auto it = backend_list().find(backend);
const auto it = backend_list().find(backend);
if (it == backend_list().end()) {
ErrorLog("net: unknown backend: " + backend);
return;
@@ -61,7 +61,7 @@ network::manager::manager()
void network::manager::update()
{
for (auto &backend : backend_list())
for (const auto &backend : backend_list())
backend.second->update();
if (client)
@@ -76,7 +76,7 @@ void network::manager::create_server(const std::string &backend, const std::stri
void network::manager::connect(const std::string &backend, const std::string &conf)
{
auto it = backend_list().find(backend);
const auto it = backend_list().find(backend);
if (it == backend_list().end()) {
ErrorLog("net: unknown backend: " + backend);
return;

6
network/message.cpp
View File

@@ -55,11 +55,11 @@ void ::network::request_command::serialize(std::ostream &stream) const
void network::request_command::deserialize(std::istream &stream)
{
uint32_t commands_size = sn_utils::ld_uint32(stream);
const uint32_t commands_size = sn_utils::ld_uint32(stream);
for (uint32_t i = 0; i < commands_size; i++)
{
uint32_t recipient = sn_utils::ld_uint32(stream);
uint32_t sequence_size = sn_utils::ld_uint32(stream);
const uint32_t sequence_size = sn_utils::ld_uint32(stream);
command_queue::commanddata_sequence sequence;
for (uint32_t i = 0; i < sequence_size; i++)
@@ -103,7 +103,7 @@ void network::frame_info::deserialize(std::istream &stream)
std::shared_ptr<network::message> network::deserialize_message(std::istream &stream)
{
auto type = (message::type_e)sn_utils::ld_uint16(stream);
const auto type = (message::type_e)sn_utils::ld_uint16(stream);
std::shared_ptr<message> msg;

15
network/network.cpp
View File

@@ -175,7 +175,7 @@ void network::client::update()
// client
std::tuple<double, double, command_queue::commands_map> network::client::get_next_delta(int counter)
{
auto now = std::chrono::high_resolution_clock::now();
const auto now = std::chrono::high_resolution_clock::now();
if (counter == 1) {
frame_time = now - last_frame;
last_frame = now;
@@ -187,23 +187,22 @@ std::tuple<double, double, command_queue::commands_map> network::client::get_nex
command_queue::commands_map>(0.0, 0.0, command_queue::commands_map());
}
float size = delta_queue.size() - consume_counter;
const float size = delta_queue.size() - consume_counter;
const auto& entry = delta_queue.front();
float mult = entry.render_dt / std::chrono::duration_cast<std::chrono::duration<float>>(frame_time).count();
const float mult = entry.render_dt / std::chrono::duration_cast<std::chrono::duration<float>>(frame_time).count();
if (counter == 1 && size < MAX_BUFFER_SIZE * 2.0f) {
last_target = last_target * TARGET_MIX +
(std::min(TARGET_MIN + jitteriness * JITTERINESS_MULTIPIER, MAX_BUFFER_SIZE)) * (1.0f - TARGET_MIX);
float diff = size - last_target;
const float diff = size - last_target;
jitteriness = std::max(jitteriness * JITTERINESS_MIX, std::abs(diff));
float speed = 1.0f + diff * CONSUME_MULTIPIER;
const float speed = 1.0f + diff * CONSUME_MULTIPIER;
consume_counter += speed;
}
float last_rcv_diff = std::chrono::duration_cast<std::chrono::duration<float>>(now - last_rcv).count();
const float last_rcv_diff = std::chrono::duration_cast<std::chrono::duration<float>>(now - last_rcv).count();
if (size > MAX_BUFFER_SIZE || consume_counter > mult || last_rcv_diff > 1.0f) {
if (consume_counter > mult) {
@@ -266,7 +265,7 @@ void network::client::handle_message(std::shared_ptr<connection> conn, const mes
if (msg.type == message::FRAME_INFO) {
resume_frame_counter++;
auto delta = dynamic_cast<const frame_info&>(msg);
const auto delta = dynamic_cast<const frame_info&>(msg);
delta_queue.push(delta);
last_rcv = std::chrono::high_resolution_clock::now();
}