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;

    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::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::Socket *_broadcastSocket;

    // For creating/joining sessions over the Internet.
    Networking::Host *_sessionServerHost;
    Address _sessionServerAddress;
    bool _forcedAddress;
    bool _gotSessions;
    int _sessionServerPeer;
    bool _isRelayingGame; 
};

} // End of namespace Scumm

#endif