D:/Zythum/DinoKod/Game/ServerGameManager.cpp

#include "Common/Ini.h"
#include "Common/Error.h"
#include "Common/Console.h"
#include "Common/Command.h"
#include "Common/Time.h"
#include "Game/ServerWorld.h"
#include "Game/ServerPlayer.h"
#include "Game/ClientInfos.h"
#include "Game/Entity.h"
#include "Server/GameServer.h"
#include "Server/Client.h"

#include "Game/ServerGameManager.h"

//---------------------------------------------------------------------------------------------------------------------
KServerGameManager::KServerGameManager( KUDPSocket* pSocket, KList<KClient*>* pClientList, KVERSION GameVersion )
: KGameManager( pSocket, GameVersion )
{
        m_pClientList           = pClientList;
        m_LastFrameTime         = 0;
        m_NextObjectHandle      = 1;
        m_NextPlayerHandle      = 1;
        m_FrameRate                     = 30;
        m_Frame                         = 0;
        m_State                         = KGSS_NOTHING;

        g_pGame->GetpCommand()->RegisterCommand( "fakeman", CommandFakeMan, "Create a fake man", this );
        g_pGame->GetpCommand()->RegisterCommand( "framerate", CommandFrameRate, "Set game frame rate", this );
}

//---------------------------------------------------------------------------------------------------------------------
KServerGameManager::~KServerGameManager()
{
        g_pGame->GetpCommand()->UnregisterCommand( "fakeman" );
        g_pGame->GetpCommand()->UnregisterCommand( "framerate" );
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::Init()
{
        if( !KGameManager::Init() )
                return false;

        m_FrameRate = (u32)g_pGame->GetpIniFile()->ReadInt( "GAME", "FrameRate", 30 );
        g_Console << "Game framerate : " << m_FrameRate << KENDL;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::End()
{
        if( !KGameManager::End() )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::Manage()
{
        if( !KGameManager::Manage() )
                return false;
        
        switch( m_State )
        {
        case KGSS_PLAYING:
                // Temporise les frames selon le framerate
                if( (g_Time.GetTime() - m_LastFrameTime) > (1000 / m_FrameRate) )
                {
                        // Envoie la frame aux clients
                        NotifyFrame();
                
                        m_LastFrameTime = g_Time.GetTime();
                }
                break;
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::MoveFrame()
{
        if( !KGameManager::MoveFrame() )
                return false;

        if( GetpServerWorld() )
                GetpServerWorld()->MoveFrame( GetLastFrameTime(), GetCurrentFrameTime() );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KServerGameManager::OnConnect( KClient* pClient )
{
        KClientInfos*   pClientInfos = new KClientInfos();

        pClient->SetpData( pClientInfos );
}

//---------------------------------------------------------------------------------------------------------------------
KServerPlayer* KServerGameManager::GetpPlayerByClient( KClient* pClient )
{
        KServerPlayer*  pPlayer;

        for( pPlayer = GetpFirstServerPlayer(); pPlayer; pPlayer = GetpNextServerPlayer( pPlayer ) )
                if( pPlayer->GetpClient() == pClient )
                        return pPlayer;

        return NULL;
}

//---------------------------------------------------------------------------------------------------------------------
void KServerGameManager::OnDisconnect( KClient* pClient )
{
        KServerPlayer*  pPlayer;
        KClient*                pNotifyClient;
        KNetMsg                 Msg;

        DoGoodBye( pClient );

        // Flush le player qui a déconnecté
        for( pPlayer = GetpFirstServerPlayer(); pPlayer; pPlayer = GetpNextServerPlayer( pPlayer ) )
        {
                if( pPlayer->GetpClient() == pClient )
                {
                        // Notify que ce player est detruit
                        Msg = CreateMsg( KGMT_DELETEPLAYER ) << pPlayer->GetHandle();
                        
                        for( pNotifyClient = GetClientList()->GetFirst(); pNotifyClient; pNotifyClient =  GetClientList()->GetNext( pNotifyClient ) )
                        {
                                // on ne notifie pas au client qui s'est déconnecté
                                if( pClient == pNotifyClient )
                                        continue;

                                Send( pNotifyClient, Msg );
                        }

                        if( GetpServerWorld() )
                        {
                                // Detruit ses objets
                                K3DObject*      pObject;
                                for( pObject = GetpServerWorld()->GetpFirstObject(); pObject; pObject = GetpServerWorld()->GetpNextObject( pObject ) )
                                {
                                        if( pObject->GethPlayer() == pPlayer->GetHandle() )
                                        {
                                                Msg = CreateMsg( KGMT_DELETEOBJECT ) << pObject->GetHandle();

                                                for( pNotifyClient = GetClientList()->GetFirst(); pNotifyClient; pNotifyClient =  GetClientList()->GetNext( pNotifyClient ) )
                                                {
                                                        // on ne notifie pas au client qui s'est déconnecté
                                                        if( pClient == pNotifyClient )
                                                                continue;

                                                        Send( pNotifyClient, Msg );
                                                }

                                                GetpServerWorld()->RemovepObject( pObject );
                                                delete pObject;
                                        }
                                }
                        }

                        // Detruit le player
                        RemovepPlayer( pPlayer );
                        Deletep( pPlayer );
                        break;
                }
        }

        KClientInfos*   pClientInfos =  (KClientInfos*)pClient->GetpData();
        if( pClientInfos )
        {
                Deletep( pClientInfos );
                pClient->SetpData( NULL );
        }
}

//---------------------------------------------------------------------------------------------------------------------
void KServerGameManager::OnMessage( KClient* pClient, KGAMEMSGTYPE MsgType, KNetMsg& Msg )
{
        KServerPlayer*          pPlayer = (KServerPlayer*)GetpPlayerByClient( pClient );

        switch( MsgType )
        {
        //
        //      VERSION
        //
        case KGMT_GAMEVERSION:
                {
                        KVERSION        ClientVersion;

                        Msg >> ClientVersion;

                        g_Console << "Client version : " << KVERSION_GETMAJOR( ClientVersion ) << "." << KVERSION_GETMINOR( ClientVersion ) << KENDL;

                        KNetMsg& Msg2 = CreateMsg( KGMT_GAMEVERSION ) << m_GameVersion ;
                        bool    bChecked;

                        if( KVERSION_GETMAJOR( ClientVersion ) < KVERSION_GETMAJOR( m_GameVersion ) )
                        {
                                // Version cliente incompatible
                                bChecked = false;
                        }
                        else
                        {
                                // Version client compatible
                                bChecked = true;
                        }

                        Msg2 << bChecked;
                        Send( pClient, Msg2 );

                        if( !bChecked )
                        {
                                // Déconnexion du client
                                pClient->GetSocket()->Disconnect();
                                return;
                        }
                }
                return;

        //
        //      PLAYERS
        //
        case KGMT_CREATEPLAYER:
                {
                        KStr    sName;
                        Msg.ReadString( sName );
                        OnCreatePlayer( pClient, sName );
                }
                return;

        case KGMT_DELETEPLAYER:
                OnDeletePlayer( pClient );
                return;
        
        case KGMT_PLAYERNAME:
                {
                        KStr            sName;
                        Msg.ReadString( sName );
                        OnChangeName( pPlayer, sName );
                }
                return;
                
        //
        //      GAMEINFOS
        //
        case KGMT_GETGAMEINFOS:
                OnGetGameInfos( pClient );
                return;

        //
        //      CLIENTSTATE
        //
        case KGMT_SETCLIENTSTATE:
                OnSetClientState( pClient, Msg );
                return;

        case KGMT_OBJECTPOS:
                {
                        KHANDLE                 Handle;
                        KVector                 Pos, Rot;

                        Msg >> Handle >> Pos >> Rot;

                        if( !SetPosAndNotityObject( Handle, Pos, Rot ) )
                                KError::Warning( NULL, "KServerGameManager::OnMessage(...) : Cannot SetPosAndNotityObject" );

                        return;
                }
/*
        case KGMT_GETALLOBJECTS:
                {
                        CreateAndNotityAllObjects( pPlayer );
                        return;
                }
*/
        case KGMT_GETWORLD:
                OnGetWorld( pPlayer );
                return;
        //
        // CHAT
        //
        case KGMT_CHAT:
                {
                        KStr                    pText;
                        KStr                    pText2;
                        KServerPlayer*  pPlayer;

                        Msg.ReadString( pText );

                        pPlayer = GetpPlayerByClient( pClient );
                        if( !pPlayer )
                        {
                                KError::Warning( NULL, "KServerGameManager::OnMessage(...) : This client [%] has no player", pClient->GetpName() );
                                return;
                        }

                        pText2 = pPlayer->GetsName();
                        pText2 += "> ";
                        pText2 += pText;
                        NotifyChat( pClient, pText2.GetpString() );
                        g_Console << (char*)pText2 << KENDL;
                        return;
                }
        }
        
        KGameManager::OnMessage( MsgType, Msg );
}

//---------------------------------------------------------------------------------------------------------------------
K3DObject* KServerGameManager::CreateAndNotityObject( KHANDLE hPlayer, KGAMEOBJECTTYPE Type, KVector& Pos, KVector& Rot )
{
        K3DObject*      pObject = CreateObject( Type );

        if( !pObject )
                return NULL;

        u32                     Handle;
        
        Handle = m_NextObjectHandle++;
        pObject->SetType( Type );
        pObject->SetHandle( Handle );
        pObject->SethPlayer( hPlayer );
        pObject->Translate( Pos.x, Pos.y, Pos.z );
        pObject->SetRot( Rot );

        // Broadcast a tous les clients
        KNetMsg         Msg = CreateMsg( KGMT_CREATEOBJECT ) << Type;
        *pObject >> Msg;
                
        KClient*        pClient;
        for( pClient = GetClientList()->GetFirst(); pClient; pClient = GetClientList()->GetNext( pClient ) )
        {
                pClient->GetSocket()->SendMessage( Msg );
        }

        return pObject;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::SetPosAndNotityObject( KHANDLE Handle, KVector& Pos, KVector& Rot )
{
/*      // Broadcast a tous les clients
        KNetMsg         Msg = CreateMsg( KGMT_OBJECTPOS ) << Handle << Pos << Rot;
                
        KServerPlayer*  pPlayer;
        for( pPlayer = (KServerPlayer*)m_PlayerList.GetFirst(); pPlayer; pPlayer = (KServerPlayer*)m_PlayerList.GetNext( pPlayer ) )
        {
//              if( pPlayer->GetState() == KGPS_PLAYING )
                        if( !pPlayer->GetpSocket()->SendMessage( Msg, false ) )
                                return false;
        }
*/
        if( !SetObjectPos( Handle, Pos, Rot ) )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
// Crée et Notifie l'objet au joueur
//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::CreateAndNotityAllObjects( KServerPlayer* pPlayer )
{
        KASSERT( pPlayer );

        K3DObject*      pObject;
        KNetMsg         Msg;

        for( pObject = GetpServerWorld()->GetpFirstObject(); pObject; pObject = GetpServerWorld()->GetpNextObject( pObject ) )
        {
                // Demande au joueur de créer l'objet
                Msg = CreateMsg( KGMT_CREATEOBJECT ) << pObject->GetType();
                *pObject >> Msg;
                Send( pPlayer->GetpClient(), Msg );

                // Notifie l'objet au joueur
//              NotityObject( pPlayer, pObject );
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
// Notifie l'objet au joueur
//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::NotityObject( KServerPlayer* pPlayer, K3DObject* pObject )
{
        KASSERT( pPlayer );
        KASSERT( pObject );

        KNetMsg                 Msg;
        
        // Envoie le contenu de l'object au client
        Msg = CreateMsg( KGMT_NOTIFYOBJECT ) << pObject->GetHandle();
        *pObject >> Msg;
        Send( pPlayer->GetpClient(), Msg );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
// Notifie l'objet a tous les joueurs
//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::NotityObjectAllPlayers( K3DObject* pObject )
{
        KASSERT( pObject );
        KServerPlayer*  pPlayer;

        // Envoie l'objet a tout les clients
        for( pPlayer = GetpFirstServerPlayer(); pPlayer; pPlayer = GetpNextServerPlayer( pPlayer ) )
        {
                NotityObject( pPlayer, pObject );
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::OnCreatePlayer( KClient* pClient, KStr& sName )
{
        KServerPlayer*  pPlayer;
        KNetMsg                 Msg;
        
        // Vérifie qu'il n'existe pas
        for( pPlayer = GetpFirstServerPlayer(); pPlayer; pPlayer = GetpNextServerPlayer( pPlayer ) )
        {
                if( pPlayer->GetpClient() == pClient )
                {
                        KError::Warning( NULL, "KServerGameManager::CreatePlayer(...) : Player already created [%s:%i]", pClient->GetAddress().GetpAddress(), pClient->GetAddress().GetPort() );
                        return false;
                }
        }

        // Creation du player
        pPlayer = (KServerPlayer*)CreatePlayer();
        pPlayer->SetpClient( pClient );
        pPlayer->SetHandle( m_NextPlayerHandle++ );
        pPlayer->SetsName( sName );
        AddpPlayer( pPlayer );

        // Notify tous les players a ce client
        if( !NotifyCreateAllPlayers( pClient ) )
                return false;

        // Notify ce nouveau player a tous les autres client
        KClient*        pNotifyClient;
        for( pNotifyClient = GetClientList()->GetFirst(); pNotifyClient; pNotifyClient =  GetClientList()->GetNext( pNotifyClient ) )
        {
                if( pNotifyClient == pClient )
                        continue;

                if( !NotifyCreatePlayer( pNotifyClient, pPlayer ) )
                        return false;
        }

        // Assigne le client a son player correspondant
        Msg = CreateMsg( KGMT_ASSIGNPLAYER ) << pPlayer->GetHandle();
        Send( pClient, Msg );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::OnDeletePlayer( KClient* pClient )
{
        KServerPlayer*  pPlayer;
        
        // Vérifie qu'il existe
        for( pPlayer = GetpFirstServerPlayer(); pPlayer; pPlayer = GetpNextServerPlayer( pPlayer ) )
        {
                if( pPlayer->GetpClient() == pClient )
                {
                        RemovepPlayer( pPlayer );
                        Deletep( pPlayer );
                        return true;
                }
        }

        KError::Warning( NULL, "KServerGameManager::DeletePlayer(...) : Unknown client [%s:%i]", pClient->GetAddress().GetpAddress, pClient->GetAddress().GetPort() );
        return false;
}

//---------------------------------------------------------------------------------------------
void KServerGameManager::OnChangeName( KServerPlayer* pPlayer, KStr& sName )
{
        // Change le nom
        pPlayer->SetsName( sName );

        // Notify le changement de nom a tous les players
        KServerPlayer*          pServerPlayer;
        KNetMsg                         Msg = CreateMsg( KGMT_PLAYERNAME ) << pPlayer->GetHandle();
        Msg.WriteString( sName );

        for( pServerPlayer = GetpFirstServerPlayer(); pServerPlayer; pServerPlayer = GetpNextServerPlayer( pServerPlayer ) )
        {
                // Envoie le message de changement de team
                Send( pServerPlayer->GetpClient(), Msg );
        }
}

//---------------------------------------------------------------------------------------------------------------------
// CREATEPLAYER Demande au client de creer ce player
//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::NotifyCreatePlayer( KClient* pClient, KServerPlayer* pPlayer )
{
        KNetMsg                 Msg;

        Msg = CreateMsg( KGMT_CREATEPLAYER );
        *pPlayer >> Msg;
        if( !Send( pClient, Msg ) )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
// CREATEALLPLAYERS Envoie au client la liste de tous les players
//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::NotifyCreateAllPlayers( KClient* pClient )
{
        KServerPlayer*  pPlayer;
        KNetMsg                 Msg;
        
        // Flush
        Msg = CreateMsg( KGMT_FLUSHPLAYERS );
        Send( pClient, Msg );

        // Envoie la totalité
        for( pPlayer = GetpFirstServerPlayer(); pPlayer; pPlayer = GetpNextServerPlayer( pPlayer ) )
        {
                if( !NotifyCreatePlayer( pClient, pPlayer ) )
                        return false;
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
// NOTIFYPLAYERS Demande au client de mettre a jour ce player
//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::NotifyPlayer( KClient* pClient, KServerPlayer* pPlayer )
{
        KNetMsg                 Msg;

        Msg = CreateMsg( KGMT_NOTIFYPLAYER );
        *pPlayer >> Msg;
        if( !Send( pClient, Msg ) )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
// NOTIFYALLPLAYERS Envoie au client la mise a jour de tous les players
//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::NotifyAllPlayers( KClient* pClient )
{
        KServerPlayer*  pPlayer;
        KNetMsg                 Msg;
        
        // Envoie la totalité
        for( pPlayer = GetpFirstServerPlayer(); pPlayer; pPlayer = GetpNextServerPlayer( pPlayer ) )
        {
                if( !NotifyPlayer( pClient, pPlayer ) )
                        return false;
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::NotifyChat( KClient* pClient, char* pText )
{
        KNetMsg         Msg = CreateMsg( KGMT_CHAT );

        // Notify ce message a tous les autres client
        KClient*        pNotifyClient;
        for( pNotifyClient = GetClientList()->GetFirst(); pNotifyClient; pNotifyClient =  GetClientList()->GetNext( pNotifyClient ) )
        {
                if( pNotifyClient == pClient )
                        continue;

                Msg.WriteString( KStr( pText ) );
                Send( pNotifyClient, Msg );
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::SendChatText( KClient* pClient, char* pText )
{
        char                    pText2[1024];

        sprintf( pText2, "Server> %s", pText );
        
        KNetMsg         Msg = CreateMsg( KGMT_CHAT );
        Msg.WriteString( KStr( pText2 ) );
        Send( pClient, Msg );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::OnGetGameInfos( KClient* pClient )
{
        KNetMsg         Msg = CreateMsg( KGMT_GAMEINFOS );
        *m_pGameInfos >> Msg;
        Send( pClient, Msg );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::OnSetClientState( KClient* pClient, KNetMsg& Msg )
{
        KGAMECLIENTSTATE        ClientState;

        g_Console << "[" << pClient->GetAddress().GetpAddress() << ":" << pClient->GetpName() << "] ";

        Msg >> ClientState;

        ((KClientInfos*)pClient->GetpData())->SetClientState( ClientState );

        switch( ClientState )
        {
        case KGCS_NOTHING:                              g_Console << "KGCS_NOTHING" << KENDL;                           break;
        case KGCS_CREATEPLAYER:                 g_Console << "KGCS_CREATEPLAYER" << KENDL;                      break;
        case KGCS_WAITINGFORGAMEINFOS:  g_Console << "KGCS_WAITINGFORGAMEINFOS" << KENDL;       break;
        case KGCS_LOADING:                              g_Console << "KGCS_LOADING" << KENDL;                           break;
        case KGCS_WAITINGTOSTART:
                g_Console << "KGCS_WAITINGTOSTART" << KENDL;
                if( m_State == m_State )
                {
                        KNetMsg         Msg2 = CreateMsg( KGMT_START );
                        Send( pClient, Msg2 );

                        DoWelcome( pClient );
                }
                break;
        case KGCS_PLAYING:                              g_Console << "KGCS_PLAYING" << KENDL;                           break;
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::Send( KClient* pClient, KNetMsg& Msg )
{
        return pClient->GetSocket()->SendMessage( Msg );
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::SendAll( KNetMsg& Msg )
{
        KServerPlayer*  pPlayer;
        
        // Broadcast a tous les players
        for( pPlayer = GetpFirstServerPlayer(); pPlayer; pPlayer = GetpNextServerPlayer( pPlayer ) )
                pPlayer->GetpClient()->GetSocket()->SendMessage( Msg );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KServerGameManager::CommandFakeMan( KStr Argument, void* pContext )
{
        KServerGameManager*     pThis = (KServerGameManager*)pContext;
        KGEInfoPlayerStart*     pInfo = (KGEInfoPlayerStart*)pThis->GetpServerWorld()->GetRandomGameEntity( KGET_INFO_PLAYER_START );
        if( pInfo )
        {
                //pThis->CreateAndNotityObject( -1, KGOT_CHARACTER, KStr( "FakeMan" ), pInfo->GetPos(), KVector( 0.0f, 0.0f, pInfo->GetAngle() / ( 2.0f * PI ) ) );
                g_Console << "CommandFakeMan TODO!!!!!!" << KENDL;
//              g_Console << "Fake man created" << KENDL;
        }
        else
        {
                g_Console << "Fake man creation failed : no spawn point found!" << KENDL;
        }
}

//---------------------------------------------------------------------------------------------------------------------
void KServerGameManager::CommandFrameRate( KStr Argument, void* pContext )
{
        KServerGameManager*     pThis = (KServerGameManager*)pContext;

        pThis->m_FrameRate = atoi( Argument );
        if( pThis->m_FrameRate < 1 )
                pThis->m_FrameRate = 1;
        g_Console << "FrameRate set to : " << pThis->m_FrameRate << " fps"<< KENDL;
}

//---------------------------------------------------------------------------------------------------------------------
void KServerGameManager::NotifyFrame()
{
/*      KServerPlayer*  pPlayer;
        K3DObject*              pObject;
        KNetMsg                 Msg;

//      return true;
        // Broadcast a tous les players
        for( pPlayer = GetpFirstServerPlayer(); pPlayer; pPlayer = GetpNextServerPlayer( pPlayer ) )
        {
                if( ((KClientInfos*)pPlayer->GetpClient()->GetpData())->GetClientState() == KGCS_PLAYING )
                {
                        // Tous les objects
                        for( pObject = GetpServerWorld()->GetpFirstObject(); pObject; pObject = GetpServerWorld()->GetpNextObject( pObject ) )
                        {
                                if( pObject->IsNotifyPos() )
                                {
                                        Msg = CreateMsg( KGMT_OBJECTPOS ) << pObject->GetHandle() << pObject->GetPos() << pObject->GetRot();
                                        pPlayer->GetpSocket()->SendMessage( Msg, false );
                                }
                        }
//                      KStr    sText( m_Frame );
//                      SendChatText( pPlayer->GetpClient(), sText );
                }
        }
*/
        m_Frame ++;
}

//---------------------------------------------------------------------------------------------------------------------
void KServerGameManager::DoWelcome( KClient* pClient )
{
}

//---------------------------------------------------------------------------------------------------------------------
void KServerGameManager::DoGoodBye( KClient* pClient )
{
}

//---------------------------------------------------------------------------------------------------------------------
void KServerGameManager::OnGetWorld( KServerPlayer* pPlayer )
{
        // Envoie tous les objets du monde au client
        CreateAndNotityAllObjects( pPlayer );
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::StartGame( KGameInfos* pGameInfos )
{
        m_pGameInfos = pGameInfos;
        m_State = KGSS_LOADING;

        //
        // Notification aux clients
        // 
        KNetMsg Msg = CreateMsg( KGMT_GAMEINFOS );
        *m_pGameInfos >> Msg;
        SendAll( Msg );
        
        // 
        //      Création du World
        //
        KASSERT( !m_pWorld );
        m_pWorld = AllocWorld();
        if( !GetpServerWorld()->Init() )
                return false;

        //
        //      Chargement de la map
        //
        if( !GetpServerWorld()->LoadMap( m_pGameInfos->GetsMapName() ) )
                return false;   

        m_State = KGSS_PLAYING;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KServerGameManager::EndGame()
{
        m_State                 = KGSS_NOTHING;
        m_pGameInfos    = NULL;

        //
        //      Déchargement de la map
        //
        if( GetpServerWorld() )
        {
                if( !GetpServerWorld()->UnloadMap() )
                        return false;   
                
                GetpServerWorld()->End();
        }

        //
        //      Destruction du World
        //
        if( m_pWorld )
                Deletep( m_pWorld );

        //
        //      Flush les players
        //
        KServerPlayer*  pPlayer;
        
        for( pPlayer = GetpFirstServerPlayer(); pPlayer; pPlayer = GetpNextServerPlayer( pPlayer ) )
                pPlayer->Flush();

        return true;
}

---