virtualx-engine/core/io/networked_multiplayer_custom.cpp

189 lines
7.3 KiB
C++

/*************************************************************************/
/* networked_multiplayer_custom.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "core/io/networked_multiplayer_custom.h"
NetworkedMultiplayerCustom::NetworkedMultiplayerCustom() {
self_id = 0;
transfer_mode = TransferMode::TRANSFER_MODE_RELIABLE;
connection_status = ConnectionStatus::CONNECTION_DISCONNECTED;
refusing_new_connections = false;
target_id = 0;
// Default to a large value.
max_packet_size = 1 << 24;
}
NetworkedMultiplayerCustom::~NetworkedMultiplayerCustom() {
}
void NetworkedMultiplayerCustom::_bind_methods() {
ClassDB::bind_method(D_METHOD("initialize", "self_peer_id"), &NetworkedMultiplayerCustom::initialize);
ClassDB::bind_method(D_METHOD("set_max_packet_size", "max_packet_size"), &NetworkedMultiplayerCustom::set_max_packet_size);
ClassDB::bind_method(D_METHOD("set_connection_status", "connection_status"), &NetworkedMultiplayerCustom::set_connection_status);
ClassDB::bind_method(D_METHOD("deliver_packet", "buffer", "from_peer_id"), &NetworkedMultiplayerCustom::deliver_packet);
ADD_SIGNAL(MethodInfo("packet_generated", PropertyInfo(Variant::INT, "peer_id"), PropertyInfo(Variant::POOL_BYTE_ARRAY, "buffer"), PropertyInfo(Variant::INT, "transfer_mode")));
}
//
// PacketPeer
//
Error NetworkedMultiplayerCustom::get_packet(const uint8_t **r_buffer, int &r_buffer_size) {
ERR_FAIL_COND_V(incoming_packets.size() == 0, Error::ERR_UNAVAILABLE);
current_packet = incoming_packets.front()->get();
incoming_packets.pop_front();
*r_buffer = current_packet.data.read().ptr();
r_buffer_size = current_packet.data.size();
return Error::OK;
}
Error NetworkedMultiplayerCustom::put_packet(const uint8_t *p_buffer, int p_buffer_size) {
PoolByteArray a;
a.resize(p_buffer_size);
PoolByteArray::Write w = a.write();
memcpy(w.ptr(), p_buffer, p_buffer_size);
emit_signal("packet_generated", target_id, a, transfer_mode);
return Error::OK;
}
int NetworkedMultiplayerCustom::get_available_packet_count() const {
return incoming_packets.size();
}
int NetworkedMultiplayerCustom::get_max_packet_size() const {
return max_packet_size;
}
//
// NetworkedMultiplayerPeer.
//
void NetworkedMultiplayerCustom::set_transfer_mode(NetworkedMultiplayerPeer::TransferMode p_mode) {
transfer_mode = p_mode;
}
NetworkedMultiplayerPeer::TransferMode NetworkedMultiplayerCustom::get_transfer_mode() const {
return transfer_mode;
}
void NetworkedMultiplayerCustom::set_target_peer(int p_target_peer) {
target_id = p_target_peer;
}
int NetworkedMultiplayerCustom::get_packet_peer() const {
ERR_FAIL_COND_V(connection_status != ConnectionStatus::CONNECTION_CONNECTED, 1);
ERR_FAIL_COND_V(incoming_packets.size() == 0, 1);
return incoming_packets.front()->get().from;
}
bool NetworkedMultiplayerCustom::is_server() const {
return self_id == 1;
}
void NetworkedMultiplayerCustom::poll() {
}
int NetworkedMultiplayerCustom::get_unique_id() const {
return self_id;
}
void NetworkedMultiplayerCustom::set_refuse_new_connections(bool p_refuse_new_connections) {
refusing_new_connections = p_refuse_new_connections;
}
bool NetworkedMultiplayerCustom::is_refusing_new_connections() const {
return refusing_new_connections;
}
NetworkedMultiplayerPeer::ConnectionStatus NetworkedMultiplayerCustom::get_connection_status() const {
return connection_status;
}
//
// Custom methods.
//
void NetworkedMultiplayerCustom::initialize(int p_self_id) {
ERR_FAIL_COND_MSG(connection_status != ConnectionStatus::CONNECTION_CONNECTING,
"Can only initialize if connection status is CONNECTION_CONNECTING.");
ERR_FAIL_COND_MSG(p_self_id < 0 || p_self_id > ~(1 << 31),
"Cannot initialize with invalid unique network id.");
self_id = p_self_id;
if (self_id == 1) {
set_connection_status(ConnectionStatus::CONNECTION_CONNECTED);
}
}
void NetworkedMultiplayerCustom::set_max_packet_size(int p_max_packet_size) {
max_packet_size = p_max_packet_size;
}
void NetworkedMultiplayerCustom::set_connection_status(NetworkedMultiplayerPeer::ConnectionStatus p_connection_status) {
if (connection_status == p_connection_status) {
return;
}
ERR_FAIL_COND_MSG(p_connection_status == ConnectionStatus::CONNECTION_CONNECTING && connection_status != ConnectionStatus::CONNECTION_DISCONNECTED,
"Can only change connection status to CONNECTION_CONNECTING from CONNECTION_DISCONNECTED.");
ERR_FAIL_COND_MSG(p_connection_status == ConnectionStatus::CONNECTION_CONNECTED && connection_status != ConnectionStatus::CONNECTION_CONNECTING,
"Can only change connection status to CONNECTION_CONNECTED from CONNECTION_CONNECTING.");
if (p_connection_status == ConnectionStatus::CONNECTION_CONNECTED) {
connection_status = p_connection_status;
emit_signal("connection_succeeded");
} else if (p_connection_status == ConnectionStatus::CONNECTION_DISCONNECTED) {
ConnectionStatus old_connection_status = connection_status;
connection_status = p_connection_status;
if (self_id != 1) {
if (old_connection_status == ConnectionStatus::CONNECTION_CONNECTING) {
emit_signal("connection_failed");
} else {
emit_signal("server_disconnected");
}
}
} else {
connection_status = p_connection_status;
}
}
void NetworkedMultiplayerCustom::deliver_packet(const PoolByteArray &p_data, int p_from_peer_id) {
Packet p = { p_data, p_from_peer_id };
incoming_packets.push_back(p);
}