serverpacket.cpp

/***************************************************************************
 * The contents of this file are subject to the Mozilla Public             *
 * License Version 1.1 (the "License"); you may not use this file          *
 * except in compliance with the License. You may obtain a copy of         *
 * the License at http://www.mozilla.org/MPL/                              *
 *                                                                         *
 * Software distributed under the License is distributed on an "AS         *
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or              *
 * implied. See the License for the specific language governing            *
 * rights and limitations under the License.                               *
 *                                                                         *
 * The Original Code is Game Network Framework (GaNeF).                    *
 *                                                                         *
 * The Initial Developers of the Original Code are                         *
 * Lars Langer and Emanuel Greisen                                         *
 * Copyright (C) 2005. Lars Langer & Emanuel Greisen                       *
 * All Rights Reserved.                                                    *
 *                                                                         *
 * Contributor(s):                                                         *
 *   none yet....                                                          *
 *                                                                         *
 ***************************************************************************/
#include "serverpacket.h"
#include "serverdata.h"

#include "../common/plugin.h"

ServerPacket::ServerPacket( unsigned int receiver, unsigned char type, unsigned char priority,unsigned int bodysize,  bool reliable )
   : FrameworkPacket(receiver,type,priority,bodysize,reliable),client(0)
{
}

ServerPacket::ServerPacket( char * data, unsigned int size )
   : FrameworkPacket(data, size),client(0)
{
}

ServerPacket::ServerPacket(
         const ServerData * fdata,
         unsigned char type,
         unsigned char priority,
         bool reliable)
   : FrameworkPacket(fdata->getFrameworkId(),type,priority,reliable),client(0)
{
   // Check type is not system or plugin
   if(type < 4)
      throw new PacketError("Type is below 4, userdefined updates must be type: 4-255");
}

ServerPacket::~ServerPacket()
{
}


ServerPacket * ServerPacket::initCreateObjectPacket(const ServerData * fdata, unsigned char prio)
{
   ServerPacket * p = new ServerPacket(fdata->getClassId(),2,prio,INITIAL_BODY_SIZE,true);
   p->writeUInt32(fdata->getFrameworkId());
   return p;
}

ServerPacket * ServerPacket::initDestroyObjectPacket( const ServerData * fdata, unsigned char prio )
{
   ServerPacket * p = new ServerPacket(fdata->getFrameworkId(),3,prio,INITIAL_BODY_SIZE,true);
   p->writeUInt32(fdata->getFrameworkId());
   return p;
}


void ServerPacket::writePtr( const ServerData * obj )
{
   writeUInt32(obj ? obj->getFrameworkId() : 0);
}

void ServerPacket::writeObject( const ServerData * obj )
{
   // First we write our ID (For testing if the object is null/not null)
   writePtr(obj);
   // Then all the user-specified data
   if(obj)
   {
      // We must always write our ID first (for ClientData to read)
      writePtr(obj);
      // Here the virtual method for filling in the packet is called.
      obj->fillCreateObjectPacket(this);
   }
}

ServerPacket * ServerPacket::createAckPacket( ServerPacket * packet )
{
   // Create a packet of type 0(system), with receiver PACKET_ACK, the same priority, a bodysize of 5 and unreliable.
   ServerPacket * ack = new ServerPacket(PACKET_ACK, 0, packet->getPriority(), 5, false);
   ack->peer = packet->peer;
   ack->writeUInt32(packet->getSequenceNumber());
   ack->writeUInt8(packet->getPriority());
   return ack;
}

ServerPacket * ServerPacket::createDummyPacket( )
{
   return createSystemPacket( DUMMY_PACKET );
}

ServerPacket * ServerPacket::createSystemPacket( FrameworkPacket::SpecialReceivers receiver )
{
   ServerPacket * packet = new ServerPacket(receiver, 0);
   packet->header->reliable = 1;
   return packet;
}

ServerPacket * ServerPacket::createPluginPacket( const Plugin<ServerPacket> * plugin, const ServerPacket * _packet )
{
   ServerPacket * packet = new ServerPacket(plugin->getUniqueId(),1,0,INITIAL_BODY_SIZE,true);
   packet->peer = _packet->peer;
   packet->client = _packet->client;
   return packet;
}

ServerPacket * ServerPacket::readPacket( unsigned int psize )
{
   before_read_check(psize);
   ServerPacket * pack = new ServerPacket(&data[pos], psize);
   pack->peer = peer;
   pack->client = client;
   pos += psize;
   return pack;
}

void ServerPacket::makeSendReady( )
{
   if(!packet_ready_to_transmit)
   {
      if(!header->reliable && !isAckPacket())
      {
         // Get the next sequence number
         header->packet_seq_number = client->getNextOutgoingPacketSeqNumber(this);
      }
      header->receiver = htonl(header->receiver);
      header->packet_seq_number = htonl(header->packet_seq_number);
      packet_ready_to_transmit = true;
   }
}

---