netmanager.h

Go to the documentation of this file.

/********************************************************************************/
/*                                                                              */
/*  Netrinjo-Engine - a library for game-development                            */
/*  Copyright (C) 2005-2006 by Tobias Nadler                                    */
/*                                                                              */
/*  This library is free software; you can redistribute it and/or               */
/*  modify it under the terms of the GNU Lesser General Public                  */
/*  License as published by the Free Software Foundation; either                */
/*  version 2.1 of the License, or (at your option) any later version.          */
/*                                                                              */
/*  This library is distributed in the hope that it will be useful,             */
/*  but WITHOUT ANY WARRANTY; without even the implied warranty of              */
/*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU           */
/*  Lesser General Public License for more details.                             */
/*                                                                              */
/*  You should have received a copy of the GNU Lesser General Public            */
/*  License along with this library; if not, write to the Free Software         */
/*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA   */
/*                                                                              */
/********************************************************************************/

#ifndef NETMANAGER_H
#define NETMANAGER_H

#include "SDL/SDL_net.h"
#include <list>
#include "basicobject.h"


#define MAX_PEERS           127
#define NETWORK_PORT        8457

#define NETWORK_UDPPORT     (NETWORK_PORT+1)
#define NETWORK_SERVERPORT  8455

using namespace std;

class NetSocket;
struct NetBasicData;

class DECLSPEC NetBasicManager: public BasicObject
{
public:
    DECLSPEC NetBasicManager(const char *name, BasicObject *p);
    DECLSPEC NetBasicManager(TiXmlElement *el, BasicObject *p);
    virtual DECLSPEC ~NetBasicManager();

    DECLSPEC bool init( unsigned int port = NETWORK_PORT, unsigned int udpport = NETWORK_UDPPORT,
                        int udpmaxsize = 1024 );
    void destroy()  {onDestroy();}

    DECLSPEC unsigned int send( char *data, int size );
    DECLSPEC bool sendUDP( char *data, int size, const IPaddress &ip );
    virtual DECLSPEC bool checkPeers();
    virtual DECLSPEC bool checkServer();

    DECLSPEC NetSocket *getSocket( const IPaddress &ip );
    DECLSPEC void deleteDisconnected();

    int numConnections()    { return nPeersConnected; }
    void setConnectCallback( BasicObject::Callback func, BasicObject *pData )   { cbServer.func = func; cbServer.obj = pData; }
    void setPeerCallback( BasicObject::Callback func, BasicObject *pData )  { cbPeer.func = func; cbPeer.obj = pData; }
    void setUDPCallback( BasicObject::Callback func, BasicObject *pData )   { cbUDP.func = func; cbUDP.obj = pData; }

    int localPort() { return nListenPort; }
    DECLSPEC const char *localIP();

    DECLSPEC static bool initSDL();
    DECLSPEC static void quitSDL();
    static NetBasicManager *the;
protected:
    DECLSPEC static NetBasicManager *getThe();
    
    virtual DECLSPEC void onInit();
    virtual DECLSPEC void onDestroy();
    virtual DECLSPEC void onReceiveUDP(UDPpacket *udp);

    virtual NetSocket *createSocket( TCPsocket socket ) = 0;
    bool bInited;
    int nListenPort;
    unsigned int nUDPPort;

private:
    DECLSPEC bool registerSocket( TCPsocket sock );
    DECLSPEC void unregisterSocket( TCPsocket sock );

    int nPeersConnected;

    SDLNet_SocketSet socksPeers, socksServer;
    TCPsocket sockServer;
    UDPsocket sockUDP;
    // used to receive/send incomming/outgoing messages
    UDPpacket *ppackUDPrecv, *ppackUDPsend;
    // max. size of a UDP-packet's content
    unsigned int nUDPMaxSize;

    BasicObject::FunctionData cbServer, cbPeer, cbUDP;

//  char *chLocalName;
    // reference counter for usage of SDL-network functions
    static unsigned int nSDLNetRefCount;

    friend class NetSocket;
};

class NetStandardSocket;

class DECLSPEC NetSimpleManager: public NetBasicManager
{
public:
    DECLSPEC NetSimpleManager(const char *name, BasicObject *p);
    DECLSPEC NetSimpleManager(TiXmlElement *el, BasicObject *p);
    virtual DECLSPEC ~NetSimpleManager();
    virtual const char *getClassName()  { return "NetSimpleManager"; }

    static NetSimpleManager *getThe()   { return (NetSimpleManager*)NetBasicManager::getThe(); }
protected:
    virtual DECLSPEC NetSocket *createSocket( TCPsocket socket );

private:
};


#endif

---