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/zone.h"
#include "math/mathlib.h"

#include <string>
#include <list>

namespace core
{

/// a player in the game
class Player
{
public:
	/// default constructor
	Player();
	/// default destructor
	virtual ~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;
	}

	/// mission target
	inline Entity *mission_target() {
		return player_mission_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
	virtual void print() const;

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

	/*----- messages -------------------------------------------------- */

	/// send a text message
	void send(const std::string text);

	/**
	 * @brief send a warning message
	 * Send the player a warning message abd set the warning
	 * message timestamp to the current application time
	 * @see last_warning()
	 */
	void send_warning(const std::string text);

	virtual void sound(const std::string name);

	virtual void message(core::Message::Channel channel, const std::string text);

	/// time of the last warning message
	float  last_warning() const {
		return player_warningtime;
	}

	/*----- 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);

	/// set mission target
	void set_mission_target(Entity *new_mission_target);

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

	/// set the amount of credits the players has
	void set_credits(const long amount);

	/**
	 * @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;
	}

	/* -- 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:
	// 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;

	// 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
	std::string		player_guid;
	
	// dirty bit
	bool 			player_dirty;
	// bit to indicate zone has changed
	bool 			player_zonechange;

	float			player_warningtime;

};

}

#endif // __INCLUDED_CORE_PLAYER_H__