path: root/src/core/player.h

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

#ifndef __INCLUDED_CORE_PLAYER_H__
#define __INCLUDED_CORE_PLAYER_H__

namespace core
{
class Player;
}

#include "core/entity.h"
#include "core/message.h"
#include "core/uid.h"
#include "core/zone.h"
#include "core/netclient.h"
#include "core/reputation.h"
#include "math/mathlib.h"

#include <string>
#include <list>

namespace core
{

/// a player in the game
class Player
{
public:
	/// default constructor
	Player(NetClient *client);
	
	/// default destructor
	~Player();

	/*----- inspectors ------------------------------------------------ */

	///  id of the player
	inline const int id() const {
		return player_id;
	}

	/// name of the player
	inline const std::string & name() const {
		return player_name;
	}

	/// dirty flag
	inline const bool dirty() const {
		return player_dirty;
	}

	/// the entity the Player is currently controling
	inline EntityControlable *control() const {
		return player_control;
	}

	/// the zone the player is currently in
	inline Zone *zone() const {
		return player_zone;
	}

	/// set the zone the player is currently in
	void set_zone(Zone *zone);

	inline const bool zonechange() const {
		return player_zonechange;
	}

	/// player primary color
	inline const math::Color & color() const {
		return player_color;
	}

	/// player secondary color
	inline const math::Color & color_second() const {
		return player_color_second;
	}

	/// player has been muted by admin or console
	inline const bool mute() const {
		return player_mute;
	}

	inline const std::string &rconpassword() const {
		return player_rconpassword;
	}

	/**
	 * @brief current mission target
	 * */
	inline Entity *mission_target() {
		return player_mission_target;
	}
	
	/**
	 * @brief current autopilot target
	 * */	
	/// mission target
	inline Entity *autopilot_target() {
		return player_autopilot_target;
	}

	/// view
	inline Entity *view() {
		return player_view;
	}

	/// credits
	inline long credits() const {
		return player_credits;
	}

	/// network ping
	inline long ping() const {
		return player_ping;
	}

	/// returns true of the player has enough credits to pay amount
	inline bool has_credits(const long amount) const {
		return (player_credits >= amount);
	}

	/// print player info to console
	void print() const;

	/// player level
	inline const int level() const
	{
		return player_level;
	}
	
	/// player admin level
	inline const int admin_level() const
	{
		return player_admin_level;
	}
	
	/// player global unique id
	inline UID & guid()
	{
		return player_guid;
	}

	/// network client associated with this player
	inline NetClient *client()
	{
		return player_client;
	}
	
	/**
	 * @brief player reputation 
	 * */
	inline Reputation & reputation()
	{
		return player_reputation;
	}
	
	/**
	 * @brief player reputation with a specific faction
	 * */
	inline const float reputation(const Info *faction) const
	{
		return player_reputation.reputation(faction);
	}
	
	/**
	 * @brief number of NPCs the player killed
	 * */
	inline const long npckills() const
	{
		return player_npckills;
	}
	
	/**
	 * @brief number of other players the player killed
	 * */
	inline const long pvpkills() const
	{
		return player_pvpkills;
	}
	
	/**
	 * @brief amount of time the player has previously spent in the game
	 * */
	inline const long time_wasted() const 
	{
		return player_time_wasted;
	}
	
	/**
	 * @brief timestamp of the the moment the player joined the game
	 * */
	inline const long time_joined() const
	{
		return player_time_joined;
	}
	
		
	/*----- server-side mesage functions ------------------------------ */	

	/// send a message to the player on one of the message channels
	void message(core::Message::Channel channel, const std::string text);
	
	/// send a text message
	void send(const std::string text);

	/// send a sound for the client to play
	void sound(const std::string name);

	/*----- mutators -------------------------------------------------- */

	/// serialize player info to a stream
	void serialize_server_update(std::ostream & os) const;

	/// receive player info from a stream
	void receive_server_update(std::istream &is);

	/// serialize player info to a stream
	void serialize_client_update(std::ostream & os);

	/// receive player info from a stream
	void receive_client_update(std::istream &is);

	/// serialize short player info to a stream
	void serialize_short_server_update(std::ostream & os) const;

	/// receive short player info from a stream
	void receive_short_server_update(std::istream &is);

	/// clear all the data
	void clear();

	/// clear assets
	void clear_assets();

	/// add an asset
	void add_asset(EntityControlable *entity);

	/// remove an asset
	void remove_asset(EntityControlable *entity);

	/// remove an asset
	void remove_asset(unsigned int id);

	/// update player info from client variables
	void update_info();

	/**
	 * @brief set the entity the player is currenty controlling
	 * This will automaticly set zone() to the zone the entity is in
	 */
	void set_control(EntityControlable *entitycontrolable);

	/**
	 * @brief set current mission target
	 * This will set dirty() if new_mission_target differs from mission_target()
	 * */
	void set_mission_target(Entity *new_mission_target);
	
	/**
	 * @brief set current autopilot target
	 * This will set dirty() if new_autopilot_target differs from autopilot_target()
	 * */
	void set_autopilot_target(Entity *new_autopilot_target);

	/// set the current view
	void set_view(Entity *view);

	/// set the amount of credits the players has
	void set_credits(const long amount);
	
	/// set the amount of time the player has previously spent in the game
	void set_time_wasted(const long time_wasted);
	
	/// set the timestamp the player joined to the current server time
	void set_time_joined();

	/**
	 * @brief add an amount to the player's credits
	 * @param amount the amount of credits to add, can be negative
	 */
	void add_credits(const long amount);

	/**
	 * @brief set the player's network ping
	 */
	void set_ping(const long ping);


	/// set the player level
	void set_level(const int level);
	
	/// set the admin level
	void set_admin_level(const int admin_level);
	
	void set_guid(const std::string & guid);
	
	/// set the dirty bit
	inline void set_dirty(const bool dirty = true) {
		player_dirty = dirty;
	}

	/// set the zonechange bit
	inline void set_zonechange(const bool dirty = true) {
		player_zonechange = dirty;
	}
	
	/**
	 * @brief set the number of NPCs the player killed
	 * */
	void set_npckills(const long kills);
	
	/**
	 * @brief set the number of other players the player killed
	 * */
	void set_pvpkills(const long kills);

	/* -- should actually not be public --*/

	///  id of the player
	int player_id;

	/// name of the player
	std::string player_name;

	/// player primary color
	math::Color player_color;

	/// player secondary color
	math::Color player_color_second;

	/// player is muted by admin
	bool player_mute;

	std::list<EntityControlable *>	assets;

private:
	// associated network client
	NetClient		*player_client;
	
	// entity the Player is currently controling
	EntityControlable 	*player_control;

	// entity the Player is currently looking at
	Entity 			*player_view;

	// current mission target
	Entity 			*player_mission_target;
	
	// current autopilot target
	Entity 			*player_autopilot_target;

	// the zone the player is currently in
	Zone 			*player_zone;

	long			player_credits;
	// in-game level
	int			player_level;
	
	long			player_ping;
	std::string		player_rconpassword;
	int			player_admin_level;
	
	// global unique id
	UID			player_guid;
	
	// dirty bit
	bool 			player_dirty;
	// bit to indicate zone has changed
	bool 			player_zonechange;

	float			player_warningtime;
	
	Reputation		player_reputation;
	
	long			player_npckills;
	
	long			player_pvpkills;
	
	unsigned long		player_time_wasted;
	
	unsigned long		player_time_joined;

};

}

#endif // __INCLUDED_CORE_PLAYER_H__