net_main.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef SCUMM_HE_NET_MAIN_H
#define SCUMM_HE_NET_MAIN_H
 
#include "backends/networking/enet/enet.h"
#include "backends/networking/enet/host.h"
#include "backends/networking/enet/socket.h"
#include "common/formats/json.h"
namespace Scumm {
 
class ScummEngine_v90he;
 
class Net {
public:
    Net(ScummEngine_v90he *vm);
    ~Net();
 
private:
    struct Address {
        Common::String host;
        int port;
        bool operator==(const Address &other) {
            return host == other.host && port == other.port;
        };
    };
    struct Session {
        bool local = false; 
        int id = -1;
        Common::String host;
        int port = 0;
        Common::String name;
        int players = 0;
        uint32 timestamp = 0;
 
        // For Moonbase map generation:
        uint8 mapGenerator = 0;
        int mapSeed = 0;
        int mapSize = 0;
        int mapTileset = 0;
        int mapEnergy = 0;
        int mapTerrain = 0;
        int mapWater = 0;
        Common::String encodedMap;
        // Used to query map data over LAN.
        bool getGeneratedMap = false;
    };
    Address getAddressFromString(Common::String address);
    Common::String getStringFromAddress(Address address);
 
public:
    int hostGame(char *sessionName, char *userName);
    int joinGame(Common::String IP, char *userName);
 
    int addUser(char *shortName, char *longName);
    int removeUser();
 
    int whoSentThis();
    int whoAmI();
 
    int createSession(char *name);
    int joinSession(int sessionIndex);
    int joinSessionById(int sessionId);
    int ifSessionExist(int sessionId);
 
    int endSession();
 
    void setSessionServer(Common::String sessionServer);
    void disableSessionJoining();
    void enableSessionJoining();
 
    void setBotsCount(int botsCount);
 
    int32 setProviderByName(int32 parameter1, int32 parameter2);
 
    void setFakeLatency(int time);
 
    bool destroyPlayer(int32 userId);
    int32 startQuerySessions(bool connectToSessionServer = true);
    int32 updateQuerySessions();
    void stopQuerySessions();
    int querySessions();
 
    int queryProviders();
    int setProvider(int providerIndex);
    int closeProvider();
 
    bool initAll();
    bool initProvider();
    bool initSession();
    bool initUser();
 
    void remoteStartScript(int typeOfSend, int sendTypeParam, int priority, int argsCount, int32 *args);
    void remoteSendArray(int typeOfSend, int sendTypeParam, int priority, int arrayIndex);
 
    int remoteStartScriptFunction(int typeOfSend, int sendTypeParam, int priority, int defaultReturnValue, int argsCount, int32 *args);
 
    void doNetworkOnceAFrame(int msecs);
 
private:
    bool connectToSession(Common::String address, int port, bool queryGeneratedMap);
 
    int doJoinSession(Session session);
 
    void generateMoonbaseMap(Session session);
 
    int remoteSendData(int typeOfSend, int sendTypeParam, int type, Common::String data, int priority, int defaultRes = 0, bool wait = false, int callid = 0);
 
    bool serviceBroadcast();
    void handleBroadcastData(Common::String data, Common::String host, int port);
    void serviceSessionServer();
    void handleSessionServerData(Common::String data);
    void remoteReceiveData();
    void handleGameData(Common::JSONValue *json, int peerIndex);
    void handleGameDataHost(Common::JSONValue *json, int peerIndex);
 
public:
    // getters
 
    bool getHostName(char *hostname, int length);
    bool getIPfromName(char *ip, int ipLength, char *nameBuffer);
    void getSessionName(int sessionNumber, char *buffer, int length);
    int getSessionPlayerCount(int sessionNumber);
    void getProviderName(int providerIndex, char *buffer, int length);
 
private:
    // mostly getters
 
    int getTotalPlayers();
 
public:
    // fields
    int _latencyTime; // ms
    bool _fakeLatency;
 
    bool _isHost; // true = hosting game, false = joined game.
 
    int _myUserId;
    int _fromUserId;
 
    int _sessionId; // Session ID received from the session server.
 
private:
    ScummEngine_v90he *_vm;
 
    Common::String _gameName;
    Common::String _gameVersion;
 
    Networking::ENet::ENet *_enet;
 
    byte *_tmpbuffer;
 
    int _numUsers;
    int _numBots;
    int _maxPlayers;
    int _userIdCounter;
    Common::HashMap<int, Common::String> _userIdToName;
    Common::HashMap<int, int> _userIdToPeerIndex;
    Common::HashMap<int, Common::String> _userIdToAddress;
    Common::HashMap<Common::String, int> _addressToUserId;
 
    Common::String _sessionName;
    Networking::ENet::Host *_sessionHost;
 
    // For Moonbase map generation:
    uint8 _mapGenerator;
    int _mapSeed;
    int _mapSize;
    int _mapTileset;
    int _mapEnergy;
    int _mapTerrain;
    int _mapWater;
    Common::String _encodedMap;
 
    bool _isShuttingDown;
 
    Common::Queue<Common::JSONValue *> _hostDataQueue;
    Common::Queue<int> _peerIndexQueue;
 
    Common::Array<Session> _sessions;
    int _hostPort;
 
    // For broadcasting our game session over LAN.
    Networking::ENet::Socket *_broadcastSocket;
 
    // For creating/joining sessions over the Internet.
    Networking::ENet::Host *_sessionServerHost;
    Address _sessionServerAddress;
    bool _forcedAddress;
    bool _gotSessions;
    int _sessionServerPeer;
    bool _isRelayingGame; 
};
 
} // End of namespace Scumm
 
#endif