2010-04-03 07:50:07 +02:00
|
|
|
// ==============================================================
|
|
|
|
// This file is part of Glest (www.glest.org)
|
|
|
|
//
|
2011-12-14 08:40:48 +01:00
|
|
|
// Copyright (C) 2001-2008 Martiño Figueroa
|
2010-04-03 07:50:07 +02:00
|
|
|
//
|
|
|
|
// You can redistribute this code and/or modify it under
|
|
|
|
// the terms of the GNU General Public License as published
|
|
|
|
// by the Free Software Foundation; either version 2 of the
|
|
|
|
// License, or (at your option) any later version
|
|
|
|
// ==============================================================
|
|
|
|
|
|
|
|
#ifndef _GLEST_GAME_CONNECTIONSLOT_H_
|
|
|
|
#define _GLEST_GAME_CONNECTIONSLOT_H_
|
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
#include "socket.h"
|
|
|
|
#include "network_interface.h"
|
2010-05-12 17:25:56 +02:00
|
|
|
#include <time.h>
|
2010-05-28 01:46:38 +02:00
|
|
|
#include "base_thread.h"
|
2010-09-07 07:25:40 +02:00
|
|
|
#include "leak_dumper.h"
|
2010-04-03 07:50:07 +02:00
|
|
|
|
|
|
|
using Shared::Platform::ServerSocket;
|
|
|
|
using Shared::Platform::Socket;
|
|
|
|
using std::vector;
|
|
|
|
|
|
|
|
namespace Glest{ namespace Game{
|
|
|
|
|
|
|
|
class ServerInterface;
|
2010-05-28 01:46:38 +02:00
|
|
|
class ConnectionSlot;
|
|
|
|
|
|
|
|
// =====================================================
|
|
|
|
// class ConnectionSlotThread
|
|
|
|
// =====================================================
|
|
|
|
|
2010-06-03 23:49:41 +02:00
|
|
|
enum ConnectionSlotEventType
|
|
|
|
{
|
|
|
|
eNone,
|
|
|
|
eReceiveSocketData,
|
|
|
|
eSendSocketData
|
|
|
|
};
|
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
class ConnectionSlotEvent {
|
|
|
|
public:
|
|
|
|
|
2010-06-03 09:52:17 +02:00
|
|
|
ConnectionSlotEvent() {
|
2010-06-03 23:49:41 +02:00
|
|
|
eventType = eNone;
|
2010-06-03 09:52:17 +02:00
|
|
|
triggerId = -1;
|
|
|
|
connectionSlot = NULL;
|
|
|
|
networkMessage = NULL;
|
|
|
|
socketTriggered = false;
|
|
|
|
eventCompleted = false;
|
2011-01-11 09:45:58 +01:00
|
|
|
eventId = -1;
|
2010-06-03 09:52:17 +02:00
|
|
|
}
|
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
int64 triggerId;
|
|
|
|
ConnectionSlot* connectionSlot;
|
2010-06-03 23:49:41 +02:00
|
|
|
ConnectionSlotEventType eventType;
|
2012-11-01 01:06:23 +01:00
|
|
|
NetworkMessage *networkMessage;
|
2010-05-28 01:46:38 +02:00
|
|
|
bool socketTriggered;
|
|
|
|
bool eventCompleted;
|
2011-01-11 09:45:58 +01:00
|
|
|
int64 eventId;
|
2010-05-28 01:46:38 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
//
|
|
|
|
// This interface describes the methods a callback object must implement
|
|
|
|
//
|
|
|
|
class ConnectionSlotCallbackInterface {
|
|
|
|
public:
|
2013-03-01 07:52:33 +01:00
|
|
|
virtual bool isClientConnected(int index) = 0;
|
|
|
|
virtual bool getAllowInGameConnections() const = 0;
|
|
|
|
virtual ConnectionSlot *getSlot(int index) = 0;
|
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
virtual void slotUpdateTask(ConnectionSlotEvent *event) = 0;
|
2012-09-22 22:13:57 +02:00
|
|
|
virtual ~ConnectionSlotCallbackInterface() {}
|
2010-05-28 01:46:38 +02:00
|
|
|
};
|
|
|
|
|
2013-01-10 22:16:28 +01:00
|
|
|
class ConnectionSlotThread : public BaseThread, public SlaveThreadControllerInterface
|
2010-05-28 01:46:38 +02:00
|
|
|
{
|
|
|
|
protected:
|
|
|
|
|
|
|
|
ConnectionSlotCallbackInterface *slotInterface;
|
|
|
|
Semaphore semTaskSignalled;
|
2011-12-02 17:07:59 +01:00
|
|
|
Mutex *triggerIdMutex;
|
2011-01-11 09:45:58 +01:00
|
|
|
vector<ConnectionSlotEvent> eventList;
|
2010-06-28 05:17:50 +02:00
|
|
|
int slotIndex;
|
2013-01-10 22:16:28 +01:00
|
|
|
MasterSlaveThreadController *masterController;
|
2010-05-28 01:46:38 +02:00
|
|
|
|
2013-06-04 02:31:41 +02:00
|
|
|
Mutex *triggerGameStarted;
|
|
|
|
bool gameStarted;
|
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
virtual void setQuitStatus(bool value);
|
2011-01-11 09:45:58 +01:00
|
|
|
virtual void setTaskCompleted(int eventId);
|
2010-05-28 01:46:38 +02:00
|
|
|
|
2011-11-23 09:00:09 +01:00
|
|
|
void slotUpdateTask(ConnectionSlotEvent *event);
|
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
public:
|
2011-11-27 06:27:50 +01:00
|
|
|
ConnectionSlotThread(int slotIndex);
|
|
|
|
ConnectionSlotThread(ConnectionSlotCallbackInterface *slotInterface,int slotIndex);
|
2011-12-02 17:07:59 +01:00
|
|
|
virtual ~ConnectionSlotThread();
|
|
|
|
|
2013-06-04 02:31:41 +02:00
|
|
|
bool getGameStarted();
|
|
|
|
void setGameStarted(bool value);
|
|
|
|
|
2013-01-10 22:16:28 +01:00
|
|
|
virtual void setMasterController(MasterSlaveThreadController *master) { masterController = master; }
|
|
|
|
virtual void signalSlave(void *userdata);
|
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
virtual void execute();
|
|
|
|
void signalUpdate(ConnectionSlotEvent *event);
|
2010-12-25 09:14:35 +01:00
|
|
|
bool isSignalCompleted(ConnectionSlotEvent *event);
|
2013-03-06 15:29:49 +01:00
|
|
|
|
2010-06-28 05:17:50 +02:00
|
|
|
int getSlotIndex() const {return slotIndex; }
|
2013-03-06 15:29:49 +01:00
|
|
|
void setSlotIndex(int index) { this->slotIndex = index; }
|
2011-01-11 09:45:58 +01:00
|
|
|
|
|
|
|
void purgeCompletedEvents();
|
2011-01-11 21:02:07 +01:00
|
|
|
void purgeAllEvents();
|
|
|
|
void setAllEventsCompleted();
|
2013-06-04 02:31:41 +02:00
|
|
|
|
|
|
|
virtual bool canShutdown(bool deleteSelfIfShutdownDelayed=false);
|
2010-05-28 01:46:38 +02:00
|
|
|
};
|
2010-04-03 07:50:07 +02:00
|
|
|
|
|
|
|
// =====================================================
|
|
|
|
// class ConnectionSlot
|
|
|
|
// =====================================================
|
|
|
|
|
2011-01-13 09:17:18 +01:00
|
|
|
class ConnectionSlot: public NetworkInterface {
|
2010-04-03 07:50:07 +02:00
|
|
|
private:
|
|
|
|
ServerInterface* serverInterface;
|
2011-11-23 09:00:09 +01:00
|
|
|
|
2011-12-02 17:07:59 +01:00
|
|
|
Mutex *mutexSocket;
|
2010-04-03 07:50:07 +02:00
|
|
|
Socket* socket;
|
|
|
|
int playerIndex;
|
|
|
|
string name;
|
|
|
|
bool ready;
|
2012-07-07 04:46:57 +02:00
|
|
|
vector<std::pair<string,uint32> > vctFileList;
|
2010-04-03 07:50:07 +02:00
|
|
|
bool receivedNetworkGameStatus;
|
2010-05-12 17:25:56 +02:00
|
|
|
time_t connectedTime;
|
|
|
|
bool gotIntro;
|
2010-12-24 09:43:09 +01:00
|
|
|
|
2011-12-02 17:07:59 +01:00
|
|
|
Mutex *mutexCloseConnection;
|
2011-05-20 21:44:33 +02:00
|
|
|
|
2011-12-02 17:07:59 +01:00
|
|
|
Mutex *mutexPendingNetworkCommandList;
|
2010-05-26 07:33:15 +02:00
|
|
|
vector<NetworkCommand> vctPendingNetworkCommandList;
|
2010-05-28 01:46:38 +02:00
|
|
|
ConnectionSlotThread* slotThreadWorker;
|
2010-06-15 07:36:07 +02:00
|
|
|
int currentFrameCount;
|
|
|
|
int currentLagCount;
|
|
|
|
time_t lastReceiveCommandListTime;
|
2010-06-17 02:08:27 +02:00
|
|
|
bool gotLagCountWarning;
|
2010-08-05 07:58:14 +02:00
|
|
|
string versionString;
|
2010-08-23 17:40:43 +02:00
|
|
|
int sessionKey;
|
2010-12-30 16:56:02 +01:00
|
|
|
uint32 connectedRemoteIPAddress;
|
2011-03-11 12:11:46 +01:00
|
|
|
int playerStatus;
|
2011-04-05 20:39:47 +02:00
|
|
|
string playerLanguage;
|
2013-06-01 04:31:12 +02:00
|
|
|
string playerUUID;
|
2010-04-03 07:50:07 +02:00
|
|
|
|
2013-03-14 22:41:15 +01:00
|
|
|
bool skipLagCheck;
|
|
|
|
bool joinGameInProgress;
|
2012-03-20 21:31:41 +01:00
|
|
|
bool canAcceptConnections;
|
2013-02-19 23:00:15 +01:00
|
|
|
bool startInGameConnectionLaunch;
|
|
|
|
bool pauseForInGameConnection;
|
|
|
|
bool unPauseForInGameConnection;
|
2013-02-27 00:31:59 +01:00
|
|
|
bool sentSavedGameInfo;
|
2012-03-20 21:31:41 +01:00
|
|
|
|
2010-04-03 07:50:07 +02:00
|
|
|
public:
|
|
|
|
ConnectionSlot(ServerInterface* serverInterface, int playerIndex);
|
|
|
|
~ConnectionSlot();
|
|
|
|
|
2013-06-04 02:31:41 +02:00
|
|
|
bool getGameStarted();
|
|
|
|
void setGameStarted(bool value);
|
|
|
|
|
2013-02-19 23:00:15 +01:00
|
|
|
bool getStartInGameConnectionLaunch() const { return startInGameConnectionLaunch; }
|
|
|
|
void setStartInGameConnectionLaunch(bool value) { startInGameConnectionLaunch = value; }
|
|
|
|
|
|
|
|
bool getPauseForInGameConnection() const { return pauseForInGameConnection; }
|
|
|
|
void setPauseForInGameConnection(bool value) { pauseForInGameConnection = value; }
|
|
|
|
|
|
|
|
bool getUnPauseForInGameConnection() const { return unPauseForInGameConnection; }
|
|
|
|
void setUnPauseForInGameConnection(bool value) { unPauseForInGameConnection = value; }
|
|
|
|
|
2013-02-15 19:25:10 +01:00
|
|
|
bool getSkipLagCheck() const { return skipLagCheck; }
|
|
|
|
bool getJoinGameInProgress() const { return joinGameInProgress; }
|
|
|
|
|
2013-02-27 00:31:59 +01:00
|
|
|
bool getSentSavedGameInfo() const { return sentSavedGameInfo; }
|
|
|
|
void setSentSavedGameInfo(bool value) { sentSavedGameInfo = value; }
|
|
|
|
|
2013-01-10 22:16:28 +01:00
|
|
|
ConnectionSlotThread *getWorkerThread() { return slotThreadWorker; }
|
|
|
|
|
2011-11-25 22:56:36 +01:00
|
|
|
void update(bool checkForNewClients,int lockedSlotIndex);
|
2013-03-06 15:29:49 +01:00
|
|
|
void setPlayerIndex(int value);
|
2011-09-01 03:11:23 +02:00
|
|
|
int getPlayerIndex() const {return playerIndex;}
|
2010-04-03 07:50:07 +02:00
|
|
|
|
2010-12-30 16:56:02 +01:00
|
|
|
uint32 getConnectedRemoteIPAddress() const { return connectedRemoteIPAddress; }
|
|
|
|
|
2013-02-15 19:25:10 +01:00
|
|
|
void setReady();
|
2010-04-03 07:50:07 +02:00
|
|
|
const string &getName() const {return name;}
|
2013-06-01 04:31:12 +02:00
|
|
|
const string &getUUID() const {return playerUUID;}
|
2010-08-21 15:04:52 +02:00
|
|
|
void setName(string value) {name = value;}
|
2010-04-03 07:50:07 +02:00
|
|
|
bool isReady() const {return ready;}
|
|
|
|
|
2011-11-25 10:12:53 +01:00
|
|
|
virtual Socket* getSocket(bool mutexLock=true);
|
2011-11-25 06:37:55 +01:00
|
|
|
pair<bool,Socket*> getSocketInfo();
|
2010-04-03 07:50:07 +02:00
|
|
|
|
|
|
|
virtual void close();
|
|
|
|
//virtual bool getFogOfWar();
|
|
|
|
|
2011-09-01 03:11:23 +02:00
|
|
|
bool getReceivedNetworkGameStatus() const { return receivedNetworkGameStatus; }
|
2010-04-03 07:50:07 +02:00
|
|
|
void setReceivedNetworkGameStatus(bool value) { receivedNetworkGameStatus = value; }
|
|
|
|
|
2011-11-27 06:27:50 +01:00
|
|
|
bool hasValidSocketId();
|
2010-05-13 09:13:53 +02:00
|
|
|
virtual bool getConnectHasHandshaked() const { return gotIntro; }
|
2010-05-25 20:06:42 +02:00
|
|
|
std::vector<std::string> getThreadErrorList() const { return threadErrorList; }
|
|
|
|
void clearThreadErrorList() { threadErrorList.clear(); }
|
2010-05-21 18:36:08 +02:00
|
|
|
|
2010-12-24 09:43:09 +01:00
|
|
|
vector<NetworkCommand> getPendingNetworkCommandList(bool clearList=false);
|
|
|
|
void clearPendingNetworkCommandList();
|
2010-05-26 07:33:15 +02:00
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
void signalUpdate(ConnectionSlotEvent *event);
|
2010-12-25 09:14:35 +01:00
|
|
|
bool updateCompleted(ConnectionSlotEvent *event);
|
2010-05-28 01:46:38 +02:00
|
|
|
|
2012-11-01 01:06:23 +01:00
|
|
|
virtual void sendMessage(NetworkMessage* networkMessage);
|
2010-06-15 07:36:07 +02:00
|
|
|
int getCurrentFrameCount() const { return currentFrameCount; }
|
|
|
|
|
|
|
|
int getCurrentLagCount() const { return currentLagCount; }
|
|
|
|
void setCurrentLagCount(int value) { currentLagCount = value; }
|
|
|
|
|
|
|
|
time_t getLastReceiveCommandListTime() const { return lastReceiveCommandListTime; }
|
2010-06-03 09:52:17 +02:00
|
|
|
|
2010-06-17 02:08:27 +02:00
|
|
|
bool getLagCountWarning() const { return gotLagCountWarning; }
|
|
|
|
void setLagCountWarning(bool value) { gotLagCountWarning = value; }
|
|
|
|
|
2010-08-05 07:58:14 +02:00
|
|
|
const string &getVersionString() const {return versionString;}
|
|
|
|
|
2010-08-20 22:03:06 +02:00
|
|
|
void validateConnection();
|
2010-08-21 15:04:52 +02:00
|
|
|
virtual string getHumanPlayerName(int index=-1);
|
2010-10-22 09:28:55 +02:00
|
|
|
virtual int getHumanPlayerIndex() const {return playerIndex;}
|
2010-08-20 22:03:06 +02:00
|
|
|
|
2011-03-11 12:11:46 +01:00
|
|
|
int getNetworkPlayerStatus() const { return playerStatus;}
|
|
|
|
|
2011-04-05 20:39:47 +02:00
|
|
|
string getNetworkPlayerLanguage() const { return playerLanguage; }
|
|
|
|
|
2011-09-24 09:46:56 +02:00
|
|
|
time_t getConnectedTime() const { return connectedTime; }
|
|
|
|
int getSessionKey() const { return sessionKey; }
|
|
|
|
|
2011-11-25 22:56:36 +01:00
|
|
|
void updateSlot(ConnectionSlotEvent *event);
|
2011-11-23 09:00:09 +01:00
|
|
|
virtual bool isConnected();
|
|
|
|
|
2011-11-25 00:15:21 +01:00
|
|
|
PLATFORM_SOCKET getSocketId();
|
|
|
|
|
2012-03-20 21:31:41 +01:00
|
|
|
void setCanAcceptConnections(bool value) { canAcceptConnections = value; }
|
|
|
|
bool getCanAcceptConnections() const { return canAcceptConnections; }
|
|
|
|
|
2012-04-13 22:20:40 +02:00
|
|
|
virtual void saveGame(XmlNode *rootNode) {};
|
|
|
|
|
2013-02-16 11:07:36 +01:00
|
|
|
void resetJoinGameInProgressFlags();
|
|
|
|
void setJoinGameInProgressFlags();
|
|
|
|
|
2010-05-21 18:36:08 +02:00
|
|
|
protected:
|
|
|
|
|
|
|
|
Mutex * getServerSynchAccessor();
|
2010-05-25 20:06:42 +02:00
|
|
|
std::vector<std::string> threadErrorList;
|
2011-12-02 17:07:59 +01:00
|
|
|
Mutex *socketSynchAccessor;
|
2011-01-13 09:17:18 +01:00
|
|
|
|
2011-11-23 09:00:09 +01:00
|
|
|
void setSocket(Socket *newSocket);
|
|
|
|
void deleteSocket();
|
2011-01-13 09:17:18 +01:00
|
|
|
virtual void update() {}
|
2011-11-25 22:56:36 +01:00
|
|
|
|
|
|
|
bool hasDataToRead();
|
2010-04-03 07:50:07 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
}}//end namespace
|
|
|
|
|
|
|
|
#endif
|