void GameEconomicServerClientConsole::ShowPrompt(void)
{
Network* network = GetSubsystem<Network>();
Connection* serverConnection = network->GetServerConnection();
/// Get serverconnection
serverConnection = network->GetServerConnection();
/// Display prompt to the user
if(serverConnection&&serverconnection)
{
cout << endl << "(serveconnect) Enter Command >> ";
}
else
{
cout << endl << "(offline) Enter Command >> ";
}
}
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 Chat::HandleSend(StringHash eventType, VariantMap& eventData)
{
String text = textEdit_->GetText();
if (text.Empty())
return; // Do not send an empty message
Network* network = GetSubsystem<Network>();
Connection* serverConnection = network->GetServerConnection();
if (serverConnection)
{
// A VectorBuffer object is convenient for constructing a message to send
VectorBuffer msg;
msg.WriteString(text);
// Send the chat message as in-order and reliable
serverConnection->SendMessage(MSG_CHAT, true, true, msg);
// Empty the text edit after sending
textEdit_->SetText(String::EMPTY);
}
}
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 GameEconomicServerClientConsole::SendMessage(String Message)
{
/// If sending message is empty
if (Message.Empty())
{
return; // Do not send an empty message
}
/// Get connection
Network* network = GetSubsystem<Network>();
Connection* serverConnection = network->GetServerConnection();
/// Send message only if serverconnection and connection is true
if (serverConnection&&serverconnection)
{
// A VectorBuffer object is convenient for constructing a message to send
VectorBuffer msg;
msg.WriteString(Message);
// Send the chat message as in-order and reliable
serverConnection->SendMessage(NetMessageAdminClientSend, true, true, msg);
}
return;
}
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);
}
}
}