serverdata.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....                                                          *
 *                                                                         *
 ***************************************************************************/
/// @example testserver/testserversnakebite.cpp
#include "serverdata.h"

#include "serverframework.h"

unsigned int ServerData::next_data_id = 1000;
mutex ServerData::next_data_id_mutex;


ServerData::ServerData( ServerFramework * f, char packet_priority, bool packet_reliable )
   : FrameworkData(ServerData::nextDataId()),
      server_frame_work(f),
      _packet_priority(packet_priority),
      _packet_reliable(packet_reliable)
{
   server_frame_work->registerData(this);
}


ServerData::~ServerData()
{
   server_frame_work->unregisterData(this);
}

unsigned int ServerData::nextDataId( )
{
   unsigned int n;
   next_data_id_mutex.enter();
   n = next_data_id++;
   next_data_id_mutex.leave();
   return n;
}

void ServerData::sendUpdateToAll(unsigned char type, bool reliable) const
{
   sendUpdate(server_frame_work->getAllClients(), type, reliable);
}

void ServerData::sendUpdate( const std::map< unsigned int, Client * > & clientlist, unsigned char type, bool reliable) const
{
   // No need to do all this if we send to nobody
   if(clientlist.empty())
      return;
   // Construct an update packet
   ServerPacket * packet = new ServerPacket(this, type, _packet_priority, reliable);
   fillUpdatePacket(packet, type);
   server_frame_work->enqueuePacket(packet, clientlist);
}

void ServerData::sendUpdate( Client * client, unsigned char type, bool reliable) const
{
   std::map< unsigned int, Client * > map;
   map.clear();
   map.insert(std::make_pair(client->getId(), client));
   sendUpdate(map,type,reliable);
}

void ServerData::sendCreateObjectToAll() const
{
   sendCreateObject(server_frame_work->getAllClients());
}

void ServerData::sendCreateObject( const std::map< unsigned int, Client * > & clientlist ) const
{
   // No need to do all this if we send to nobody
   if(clientlist.empty())
      return;
   // Construct an create object-packet
   ServerPacket * packet = ServerPacket::initCreateObjectPacket(this, _packet_priority);
   fillCreateObjectPacket(packet);
   server_frame_work->enqueuePacket(packet, clientlist);
}

void ServerData::sendCreateObject( Client * client ) const
{
   std::map< unsigned int, Client * > map;
   map.clear();
   map.insert(std::make_pair(client->getId(), client));
   sendCreateObject(map);
}

void ServerData::sendDestroyToAll() const
{
   sendDestroy(server_frame_work->getAllClients());
}

void ServerData::sendDestroy( const std::map< unsigned int, Client * > & clientlist ) const
{
   // No need to do all this if we send to nobody
   if(clientlist.empty())
      return;
   // Construct a delete/destroy object-packet
   ServerPacket * packet = ServerPacket::initDestroyObjectPacket(this, _packet_priority);
   server_frame_work->enqueuePacket(packet, clientlist);
}

void ServerData::sendDestroy( Client * client ) const
{
   std::map< unsigned int, Client * > map;
   map.clear();
   map.insert(std::make_pair(client->getId(), client));
   sendDestroy(map);
}

---