clientframework.h

/***************************************************************************
 * 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....                                                          *
 *                                                                         *
 ***************************************************************************/
#ifndef CLIENTFRAMEWORK_H
#define CLIENTFRAMEWORK_H

#include <ptypes.h>

#include <map>
#include <vector>

#include "../common/framework.h"
#include "../common/frameworkseqnolist.h"
#include "../common/averagetimecalculator.h"
#include "../common/frameworkpacket.h"
#include "clientpacket.h"
#include "clientdatamap.h"

class ClientData;

/// @example testclient/testclientframework.h

/**
 * @ingroup Client
 * @brief This class is the framework on the client.
 * With sender, reciever, pending-ack-list and all client data.
 * This is the class you must inherit from on the client side of your game.
 *
 * @author Lars Langer and Emanuel Greisen
 */
class ClientFramework : public Framework<ClientPacket,ipmessage>
{
friend class ClientData;
//friend class ServerData;

public:
   enum ClientState
   {
      ///Framework initialized, but not started
      NOT_STARTED                    = 1000,
      ///Handshaking initilized
      HANDSHAKING_INIT               = 3001,
      ///Handshaking was aborted by the server
      HANDSHAKING_ABORTED_BY_SERVER  = 3002,
      ///Handshaking was aborted by the server
      HANDSHAKING_ABORTED_BY_CLIENT  = 3003,
      ///Client and server in agreement - client connected
      CONNECTED                      = 4000,
      ///Now we are disconnected (but we were connected before)
      DISCONNECTED                   = 5000
   };

private:
   ClientDataMap * client_data_map;
   ipaddress server_host;
   int server_port;
   int local_port;
   FrameworkSeqNoList<ClientPacket,ipmessage> sequencenumbers;
   std::map<unsigned int, ClientData *> client_data;
   std::map<unsigned int, Plugin<ClientPacket> *> plugins;
   std::map<unsigned int, ClientData* (*)(ClientFramework *, ClientPacket *) > constructors;
   AverageTimeCalculator<16> avg_rtt;
   /// Told by the server, telling us how often we should at least heartbeat.
   unsigned int connection_timeout_length;
   unsigned int last_reliable_sent_packet_time;
   unsigned int last_received_pack;

   bool onConnectCalled;
   bool onDisconnectCalled;
   unsigned int nextExpectedSequenceNumber;
   ClientState state;


public:
   ClientFramework(int local_port);
   ~ClientFramework();

public:
   ///This method starts the listning and receiving sockets of the framework. It also starts the handshaking session between the client framwork and the server
   void initServerConnection(const std::string & _server_host, int _server_port);
   /// This method will stop both the sender and the receiver if they are started, and clean out the queues.
   void terminateServerConnection();
   //static ipaddress getHostFromName(const std::string &hostname);

private:
   virtual void registerData(ClientData *data);
   bool checkPlugin( unsigned int plug_id );
   void handleSystemPacket(ClientPacket * p);
   void heartBeat();
   void disconnectionCleanup();

public:
   virtual void unregisterData( ClientData *data );
   /// This method will return a pointer to a ClientData object (or null if the object does not exist on the client).
   ClientData * getDataObject(unsigned int objid);
   /// This method will add to the pointer-pointer-table-thingy a missing pointer.
   void registerPointer(unsigned int receiver, unsigned int missing, ClientData **ptrptr);
   /// This method will deletea pointer from the pointer-pointer-table
   bool unregisterPointer(unsigned int receiver, unsigned int objid, ClientData **ptrptr);
   /// This method will register a constructor-method with a class-id.
   void registerConstructor(unsigned int class_id, ClientData * (*func)(ClientFramework *, ClientPacket *));
   /// Will register a plugin in the framework, plugins are used to "unpack" packets created with the same plugin on the server side (example: compression).
   void registerPlugin(Plugin<ClientPacket> * plugin);
   /// This will handle any incomming packets, along with other keep-alive-stuff.
   void keepAlive(unsigned int sleepmillis = 0);
   /// This method tests if a packet is in order, and if not buffer the packet
   /// for later delivery.
   virtual bool isPacketReadyForDelivery(ClientPacket * packet);
   /// This method will deliver the packet and return any buffered packets,
   /// waiting for this packet.
   virtual ClientPacket * deliverPacket(ClientPacket * p);
   /// This will return the next sequence number for the outgoing packet, and increment it also.
   unsigned int getNextUnreliablePacketSeqNumber(ClientPacket * packet);
   /// Called when we want to insert a pending ack into the pendingackist.
   virtual void addPendingAck(ClientPacket * packet, bool haslock);
   /// This method will be called by the sender when ever it successfully sends a
   /// reliable packet to the socket, we will register the time.
   virtual void sentReliablePacket(ClientPacket * packet);
   /// This method enqueues a packet.
   void enqueuePacket(ClientPacket * p, bool sendnow=false);
   /// This method will return the current state of the client;
   ClientState getState() const { return state; };
   /// This method will return a complete list of ClientData objects registered in the framework.
   inline const std::map<unsigned int, ClientData *> & getClientDataObjects() const { return client_data; };
   /// Just a debug method.
   void printPointerPointerMapDebug( ) const { client_data_map->printDebug(); };


public:
   /// Will be called by the pendingacklist when ever we want to retransmit a packet
   virtual void retransmitPacket(FrameworkPacket * packet);

protected: // These must be implemented in a derived class
   /// This method is called just before a connection attempt,
   /// you can write any gamespecific data in the packet for the server to read.
   virtual void writeHandshakeInitMessage(ClientPacket * fp) = 0;
   /// If the server will not let you connect, you can read what ever was written to you.
   virtual void onHandshakingDiscontinue(ClientPacket * fp) = 0;
   /// If the server will let you connect, then here is the packet from the server,
   /// and you can reply in the other packet.
   virtual bool onHandshakeDescription(ClientPacket * fp, ClientPacket * reply) = 0;
   /// Will be called during "keepAlive(...)" if the client has lost the connection
   /// to the server.
   virtual void onDisconnect() = 0;
   /// Will be called during "keepAlive(...)" if the client has successfully
   /// connected to the server.
   virtual void onConnect() = 0;
   /// This method should add a sequence number to the pluginpacket if it does not already have one.
   virtual void addPluginSequenceNumber( ClientPacket * packet);

public:
   unsigned long bytesReceived() const;
   unsigned long packetsReceived() const;
   unsigned long packetsDelivered() const;
   unsigned long getSkippedUnreliablePackets() const;
   unsigned long getSkippedReliablePackets() const;
   unsigned long bytesSent() const;
   unsigned long packetsSent() const;
   unsigned long inQueueSize() const;
   unsigned long outQueueSize() const;
   unsigned long getPendingAckCount() const;
   /// Returns total count of packets buffered due to deliver-in-order
   unsigned int bufferedPackets() const;

};

#endif

---