void Chat::HandleNetworkMessage(StringHash eventType, VariantMap& eventData)
{
Network* network = GetSubsystem<Network>();
using namespace NetworkMessage;
int msgID = eventData[P_MESSAGEID].GetInt();
if (msgID == MSG_CHAT)
{
const PODVector<unsigned char>& data = eventData[P_DATA].GetBuffer();
// Use a MemoryBuffer to read the message data so that there is no unnecessary copying
MemoryBuffer msg(data);
String text = msg.ReadString();
// If we are the server, prepend the sender's IP address and port and echo to everyone
// If we are a client, just display the message
if (network->IsServerRunning())
{
Connection* sender = static_cast<Connection*>(eventData[P_CONNECTION].GetPtr());
text = sender->ToString() + " " + text;
VectorBuffer sendMsg;
sendMsg.WriteString(text);
// Broadcast as in-order and reliable
network->BroadcastMessage(MSG_CHAT, true, true, sendMsg);
}
ShowChatText(text);
}
}
void Chat::UpdateButtons()
{
Network* network = GetSubsystem<Network>();
Connection* serverConnection = network->GetServerConnection();
bool serverRunning = network->IsServerRunning();
// Show and hide buttons so that eg. Connect and Disconnect are never shown at the same time
sendButton_->SetVisible(serverConnection != 0);
connectButton_->SetVisible(!serverConnection && !serverRunning);
disconnectButton_->SetVisible(serverConnection || serverRunning);
startServerButton_->SetVisible(!serverConnection && !serverRunning);
}
void Chat::HandleDisconnect(StringHash eventType, VariantMap& eventData)
{
Network* network = GetSubsystem<Network>();
Connection* serverConnection = network->GetServerConnection();
// If we were connected to server, disconnect
if (serverConnection)
serverConnection->Disconnect();
// Or if we were running a server, stop it
else if (network->IsServerRunning())
network->StopServer();
UpdateButtons();
}
void SceneReplication::HandleDisconnect(StringHash eventType, VariantMap& eventData)
{
Network* network = GetSubsystem<Network>();
Connection* serverConnection = network->GetServerConnection();
// If we were connected to server, disconnect. Or if we were running a server, stop it. In both cases clear the
// scene of all replicated content, but let the local nodes & components (the static world + camera) stay
if (serverConnection)
{
serverConnection->Disconnect();
scene_->Clear(true, false);
clientObjectID_ = 0;
}
// Or if we were running a server, stop it
else if (network->IsServerRunning())
{
network->StopServer();
scene_->Clear(true, false);
}
UpdateButtons();
}
void SceneReplication::HandlePhysicsPreStep(StringHash eventType, VariantMap& eventData)
{
// This function is different on the client and server. The client collects controls (WASD controls + yaw angle)
// and sets them to its server connection object, so that they will be sent to the server automatically at a
// fixed rate, by default 30 FPS. The server will actually apply the controls (authoritative simulation.)
Network* network = GetSubsystem<Network>();
Connection* serverConnection = network->GetServerConnection();
// Client: collect controls
if (serverConnection)
{
UI* ui = GetSubsystem<UI>();
Input* input = GetSubsystem<Input>();
Controls controls;
// Copy mouse yaw
controls.yaw_ = yaw_;
// Only apply WASD controls if there is no focused UI element
if (!ui->GetFocusElement())
{
controls.Set(CTRL_FORWARD, input->GetKeyDown('W'));
controls.Set(CTRL_BACK, input->GetKeyDown('S'));
controls.Set(CTRL_LEFT, input->GetKeyDown('A'));
controls.Set(CTRL_RIGHT, input->GetKeyDown('D'));
}
serverConnection->SetControls(controls);
// In case the server wants to do position-based interest management using the NetworkPriority components, we should also
// tell it our observer (camera) position. In this sample it is not in use, but eg. the NinjaSnowWar game uses it
serverConnection->SetPosition(cameraNode_->GetPosition());
}
// Server: apply controls to client objects
else if (network->IsServerRunning())
{
const Vector<SharedPtr<Connection> >& connections = network->GetClientConnections();
for (unsigned i = 0; i < connections.Size(); ++i)
{
Connection* connection = connections[i];
// Get the object this connection is controlling
Node* ballNode = serverObjects_[connection];
if (!ballNode)
continue;
RigidBody* body = ballNode->GetComponent<RigidBody>();
// Get the last controls sent by the client
const Controls& controls = connection->GetControls();
// Torque is relative to the forward vector
Quaternion rotation(0.0f, controls.yaw_, 0.0f);
const float MOVE_TORQUE = 3.0f;
// Movement torque is applied before each simulation step, which happen at 60 FPS. This makes the simulation
// independent from rendering framerate. We could also apply forces (which would enable in-air control),
// but want to emphasize that it's a ball which should only control its motion by rolling along the ground
if (controls.buttons_ & CTRL_FORWARD)
body->ApplyTorque(rotation * Vector3::RIGHT * MOVE_TORQUE);
if (controls.buttons_ & CTRL_BACK)
body->ApplyTorque(rotation * Vector3::LEFT * MOVE_TORQUE);
if (controls.buttons_ & CTRL_LEFT)
body->ApplyTorque(rotation * Vector3::FORWARD * MOVE_TORQUE);
if (controls.buttons_ & CTRL_RIGHT)
body->ApplyTorque(rotation * Vector3::BACK * MOVE_TORQUE);
}
}
}
