/home/malcolm/tmp/duncan/prototype/0/server/world.h

#ifndef SERVER_WORLD_H_
#define SERVER_WORLD_H_

extern bool g_serverpath;

#include <algorithm>
#include <tr1/memory>
#include <cstring>
#include <queue>
#include <iostream>
#include <sstream>
#include "charlist.h"
#include "player.h"
#include "npc.h"
#include "playerpacket.h"
#include "map.h"
#include "pathworld.h"
#include "pathfinder.h"

namespace server {

class World : public PathWorld {
        public:
                typedef CharList<Character> CList;
        private:
                const static double kPositionPacketInterval=0.1;

                const static double kPathPacketInterval=1.5;

                const static double kTreeRebuildInterval=1;

                double tree_age_;
                
                std::queue<PlayerPacket::pointer_t> outgoing_;

                Character* charlist_[net::kMaxCharacters];

                std::queue<net::index_t> available_;

                CList chars_;

                typedef std::vector<Player*> PList;
                PList players_;

                typedef std::vector<std::tr1::shared_ptr<NPC> > NPCList;
                NPCList npcs_;
        
                std::queue<Player*> to_join_;
                std::pair<Character*,std::pair<double,double> > to_move_[net::kMaxCharacters];

                PlayerPacket::pointer_t player_packet(Player*);
                PlayerPacket::pointer_t demand_player_packet(Player*);

                std::string mapname_;
                ServerMap map_;
                net::maphash_t maphash_;

                PathFinder path_finder_;

                void send_disconnect(net::index_t);
                void send_names(Player*);       
                void send_positions(Player*);
                void send_path_request(Player*,NPC*);

                void chat(Player*,const std::string&);

                void next_join();
        public:
                World(const std::string&);
                World(const World&);
                const World& operator=(const World&);

                void name_changed(Player*);
                const PlayerPacket::pointer_t next_outgoing();
                void pop_outgoing();
                void update(double);
                void join(Player*);
                void disconnect(Player*);
                void packet(net::data_t*, size_t, Player*);

                net::maphash_t maphash();
                const std::string& mapname();
                bool is_vacant(double,double,Character*) const;
                size_t width() const;
                size_t height() const;
};

}

#endif