netstructs.h

Go to the documentation of this file.

/********************************************************************************/
/*                                                                              */
/*  Netrinjo-Engine - a library for game-development                            */
/*  Copyright (C) 2005 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 NETSTRUCTS_H
#define NETSTRUCTS_H

#include "netpeermanager.h"

// admin-ids: 0x0**
#define TYP_ADMIN_SPEED     0x010
#define TYP_ADMIN_CLOSE     0x020
#define TYP_ADMIN_REJECT    0x031
//#define TYP_ADMIN_REQUEST 0x080   // last 7 Bits indicate, which request is meant
//#define TYP_ADMIN_ANSWER  0x080   // you can distinguish between request and answer
// by finding out whether or not this app is the server-app
#define TYP_ADMIN_MAXPING   0x081
#define MAX_ADMIN_PASSWORD  31

// connection-ids: 0x1**
#define TYP_CONNECT         0x101
#define TYP_DISCONNECT      0x102
#define TYP_CONNECTIONLIST  0x108
#define TYP_PING_REQUEST    0x110
#define TYP_PING_ANSWER     0x111

// chat-ids: 0x2**
#define TYP_CHAT_MESSAGE    0x202

// game-ids: 0x3**
#define TYP_NEXT_TURN       0x301

// command-ids: 0x4**
#define TYP_BASIC_COMMAND   0x400

struct NetBasicData
{
    Uint32 type()               { return SDLNet_Read32( &nType ); }
    void setType( Uint32 t )    { SDLNet_Write32( t, &nType ); }
protected:
    Uint32 nType;
};

struct NetBasicAdminData : NetBasicData
{
    NetBasicAdminData()
    {
        chPassword[0] = '\0';
    }
    char chPassword[MAX_ADMIN_PASSWORD+1];
};

struct NetAdminSpeed : NetBasicAdminData
{
    NetAdminSpeed()
    {
        setType( TYP_ADMIN_SPEED );
    }
    Uint32 get()            { return SDLNet_Read32( &nTime );   }
    void set( Uint32 t )    { SDLNet_Write32( t, &nTime );      }
protected:
    Uint32 nTime;
};

struct NetAdminReject : NetBasicAdminData
{
    NetAdminReject()
    {
        setType( TYP_ADMIN_REJECT );
        ip.host = 0;
        ip.port = 0;
    }
    IPaddress ip;
};

struct NetConnectData : NetBasicData
{
    NetConnectData()
    {
        setType( TYP_CONNECT );
        chName[PEER_MAX_NAME] = '\0';
    }
    int getPort()   { return SDLNet_Read16( &nListenPort ); }
    void setPort( int p )   { SDLNet_Write16( p, &nListenPort ); }
    char chName[PEER_MAX_NAME+1];
    char chInfo[64];
protected:
    Uint16 nListenPort;
};

struct NetDisconnectData : NetBasicData
{
    NetDisconnectData()
    {
        setType( TYP_DISCONNECT );
        chReason[PEER_MAX_REASON] = '\0';
    }
    char chReason[PEER_MAX_REASON+1];
};

struct NetConnectionList
{
    NetConnectionList( int max = 253 )
    {
        pData = new char[sizeof(NetBasicData) + sizeof(Uint32) + max*sizeof(IPaddress)];
        pIPs = (IPaddress*)(pData + sizeof(NetBasicData) + sizeof(Uint32));
        pType = (NetBasicData*)pData;
        pCount = (Uint32*)(pData + sizeof(NetBasicData));
        *pCount = 0;
        bAllocated = true;
        pType->setType( TYP_CONNECTIONLIST );
    }
    NetConnectionList( void *data )
    {
        pData = (char*)data;
        pIPs = (IPaddress*)(pData + sizeof(NetBasicData) + sizeof(Uint32));
        pType = (NetBasicData*)pData;
        pCount = (Uint32*)(pData + sizeof(NetBasicData));
        bAllocated = false;
    }
    ~NetConnectionList()
    {
        if( bAllocated && pData )
            delete[] pData;
        pData = NULL;
    }
    void *getData() { return pData; }
    IPaddress *get( int i )
    {
        if( i >= SDLNet_Read32( pCount ) )
            return NULL;
        return &pIPs[i];
    }
    void set( IPaddress a, int i )
    {
        if( SDLNet_Read32( pCount ) <= i )
            SDLNet_Write32( i+1, pCount );
        pIPs[i] = a;
    }
    int size()
    {
        return SDLNet_Read32( pCount )*sizeof(IPaddress) + sizeof(NetBasicData) + sizeof(Uint32);
    }
    Uint32 count()
    {
        return SDLNet_Read32( pCount );
    }
private:
    NetBasicData *pType;
    IPaddress *pIPs;
    char *pData;
    Uint32 *pCount;
    bool bAllocated;
};

struct NetValue32Data : NetBasicData
{
    NetValue32Data( Uint32 typ = 0 )
    {
        setType( typ );
        nValue = 0;
    }
    Uint32 get()        { return SDLNet_Read32( &nValue );  }
    void set( Uint32 v )    { SDLNet_Write32( v, &nValue );     }

protected:
    Uint32 nValue;
};

#endif

---