path: root/src/core/gameserver.cc

/*
   core/gameserver.h
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2
*/

#include <fstream>
#include <iomanip>

#include "auxiliary/functions.h"
#include "core/application.h"
#include "core/cvar.h"
#include "core/func.h"
#include "core/gameserver.h"
#include "core/loader.h"
#include "core/netserver.h"
#include "filesystem/filesystem.h"
#include "sys/sys.h"

namespace core
{

Player *console_find_player(std::string const & target)
{
	Player *targetplayer = server()->find_player(target);
	if (!targetplayer) {
		con_print << "^BPlayer '" + target + "^B' not found";
	}
	return targetplayer;
}

void func_who(std::string const &args)
{
	server()->list_players();
}

void func_time(std::string const &args)
{
	using namespace std;

	int minutes = (int) floorf(server()->time() / 60.0f);
	int seconds = (int) floorf(server()->time() - (float) minutes * 60.0f);

	int syshours = sys::time() / 3600;
	int sysminutes = (sys::time() - syshours * 3600) / 60;
	int sysseconds = sys::time() % 60;

	con_print <<
	"Uptime " << minutes << ":" << setfill('0') << setw(2) << seconds <<
	"  Local time " << setfill(' ') << setw(2) << syshours << ":" << setfill('0') << setw(2) << sysminutes << ":" << setw(2) << sysseconds << setfill(' ') << std::endl;
}

void func_mute(std::string const &args)
{
	Player *targetplayer = 0;
	if (!(targetplayer = console_find_player(args)))
		return;

	if (targetplayer->mute()) {
		con_print << "^BPlayer " + targetplayer->name() + "^B has already been muted";
		return;
	}

	targetplayer->player_mute = true;
	server()->broadcast("^B" + targetplayer->name() + "^B has been muted", targetplayer);
	targetplayer->send("^WYou have been muted");
}

void func_unmute(std::string const &args)
{
	Player *targetplayer = 0;
	if (!(targetplayer = console_find_player(args)))
		return;

	if (!targetplayer->mute()) {
		con_print << "^BPlayer " + targetplayer->name() + "^B has not been muted";
		return;
	}

	targetplayer->player_mute = false;
	server()->broadcast("^B" + targetplayer->name() + "^B has been unmuted", targetplayer);
	targetplayer->send("^WYou have been unmuted");
}

void func_kick(std::string const &args)
{
	std::stringstream str(args);
	std::string name;

	if (str >> name) {
		Player *targetplayer = 0;
		if (!(targetplayer = console_find_player(name)))
			return;
		std::string reason;
		if (args.size() > name.size() + 1)
			reason.assign(args.substr(name.size() + 1));
		else
			reason.assign("forcefully removed.");

		server()->kick(targetplayer, reason);
	}
}

void func_grant_rcon(std::string const &args)
{
	Player *targetplayer = 0;
	if (!(targetplayer = console_find_player(args)))
		return;
}

void func_revoke_rcon(std::string const &args)
{
	Player *targetplayer = 0;
	if (!(targetplayer = console_find_player(args)))
		return;
}

GameServer *GameServer::server_instance = 0;

GameServer::GameServer() : GameInterface()
{
	con_print << "^BInitializing game server...\n";
	server_instance = this;
	server_network = 0;
	server_timestamp = 0;
	server_previoustime = 0;
	server_maxplayerid = 1;
	server_startup = application()->timestamp();

	server_module = Loader::init();
	if (!server_module) {
		con_error << "No module loaded.\n";
		abort();
		return;
	}

	if (!server_module->running()) {
		con_error << "Could not initialize module '" << server_module->name() << "'\n";
		abort();
		return;
	}

	if (server_module->interactive()) {
		//FIXME interferes with command line because of cmd.exec
		load_config();
	}

	// set the name of the game
	core::Cvar::set("g_name", server_module->name().c_str(), core::Cvar::Game | core::Cvar::ReadOnly);


	con_print << "  module '^B" << server_module->name() << "^N'\n";

	if (server_module->interactive() && (Cvar::sv_dedicated->value() || Cvar::sv_private->value())) {
		server_network = new NetServer(Cvar::net_host->str(), (unsigned int) Cvar::net_port->value());
		if (!server_network->valid()) {
			delete server_network;
			server_network = 0;
			con_error << "Could not initialize network server\n";
			abort();
			return;
		}
	} else {
		con_print << "  network server disabled.\n";
		server_network = 0;
	}

	Func *func = 0;

	/* -- admin functions -- */
	func = Func::add("mute", func_mute);
	func->set_info("[player] mute a player");

	func = Func::add("unmute", func_unmute);
	func->set_info("[player] unmute a player");

	func = Func::add("kick", func_kick);
	func->set_info("[player] [reason] kick a player from the server");

	/* -- shared functions --*/
	func = Func::add("time", func_time, true);
	func->set_info("get the server uptime and current server localtime");

	func = Func::add("who", func_who, true);
	func->set_info("get a list of connected players");

	if (!Cvar::sv_dedicated->value()) {
		player_connect(localplayer());
	}

	server_running = true;
}

GameServer::~GameServer()
{
	server_running = false;

	con_print << "^BShutting down game server...\n";

	if (server_network) {
		delete server_network;
		server_network = 0;
	}

	if (server_module->interactive())
		save_config();

	if (server_module) {
		if (!Cvar::sv_dedicated->value())
			player_disconnect(localplayer());

		delete server_module;
		server_module = 0;
	}

	Func::remove("kick");

	Func::remove("mute");
	Func::remove("unmute");

	/*	Func::remove("grant_rcon");
		Func::remove("revoke_rcon");
	*/
	Func::remove("time");
	Func::remove("who");

	server_instance = 0;
}

unsigned long GameServer::timestamp() const
{
	return server_timestamp;
}

float GameServer::time() const
{
	return ((float)(server_timestamp) / 1000.0f);
}

Info *GameServer::info(const std::string &label)
{
	return Info::find(label);
}

void GameServer::abort()
{
	server_running = false;
}

bool GameServer::interactive() const
{
	if (!server_module) {
		return false;
	} else {
		return server_module->interactive();
	}
}

void GameServer::say(Player *player, std::string const &message)
{
	if (!message.size())
		return;

	if (player->mute()) {
		player->send("^WYou have been muted");
		return;
	}

	std::string notification("^B");
	notification.append(player->name());
	notification.append("^F:^N ");
	notification.append(message);

	broadcast(Message::Public, notification);
}

void GameServer::private_message(Player *player, std::string const &args)
{
	if (!args.size())
		return;

	if (player->mute()) {
		player->send("^WYou have been muted");
		return;
	}

	std::string target;
	std::stringstream argstr(args);
	if (!(argstr >> target)) {
		return;
	}

	core::Player *targetplayer = core::server()->find_player(target);
	if (!targetplayer) {
		player->send("^BPlayer " + target + "^B not found");
		return;
	}


	std::string message(args.substr(target.size()));
	player->message(Message::Private, "^FTo ^B" + targetplayer->name() + "^F:" + message);
	targetplayer->message(Message::Private, "^FFrom ^B" + player->name() + "^F:" + message);
}

// FIXME kicked by
void GameServer::kick(Player *player, std::string const &reason)
{
	if (!server_network) {
		con_print << "Not running a networked server" << std::endl;
		return;
	}

	NetClient *client = server_network->find_client(player);
	if (client) {
		broadcast("^B" + player->name() + "^B has been kicked: " + reason, player);
		player->send("^WYou have been kicked: " + reason);
		server_network->send_disconnect(client);
	} else {
		con_print << "Network client not found" << std::endl;
	}
}

// broadcast an "info" message to all players
void GameServer::broadcast(const std::string text, Player *ignore_player)
{
	broadcast(Message::Info, text, ignore_player);
}


// broadcast a message on a specified channel to all players
void GameServer::broadcast(const Message::Channel channel, const std::string text, Player *ignore_player)
{
	if (!text.size())
		return;

	for (Players::iterator it = players().begin(); it != players().end(); it++) {
		Player *player = (*it);
		if (player != ignore_player) {
			Player *player = (*it);
			player->message(channel, text);
		}
	}

	// console is not in the player list
	if (Cvar::sv_dedicated->value()) {
		localplayer()->message(channel, text);
	}
}

// broadcast a sound event to all players
void GameServer::broadcast_sound(const std::string name, Player *ignore_player)
{
	if (!name.size())
		return;

	for (Players::iterator it = players().begin(); it != players().end(); it++) {
		Player *player = (*it);
		if (player != ignore_player) {
			Player *player = (*it);
			player->sound(name);
		}
	}
}

// execute a command for a remote player
void GameServer::exec(Player *player, std::string const & cmdline)
{
	std::string command;
	std::stringstream cmdstream;
	cmdstream.str(cmdline);
	cmdstream >> command;

	Func *function = Func::find(command);
	if (function) {
		std::string args;
		if (cmdline.size() > command.size() + 1)
			args.assign(cmdline.substr(command.size() + 1));

		if ((function ->flags() & Func::Game) == Func::Game) {
			if ((function ->flags() & Func::Target) == Func::Target) {
				unsigned int id = 0;
				if ((cmdstream >> id)) {
					Entity *entity = Entity::find(id);
					if (entity)
						function->exec(player, entity);
				}
			} else {
				function->exec(player, args);
			}

		} else if ((function->flags() & Func::Shared) == Func::Shared) {

			// enable rcon buffering
			console()->set_rcon(true);
			function->exec(args);

			while (console()->rconbuf().size()) {
				player->message(Message::RCon, (*console()->rconbuf().begin()));
				console()->rconbuf().pop_front();
			}

			// disable rcon buffering
			console()->set_rcon(false);
		}
		return;
	}

	std::string message("Unknown command '");
	message.append(command);
	message.append("^N'");
	player->send(message);
}

void GameServer::player_connect(Player *player)
{
	if (Cvar::sv_dedicated->value() && (player == localplayer())) {
		return;
	}

	player->player_id = server_maxplayerid++;

	std::string message("^B");
	message.append(player->name());
	message.append("^B connects.");
	broadcast(message, player);

	// notify the game module
	server_module->player_connect(player);

	// manage player list
	game_players.push_back(player);
}

void GameServer::player_disconnect(Player *player)
{
	std::string message("^B");
	message.append(player->name());
	message.append("^B disconnects.");
	broadcast(message, player);

	// clear all player assets
	player->clear_assets();

	// notify the game module
	server_module->player_disconnect(player);

	// manage player list
	std::list<Player *>:: iterator it = game_players.begin();
	while (((*it)->id() != player->id()) && (it != game_players.end())) {
		it++;
	}
	if (it != game_players.end()) {
		game_players.erase(it);
	}
}

void GameServer::frame(unsigned long timestamp)
{
	if (error())
		return;

	// process incoming network messages
	if (server_network) {
		server_network->receive();

		if (server_network->error()) {
			abort();
			return;
		}
	}

	if (localplayer()->dirty())
		localplayer()->update_info();

	/*if (!Cvar::sv_dedicated->value()) {
		update_clientstate();
	}*/

	if ((Cvar::sv_dedicated->value() || Cvar::sv_private->value())) {
		if (core::Cvar::sv_framerate->value()) {
			float f =  1000.0f / core::Cvar::sv_framerate->value();
			if (server_startup + server_timestamp + f > timestamp) {
				return;
			}
		}
	}

	server_previoustime = server_timestamp;
	server_timestamp = timestamp - server_startup;
	float elapsed = (float)(server_timestamp - server_previoustime) / 1000.0f;

	// copy the previous entity state to the client state
	/*if (!Cvar::sv_dedicated->value()) {
		reset_clientstate();
	}*/

	// run a time frame on each entity
	for (Entity::Registry::iterator it = Entity::registry().begin(); it != Entity::registry().end(); it++) {
		Entity *entity = (*it).second;

		if ((entity->type() == Entity::Controlable) || (entity->type() == Entity::Dynamic)) {
			entity->frame(elapsed);
		}
	}

	// run a frame on the module
	if (server_module) {
		if (server_module->running())
			server_module->frame(elapsed);

		if (server_module->error()) {
			abort();
			return;
		}
	}

	if (server_network) {
		// send network updates
		server_network->frame(server_timestamp);
	}

	// mark all entities as updated
	for (Entity::Registry::iterator it = Entity::registry().begin(); it != Entity::registry().end();) {
		Entity *entity = (*it).second;

		if (entity->entity_destroyed) {
			delete entity;
			(*it).second = entity = 0;
			Entity::registry().erase(it++);
		} else {
			entity->clear_updates();
			++it;
		}
	}

	if (localplayer()->zonechange()) {
		application()->notify_zonechange();
		localplayer()->set_zonechange(false);
	}

	/*if (!Cvar::sv_dedicated->value()) {
		update_clientstate();
	}*/
}

void GameServer::save_config()
{
	std::string filename(filesystem::writedir());
	filename.append("game.cfg");
	std::ofstream ofs(filename.c_str());

	if (!ofs.is_open()) {
		con_warn << "Could not write " << filename << std::endl;
		return;
	}

	con_print << "  writing configuration to " << filename << std::endl;

	ofs << "# game.cfg - " << server_module->name() << " configuration" << std::endl;
	ofs << "# this file is automaticly generated" << std::endl;
	ofs << std::endl;

	for (Cvar::Registry::iterator it = Cvar::registry().begin(); it != Cvar::registry().end(); it++) {
		if ((((*it).second->flags() & Cvar::Archive) == Cvar::Archive) && (((*it).second->flags() & Cvar::Game) == Cvar::Game)) {
			ofs << "# " << (*it).first << " " << (*it).second->info() << std::endl;
			ofs << "set " << (*it).first << " " << (*it).second->str() << std::endl;
			ofs << std::endl;
		}
	}
	ofs.close();
}

void GameServer::load_config()
{
	std::string filename(filesystem::writedir());
	filename.append("game.cfg");
	std::ifstream ifs(filename.c_str(), std::ifstream::in);

	if (!ifs.is_open()) {
		con_warn << "Could not read " << filename << std::endl;
		return;
	}

	con_print << "  reading configuration from " << filename << std::endl;

	char line[MAXCMDSIZE];
	while (ifs.getline(line, MAXCMDSIZE - 1)) {
		if (line[0] && line[0] != '#' && line[0] != ';')
			cmd() << line << '\n';
	}

	// execute commands in the buffer
	CommandBuffer::exec();
}

}