void ServerLobbyEvents::on_event_join_game(const NetGameEvent &e, ServerLobbyPlayer *player)
{
int lobby_game_id = e.get_argument(0);
ServerLobbyGame *lobby_game = lobby_model->games.get_lobby_game(lobby_game_id);
if(lobby_game)
lobby_game->get_player_collection()->add_player(player);
else
player->send_event(NetGameEvent(STC_LOBBY_ERROR_MESSAGE, "Game not found"));
}
// "Login" event was received
void Server::on_event_login(const NetGameEvent &e, ServerUser *user)
{
log_event("events", "Client requested login");
std::string user_name = e.get_argument(0);
if(user_name.length() == 0)
{
user->send_event(NetGameEvent("Login-Fail", "Missing user name"));
}
else
{
// Assign name and id to User object (created when user connected earlier)
user->user_name = user_name;
user->id = next_user_id++;
user->send_event(NetGameEvent("Login-Success"));
}
}
void ServerLobbyEvents::on_event_start_game(const NetGameEvent &e, ServerLobbyPlayer *player)
{
if(player->current_game)
{
if(player->current_game->get_player_collection()->get_owner() == player)
{
ServerGame *game = lobby_model->games.create_game(player->current_game);
if(game->start())
player->current_game->set_state(ServerLobbyGame::playing);
}
else
{
player->send_event(NetGameEvent(STC_LOBBY_ERROR_MESSAGE, "Can not start a game without owning it"));
}
}
else
{
player->send_event(NetGameEvent(STC_LOBBY_ERROR_MESSAGE, "Not joined any game"));
}
}
void ServerLobbyEvents::on_event_leave_game(const NetGameEvent &e, ServerLobbyPlayer *player)
{
if(player->current_game)
{
player->current_game->get_player_collection()->remove_player(player);
lobby_model->games.remove_empty_games();
}
else
{
player->send_event(NetGameEvent(STC_LOBBY_ERROR_MESSAGE, "Not joined any game"));
}
}
NetGameEvent NetGameNetworkData::receive_data(const void *data, int size, int &out_bytes_consumed)
{
if (size >= 2)
{
int payload_size = *static_cast<const unsigned short *>(data);
if (payload_size > packet_limit)
throw Exception("Incoming message too big");
if (size >= 2 + payload_size)
{
out_bytes_consumed = 2 + payload_size;
DataBuffer buffer(static_cast<const char*>(data) + 2, payload_size);
return decode_event(buffer);
}
}
out_bytes_consumed = 0;
return NetGameEvent(std::string());
}
void ServerLobbyEvents::on_event_change_game_settings(const NetGameEvent &e, ServerLobbyPlayer *player)
{
std::string game_name = e.get_argument(0);
std::string map_name = e.get_argument(1);
int max_players = e.get_argument(2);
if(player->current_game)
{
ServerLobbyGame *lobby_game = player->current_game;
lobby_game->set_map_name(map_name);
lobby_game->set_max_players(max_players);
lobby_game->set_name(game_name);
lobby_game->send_game_info();
}
else
{
player->send_event(NetGameEvent(STC_LOBBY_ERROR_MESSAGE, "You do not own a game"));
}
}
// "Game-RequestStartGame" event was received
void Server::on_event_game_requeststart(const NetGameEvent &e, ServerUser *user)
{
log_event("events", "Client requested game start");
if(game_running == false)
{
game_running = true;
std::string map_name = "Map1";
int max_players = 6;
CustomType position(143,22,3);
NetGameEvent loadMapEvent("Game-LoadMap");
loadMapEvent.add_argument(map_name);
loadMapEvent.add_argument(max_players);
loadMapEvent.add_argument(position);
network_server.send_event(loadMapEvent);
network_server.send_event(NetGameEvent("Game-Start"));
}
}
void GameViewChat::on_lineedit_chat_enter_pressed()
{
client->get_network_client()->send_event(NetGameEvent(CTS_GAME_ADD_MESSAGE, lineedit_chat->get_text()));
lineedit_chat->set_text("");
}
void NetGameConnectionImpl::connection_main()
{
try
{
if (!is_connected)
connection = TCPConnection::connect(socket_name);
is_connected = true;
site->add_network_event(NetGameNetworkEvent(base, NetGameNetworkEvent::client_connected));
int bytes_received = 0;
int bytes_sent = 0;
const int max_event_packet_size = 32000 + 2;
auto receive_buffer = DataBuffer::create(max_event_packet_size);
auto send_buffer = DataBuffer::create(0);
bool send_graceful_close = false;
while (true)
{
if (read_connection_data(*receive_buffer, bytes_received))
break;
if (write_connection_data(*send_buffer, bytes_sent, send_graceful_close))
break;
std::unique_lock<std::mutex> lock(mutex);
if (stop_flag)
break;
NetworkEvent *events[] = { connection.get() };
worker_event.wait(lock, 1, events);
}
site->add_network_event(NetGameNetworkEvent(base, NetGameNetworkEvent::client_disconnected));
}
catch (const Exception& e)
{
site->add_network_event(NetGameNetworkEvent(base, NetGameNetworkEvent::client_disconnected, NetGameEvent(e.message)));
}
}
void ServerLobbyEvents::on_event_add_lobby_message(const NetGameEvent &e, ServerLobbyPlayer *lobby_player)
{
std::string message = e.get_argument(0);
if(message.length() > 0)
server->get_network_server()->send_event(NetGameEvent(STC_LOBBY_PLAYER_MESSAGE, lobby_player->player->id, message));
}
