CVCMIServer.cpp 31 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168
  1. /*
  2. * CVCMIServer.cpp, part of VCMI engine
  3. *
  4. * Authors: listed in file AUTHORS in main folder
  5. *
  6. * License: GNU General Public License v2.0 or later
  7. * Full text of license available in license.txt file, in main folder
  8. *
  9. */
  10. #include "StdInc.h"
  11. #include <boost/asio.hpp>
  12. #include "../lib/filesystem/Filesystem.h"
  13. #include "../lib/mapping/CCampaignHandler.h"
  14. #include "../lib/CThreadHelper.h"
  15. #include "../lib/serializer/Connection.h"
  16. #include "../lib/CModHandler.h"
  17. #include "../lib/CArtHandler.h"
  18. #include "../lib/CGeneralTextHandler.h"
  19. #include "../lib/CHeroHandler.h"
  20. #include "../lib/CTownHandler.h"
  21. #include "../lib/CBuildingHandler.h"
  22. #include "../lib/spells/CSpellHandler.h"
  23. #include "../lib/CCreatureHandler.h"
  24. #include "zlib.h"
  25. #include "CVCMIServer.h"
  26. #include "../lib/StartInfo.h"
  27. #include "../lib/mapping/CMapHeader.h"
  28. #include "../lib/rmg/CMapGenOptions.h"
  29. #include "../lib/NetPackVisitor.h"
  30. #include "LobbyNetPackVisitors.h"
  31. #ifdef VCMI_ANDROID
  32. #include <jni.h>
  33. #include <android/log.h>
  34. #include "lib/CAndroidVMHelper.h"
  35. #elif !defined(VCMI_IOS)
  36. #include "../lib/Interprocess.h"
  37. #endif
  38. #include "../lib/VCMI_Lib.h"
  39. #include "../lib/VCMIDirs.h"
  40. #include "CGameHandler.h"
  41. #include "../lib/mapping/CMapInfo.h"
  42. #include "../lib/GameConstants.h"
  43. #include "../lib/logging/CBasicLogConfigurator.h"
  44. #include "../lib/CConfigHandler.h"
  45. #include "../lib/ScopeGuard.h"
  46. #include "../lib/serializer/CMemorySerializer.h"
  47. #include "../lib/serializer/Cast.h"
  48. #include "../lib/UnlockGuard.h"
  49. // for applier
  50. #include "../lib/registerTypes/RegisterTypes.h"
  51. // UUID generation
  52. #include <boost/uuid/uuid.hpp>
  53. #include <boost/uuid/uuid_io.hpp>
  54. #include <boost/uuid/uuid_generators.hpp>
  55. #include "../lib/gameState/CGameState.h"
  56. template<typename T> class CApplyOnServer;
  57. class CBaseForServerApply
  58. {
  59. public:
  60. virtual bool applyOnServerBefore(CVCMIServer * srv, void * pack) const =0;
  61. virtual void applyOnServerAfter(CVCMIServer * srv, void * pack) const =0;
  62. virtual ~CBaseForServerApply() {}
  63. template<typename U> static CBaseForServerApply * getApplier(const U * t = nullptr)
  64. {
  65. return new CApplyOnServer<U>();
  66. }
  67. };
  68. template <typename T> class CApplyOnServer : public CBaseForServerApply
  69. {
  70. public:
  71. bool applyOnServerBefore(CVCMIServer * srv, void * pack) const override
  72. {
  73. T * ptr = static_cast<T *>(pack);
  74. ClientPermissionsCheckerNetPackVisitor checker(*srv);
  75. ptr->visit(checker);
  76. if(checker.getResult())
  77. {
  78. boost::unique_lock<boost::mutex> stateLock(srv->stateMutex);
  79. ApplyOnServerNetPackVisitor applier(*srv);
  80. ptr->visit(applier);
  81. return applier.getResult();
  82. }
  83. else
  84. return false;
  85. }
  86. void applyOnServerAfter(CVCMIServer * srv, void * pack) const override
  87. {
  88. T * ptr = static_cast<T *>(pack);
  89. ApplyOnServerAfterAnnounceNetPackVisitor applier(*srv);
  90. ptr->visit(applier);
  91. }
  92. };
  93. template <>
  94. class CApplyOnServer<CPack> : public CBaseForServerApply
  95. {
  96. public:
  97. bool applyOnServerBefore(CVCMIServer * srv, void * pack) const override
  98. {
  99. logGlobal->error("Cannot apply plain CPack!");
  100. assert(0);
  101. return false;
  102. }
  103. void applyOnServerAfter(CVCMIServer * srv, void * pack) const override
  104. {
  105. logGlobal->error("Cannot apply plain CPack!");
  106. assert(0);
  107. }
  108. };
  109. std::string SERVER_NAME_AFFIX = "server";
  110. std::string SERVER_NAME = GameConstants::VCMI_VERSION + std::string(" (") + SERVER_NAME_AFFIX + ')';
  111. CVCMIServer::CVCMIServer(boost::program_options::variables_map & opts)
  112. : port(3030), io(std::make_shared<boost::asio::io_service>()), state(EServerState::LOBBY), cmdLineOptions(opts), currentClientId(1), currentPlayerId(1), restartGameplay(false)
  113. {
  114. uuid = boost::uuids::to_string(boost::uuids::random_generator()());
  115. logNetwork->trace("CVCMIServer created! UUID: %s", uuid);
  116. applier = std::make_shared<CApplier<CBaseForServerApply>>();
  117. registerTypesLobbyPacks(*applier);
  118. if(cmdLineOptions.count("port"))
  119. port = cmdLineOptions["port"].as<ui16>();
  120. logNetwork->info("Port %d will be used", port);
  121. try
  122. {
  123. acceptor = std::make_shared<TAcceptor>(*io, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
  124. }
  125. catch(...)
  126. {
  127. logNetwork->info("Port %d is busy, trying to use random port instead", port);
  128. if(cmdLineOptions.count("run-by-client") && !cmdLineOptions.count("enable-shm"))
  129. {
  130. logNetwork->error("Cant pass port number to client without shared memory!", port);
  131. exit(0);
  132. }
  133. acceptor = std::make_shared<TAcceptor>(*io, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0));
  134. port = acceptor->local_endpoint().port();
  135. }
  136. logNetwork->info("Listening for connections at port %d", port);
  137. }
  138. CVCMIServer::~CVCMIServer()
  139. {
  140. announceQueue.clear();
  141. if(announceLobbyThread)
  142. announceLobbyThread->join();
  143. }
  144. void CVCMIServer::run()
  145. {
  146. if(!restartGameplay)
  147. {
  148. this->announceLobbyThread = std::make_unique<boost::thread>(&CVCMIServer::threadAnnounceLobby, this);
  149. #if !defined(VCMI_MOBILE)
  150. if(cmdLineOptions.count("enable-shm"))
  151. {
  152. std::string sharedMemoryName = "vcmi_memory";
  153. if(cmdLineOptions.count("enable-shm-uuid") && cmdLineOptions.count("uuid"))
  154. {
  155. sharedMemoryName += "_" + cmdLineOptions["uuid"].as<std::string>();
  156. }
  157. shm = std::make_shared<SharedMemory>(sharedMemoryName);
  158. }
  159. #endif
  160. startAsyncAccept();
  161. if(!remoteConnectionsThread && cmdLineOptions.count("lobby"))
  162. {
  163. remoteConnectionsThread = std::make_unique<boost::thread>(&CVCMIServer::establishRemoteConnections, this);
  164. }
  165. #if defined(VCMI_ANDROID)
  166. #ifndef SINGLE_PROCESS_APP
  167. CAndroidVMHelper vmHelper;
  168. vmHelper.callStaticVoidMethod(CAndroidVMHelper::NATIVE_METHODS_DEFAULT_CLASS, "onServerReady");
  169. #endif
  170. #elif !defined(VCMI_IOS)
  171. if(shm)
  172. {
  173. shm->sr->setToReadyAndNotify(port);
  174. }
  175. #endif
  176. }
  177. while(state == EServerState::LOBBY || state == EServerState::GAMEPLAY_STARTING)
  178. boost::this_thread::sleep(boost::posix_time::milliseconds(50));
  179. logNetwork->info("Thread handling connections ended");
  180. if(state == EServerState::GAMEPLAY)
  181. {
  182. gh->run(si->mode == StartInfo::LOAD_GAME);
  183. }
  184. while(state == EServerState::GAMEPLAY_ENDED)
  185. boost::this_thread::sleep(boost::posix_time::milliseconds(50));
  186. }
  187. void CVCMIServer::establishRemoteConnections()
  188. {
  189. //wait for host connection
  190. while(connections.empty())
  191. boost::this_thread::sleep(boost::posix_time::milliseconds(50));
  192. uuid = cmdLineOptions["lobby-uuid"].as<std::string>();
  193. int numOfConnections = cmdLineOptions["connections"].as<ui16>();
  194. auto address = cmdLineOptions["lobby"].as<std::string>();
  195. int port = cmdLineOptions["lobby-port"].as<ui16>();
  196. logGlobal->info("Server is connecting to remote at %s:%d with uuid %s %d times", address, port, uuid, numOfConnections);
  197. for(int i = 0; i < numOfConnections; ++i)
  198. connectToRemote(address, port);
  199. }
  200. void CVCMIServer::connectToRemote(const std::string & addr, int port)
  201. {
  202. std::shared_ptr<CConnection> c;
  203. try
  204. {
  205. logNetwork->info("Establishing connection...");
  206. c = std::make_shared<CConnection>(addr, port, SERVER_NAME, uuid);
  207. }
  208. catch(...)
  209. {
  210. logNetwork->error("\nCannot establish remote connection!");
  211. }
  212. if(c)
  213. {
  214. connections.insert(c);
  215. c->handler = std::make_shared<boost::thread>(&CVCMIServer::threadHandleClient, this, c);
  216. }
  217. }
  218. void CVCMIServer::threadAnnounceLobby()
  219. {
  220. while(state != EServerState::SHUTDOWN)
  221. {
  222. {
  223. boost::unique_lock<boost::recursive_mutex> myLock(mx);
  224. while(!announceQueue.empty())
  225. {
  226. announcePack(std::move(announceQueue.front()));
  227. announceQueue.pop_front();
  228. }
  229. if(acceptor)
  230. {
  231. io->reset();
  232. io->poll();
  233. }
  234. }
  235. boost::this_thread::sleep(boost::posix_time::milliseconds(50));
  236. }
  237. }
  238. void CVCMIServer::prepareToRestart()
  239. {
  240. if(state == EServerState::GAMEPLAY)
  241. {
  242. restartGameplay = true;
  243. * si = * gh->gs->initialOpts;
  244. si->seedToBeUsed = si->seedPostInit = 0;
  245. state = EServerState::LOBBY;
  246. // FIXME: dirry hack to make sure old CGameHandler::run is finished
  247. boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
  248. }
  249. for(auto c : connections)
  250. {
  251. c->enterLobbyConnectionMode();
  252. c->disableStackSendingByID();
  253. }
  254. boost::unique_lock<boost::recursive_mutex> queueLock(mx);
  255. gh = nullptr;
  256. }
  257. bool CVCMIServer::prepareToStartGame()
  258. {
  259. gh = std::make_shared<CGameHandler>(this);
  260. switch(si->mode)
  261. {
  262. case StartInfo::CAMPAIGN:
  263. logNetwork->info("Preparing to start new campaign");
  264. si->campState->currentMap = std::make_optional(campaignMap);
  265. si->campState->chosenCampaignBonuses[campaignMap] = campaignBonus;
  266. gh->init(si.get());
  267. break;
  268. case StartInfo::NEW_GAME:
  269. logNetwork->info("Preparing to start new game");
  270. gh->init(si.get());
  271. break;
  272. case StartInfo::LOAD_GAME:
  273. logNetwork->info("Preparing to start loaded game");
  274. if(!gh->load(si->mapname))
  275. return false;
  276. break;
  277. default:
  278. logNetwork->error("Wrong mode in StartInfo!");
  279. assert(0);
  280. break;
  281. }
  282. state = EServerState::GAMEPLAY_STARTING;
  283. return true;
  284. }
  285. void CVCMIServer::startGameImmidiately()
  286. {
  287. for(auto c : connections)
  288. c->enterGameplayConnectionMode(gh->gs);
  289. state = EServerState::GAMEPLAY;
  290. }
  291. void CVCMIServer::startAsyncAccept()
  292. {
  293. assert(!upcomingConnection);
  294. assert(acceptor);
  295. #if BOOST_VERSION >= 107000 // Boost version >= 1.70
  296. upcomingConnection = std::make_shared<TSocket>(acceptor->get_executor());
  297. #else
  298. upcomingConnection = std::make_shared<TSocket>(acceptor->get_io_service());
  299. #endif
  300. acceptor->async_accept(*upcomingConnection, std::bind(&CVCMIServer::connectionAccepted, this, _1));
  301. }
  302. void CVCMIServer::connectionAccepted(const boost::system::error_code & ec)
  303. {
  304. if(ec)
  305. {
  306. if(state != EServerState::SHUTDOWN)
  307. logNetwork->info("Something wrong during accepting: %s", ec.message());
  308. return;
  309. }
  310. try
  311. {
  312. if(state == EServerState::LOBBY || !hangingConnections.empty())
  313. {
  314. logNetwork->info("We got a new connection! :)");
  315. auto c = std::make_shared<CConnection>(upcomingConnection, SERVER_NAME, uuid);
  316. upcomingConnection.reset();
  317. connections.insert(c);
  318. c->handler = std::make_shared<boost::thread>(&CVCMIServer::threadHandleClient, this, c);
  319. }
  320. }
  321. catch(std::exception & e)
  322. {
  323. logNetwork->error("Failure processing new connection! %s", e.what());
  324. upcomingConnection.reset();
  325. }
  326. startAsyncAccept();
  327. }
  328. class CVCMIServerPackVisitor : public VCMI_LIB_WRAP_NAMESPACE(ICPackVisitor)
  329. {
  330. private:
  331. CVCMIServer & handler;
  332. std::shared_ptr<CGameHandler> gh;
  333. public:
  334. CVCMIServerPackVisitor(CVCMIServer & handler, std::shared_ptr<CGameHandler> gh)
  335. :handler(handler), gh(gh)
  336. {
  337. }
  338. virtual bool callTyped() override { return false; }
  339. virtual void visitForLobby(CPackForLobby & packForLobby) override
  340. {
  341. handler.handleReceivedPack(std::unique_ptr<CPackForLobby>(&packForLobby));
  342. }
  343. virtual void visitForServer(CPackForServer & serverPack) override
  344. {
  345. if (gh)
  346. gh->handleReceivedPack(&serverPack);
  347. else
  348. logNetwork->error("Received pack for game server while in lobby!");
  349. }
  350. virtual void visitForClient(CPackForClient & clientPack) override
  351. {
  352. }
  353. };
  354. void CVCMIServer::threadHandleClient(std::shared_ptr<CConnection> c)
  355. {
  356. setThreadName("CVCMIServer::handleConnection");
  357. c->enterLobbyConnectionMode();
  358. #ifndef _MSC_VER
  359. try
  360. {
  361. #endif
  362. while(c->connected)
  363. {
  364. CPack * pack;
  365. try
  366. {
  367. pack = c->retrievePack();
  368. }
  369. catch(boost::system::system_error & e)
  370. {
  371. logNetwork->error("Network error receiving a pack. Connection %s dies. What happened: %s", c->toString(), e.what());
  372. hangingConnections.insert(c);
  373. connections.erase(c);
  374. if(connections.empty() || hostClient == c)
  375. state = EServerState::SHUTDOWN;
  376. if(gh && state == EServerState::GAMEPLAY)
  377. {
  378. gh->handleClientDisconnection(c);
  379. }
  380. break;
  381. }
  382. CVCMIServerPackVisitor visitor(*this, this->gh);
  383. pack->visit(visitor);
  384. }
  385. #ifndef _MSC_VER
  386. }
  387. catch(const std::exception & e)
  388. {
  389. (void)e;
  390. boost::unique_lock<boost::recursive_mutex> queueLock(mx);
  391. logNetwork->error("%s dies... \nWhat happened: %s", c->toString(), e.what());
  392. }
  393. catch(...)
  394. {
  395. state = EServerState::SHUTDOWN;
  396. handleException();
  397. throw;
  398. }
  399. #endif
  400. boost::unique_lock<boost::recursive_mutex> queueLock(mx);
  401. // if(state != ENDING_AND_STARTING_GAME)
  402. if(c->connected)
  403. {
  404. auto lcd = std::make_unique<LobbyClientDisconnected>();
  405. lcd->c = c;
  406. lcd->clientId = c->connectionID;
  407. handleReceivedPack(std::move(lcd));
  408. }
  409. logNetwork->info("Thread listening for %s ended", c->toString());
  410. c->handler.reset();
  411. }
  412. void CVCMIServer::handleReceivedPack(std::unique_ptr<CPackForLobby> pack)
  413. {
  414. CBaseForServerApply * apply = applier->getApplier(typeList.getTypeID(pack.get()));
  415. if(apply->applyOnServerBefore(this, pack.get()))
  416. addToAnnounceQueue(std::move(pack));
  417. }
  418. void CVCMIServer::announcePack(std::unique_ptr<CPackForLobby> pack)
  419. {
  420. for(auto c : connections)
  421. {
  422. // FIXME: we need to avoid sending something to client that not yet get answer for LobbyClientConnected
  423. // Until UUID set we only pass LobbyClientConnected to this client
  424. if(c->uuid == uuid && !dynamic_cast<LobbyClientConnected *>(pack.get()))
  425. continue;
  426. c->sendPack(pack.get());
  427. }
  428. applier->getApplier(typeList.getTypeID(pack.get()))->applyOnServerAfter(this, pack.get());
  429. }
  430. void CVCMIServer::announceMessage(const std::string & txt)
  431. {
  432. logNetwork->info("Show message: %s", txt);
  433. auto cm = std::make_unique<LobbyShowMessage>();
  434. cm->message = txt;
  435. addToAnnounceQueue(std::move(cm));
  436. }
  437. void CVCMIServer::announceTxt(const std::string & txt, const std::string & playerName)
  438. {
  439. logNetwork->info("%s says: %s", playerName, txt);
  440. auto cm = std::make_unique<LobbyChatMessage>();
  441. cm->playerName = playerName;
  442. cm->message = txt;
  443. addToAnnounceQueue(std::move(cm));
  444. }
  445. void CVCMIServer::addToAnnounceQueue(std::unique_ptr<CPackForLobby> pack)
  446. {
  447. boost::unique_lock<boost::recursive_mutex> queueLock(mx);
  448. announceQueue.push_back(std::move(pack));
  449. }
  450. bool CVCMIServer::passHost(int toConnectionId)
  451. {
  452. for(auto c : connections)
  453. {
  454. if(isClientHost(c->connectionID))
  455. continue;
  456. if(c->connectionID != toConnectionId)
  457. continue;
  458. hostClient = c;
  459. hostClientId = c->connectionID;
  460. announceTxt(boost::str(boost::format("Pass host to connection %d") % toConnectionId));
  461. return true;
  462. }
  463. return false;
  464. }
  465. void CVCMIServer::clientConnected(std::shared_ptr<CConnection> c, std::vector<std::string> & names, std::string uuid, StartInfo::EMode mode)
  466. {
  467. if(state == EServerState::LOBBY)
  468. c->connectionID = currentClientId++;
  469. if(!hostClient)
  470. {
  471. hostClient = c;
  472. hostClientId = c->connectionID;
  473. si->mode = mode;
  474. }
  475. logNetwork->info("Connection with client %d established. UUID: %s", c->connectionID, c->uuid);
  476. if(state == EServerState::LOBBY)
  477. {
  478. for(auto & name : names)
  479. {
  480. logNetwork->info("Client %d player: %s", c->connectionID, name);
  481. ui8 id = currentPlayerId++;
  482. ClientPlayer cp;
  483. cp.connection = c->connectionID;
  484. cp.name = name;
  485. playerNames.insert(std::make_pair(id, cp));
  486. announceTxt(boost::str(boost::format("%s (pid %d cid %d) joins the game") % name % id % c->connectionID));
  487. //put new player in first slot with AI
  488. for(auto & elem : si->playerInfos)
  489. {
  490. if(elem.second.isControlledByAI() && !elem.second.compOnly)
  491. {
  492. setPlayerConnectedId(elem.second, id);
  493. break;
  494. }
  495. }
  496. }
  497. }
  498. }
  499. void CVCMIServer::clientDisconnected(std::shared_ptr<CConnection> c)
  500. {
  501. connections -= c;
  502. if(connections.empty() || hostClient == c)
  503. {
  504. state = EServerState::SHUTDOWN;
  505. return;
  506. }
  507. PlayerReinitInterface startAiPack;
  508. startAiPack.playerConnectionId = PlayerSettings::PLAYER_AI;
  509. for(auto it = playerNames.begin(); it != playerNames.end();)
  510. {
  511. if(it->second.connection != c->connectionID)
  512. {
  513. ++it;
  514. continue;
  515. }
  516. int id = it->first;
  517. std::string playerLeftMsgText = boost::str(boost::format("%s (pid %d cid %d) left the game") % id % playerNames[id].name % c->connectionID);
  518. announceTxt(playerLeftMsgText); //send lobby text, it will be ignored for non-lobby clients
  519. auto * playerSettings = si->getPlayersSettings(id);
  520. if(!playerSettings)
  521. {
  522. ++it;
  523. continue;
  524. }
  525. it = playerNames.erase(it);
  526. setPlayerConnectedId(*playerSettings, PlayerSettings::PLAYER_AI);
  527. if(gh && si && state == EServerState::GAMEPLAY)
  528. {
  529. gh->playerMessage(playerSettings->color, playerLeftMsgText, ObjectInstanceID{});
  530. gh->connections[playerSettings->color].insert(hostClient);
  531. startAiPack.players.push_back(playerSettings->color);
  532. }
  533. }
  534. if(!startAiPack.players.empty())
  535. gh->sendAndApply(&startAiPack);
  536. }
  537. void CVCMIServer::reconnectPlayer(int connId)
  538. {
  539. PlayerReinitInterface startAiPack;
  540. startAiPack.playerConnectionId = connId;
  541. if(gh && si && state == EServerState::GAMEPLAY)
  542. {
  543. for(auto it = playerNames.begin(); it != playerNames.end(); ++it)
  544. {
  545. if(it->second.connection != connId)
  546. continue;
  547. int id = it->first;
  548. auto * playerSettings = si->getPlayersSettings(id);
  549. if(!playerSettings)
  550. continue;
  551. std::string messageText = boost::str(boost::format("%s (cid %d) is connected") % playerSettings->name % connId);
  552. gh->playerMessage(playerSettings->color, messageText, ObjectInstanceID{});
  553. startAiPack.players.push_back(playerSettings->color);
  554. }
  555. if(!startAiPack.players.empty())
  556. gh->sendAndApply(&startAiPack);
  557. }
  558. }
  559. void CVCMIServer::setPlayerConnectedId(PlayerSettings & pset, ui8 player) const
  560. {
  561. if(vstd::contains(playerNames, player))
  562. pset.name = playerNames.find(player)->second.name;
  563. else
  564. pset.name = VLC->generaltexth->allTexts[468]; //Computer
  565. pset.connectedPlayerIDs.clear();
  566. if(player != PlayerSettings::PLAYER_AI)
  567. pset.connectedPlayerIDs.insert(player);
  568. }
  569. void CVCMIServer::updateStartInfoOnMapChange(std::shared_ptr<CMapInfo> mapInfo, std::shared_ptr<CMapGenOptions> mapGenOpts)
  570. {
  571. mi = mapInfo;
  572. if(!mi)
  573. return;
  574. auto namesIt = playerNames.cbegin();
  575. si->playerInfos.clear();
  576. if(mi->scenarioOptionsOfSave)
  577. {
  578. si = CMemorySerializer::deepCopy(*mi->scenarioOptionsOfSave);
  579. si->mode = StartInfo::LOAD_GAME;
  580. if(si->campState)
  581. campaignMap = si->campState->currentMap.value();
  582. for(auto & ps : si->playerInfos)
  583. {
  584. if(!ps.second.compOnly && ps.second.connectedPlayerIDs.size() && namesIt != playerNames.cend())
  585. {
  586. setPlayerConnectedId(ps.second, namesIt++->first);
  587. }
  588. else
  589. {
  590. setPlayerConnectedId(ps.second, PlayerSettings::PLAYER_AI);
  591. }
  592. }
  593. }
  594. else if(si->mode == StartInfo::NEW_GAME || si->mode == StartInfo::CAMPAIGN)
  595. {
  596. if(mi->campaignHeader)
  597. return;
  598. for(int i = 0; i < mi->mapHeader->players.size(); i++)
  599. {
  600. const PlayerInfo & pinfo = mi->mapHeader->players[i];
  601. //neither computer nor human can play - no player
  602. if(!(pinfo.canHumanPlay || pinfo.canComputerPlay))
  603. continue;
  604. PlayerSettings & pset = si->playerInfos[PlayerColor(i)];
  605. pset.color = PlayerColor(i);
  606. if(pinfo.canHumanPlay && namesIt != playerNames.cend())
  607. {
  608. setPlayerConnectedId(pset, namesIt++->first);
  609. }
  610. else
  611. {
  612. setPlayerConnectedId(pset, PlayerSettings::PLAYER_AI);
  613. if(!pinfo.canHumanPlay)
  614. {
  615. pset.compOnly = true;
  616. }
  617. }
  618. pset.castle = pinfo.defaultCastle();
  619. pset.hero = pinfo.defaultHero();
  620. if(pset.hero != PlayerSettings::RANDOM && pinfo.hasCustomMainHero())
  621. {
  622. pset.hero = pinfo.mainCustomHeroId;
  623. pset.heroName = pinfo.mainCustomHeroName;
  624. pset.heroPortrait = pinfo.mainCustomHeroPortrait;
  625. }
  626. pset.handicap = PlayerSettings::NO_HANDICAP;
  627. }
  628. if(mi->isRandomMap && mapGenOpts)
  629. si->mapGenOptions = std::shared_ptr<CMapGenOptions>(mapGenOpts);
  630. else
  631. si->mapGenOptions.reset();
  632. }
  633. si->mapname = mi->fileURI;
  634. }
  635. void CVCMIServer::updateAndPropagateLobbyState()
  636. {
  637. boost::unique_lock<boost::mutex> stateLock(stateMutex);
  638. // Update player settings for RMG
  639. // TODO: find appropriate location for this code
  640. if(si->mapGenOptions && si->mode == StartInfo::NEW_GAME)
  641. {
  642. for(const auto & psetPair : si->playerInfos)
  643. {
  644. const auto & pset = psetPair.second;
  645. si->mapGenOptions->setStartingTownForPlayer(pset.color, pset.castle);
  646. if(pset.isControlledByHuman())
  647. {
  648. si->mapGenOptions->setPlayerTypeForStandardPlayer(pset.color, EPlayerType::HUMAN);
  649. }
  650. }
  651. }
  652. auto lus = std::make_unique<LobbyUpdateState>();
  653. lus->state = *this;
  654. addToAnnounceQueue(std::move(lus));
  655. }
  656. void CVCMIServer::setPlayer(PlayerColor clickedColor)
  657. {
  658. struct PlayerToRestore
  659. {
  660. PlayerColor color;
  661. int id;
  662. void reset() { id = -1; color = PlayerColor::CANNOT_DETERMINE; }
  663. PlayerToRestore(){ reset(); }
  664. } playerToRestore;
  665. PlayerSettings & clicked = si->playerInfos[clickedColor];
  666. //identify clicked player
  667. int clickedNameID = 0; //number of player - zero means AI, assume it initially
  668. if(clicked.isControlledByHuman())
  669. clickedNameID = *(clicked.connectedPlayerIDs.begin()); //if not AI - set appropiate ID
  670. if(clickedNameID > 0 && playerToRestore.id == clickedNameID) //player to restore is about to being replaced -> put him back to the old place
  671. {
  672. PlayerSettings & restPos = si->playerInfos[playerToRestore.color];
  673. setPlayerConnectedId(restPos, playerToRestore.id);
  674. playerToRestore.reset();
  675. }
  676. int newPlayer; //which player will take clicked position
  677. //who will be put here?
  678. if(!clickedNameID) //AI player clicked -> if possible replace computer with unallocated player
  679. {
  680. newPlayer = getIdOfFirstUnallocatedPlayer();
  681. if(!newPlayer) //no "free" player -> get just first one
  682. newPlayer = playerNames.begin()->first;
  683. }
  684. else //human clicked -> take next
  685. {
  686. auto i = playerNames.find(clickedNameID); //clicked one
  687. i++; //player AFTER clicked one
  688. if(i != playerNames.end())
  689. newPlayer = i->first;
  690. else
  691. newPlayer = 0; //AI if we scrolled through all players
  692. }
  693. setPlayerConnectedId(clicked, newPlayer); //put player
  694. //if that player was somewhere else, we need to replace him with computer
  695. if(newPlayer) //not AI
  696. {
  697. for(auto i = si->playerInfos.begin(); i != si->playerInfos.end(); i++)
  698. {
  699. int curNameID = *(i->second.connectedPlayerIDs.begin());
  700. if(i->first != clickedColor && curNameID == newPlayer)
  701. {
  702. assert(i->second.connectedPlayerIDs.size());
  703. playerToRestore.color = i->first;
  704. playerToRestore.id = newPlayer;
  705. setPlayerConnectedId(i->second, PlayerSettings::PLAYER_AI); //set computer
  706. break;
  707. }
  708. }
  709. }
  710. }
  711. void CVCMIServer::optionNextCastle(PlayerColor player, int dir)
  712. {
  713. PlayerSettings & s = si->playerInfos[player];
  714. si16 & cur = s.castle;
  715. auto & allowed = getPlayerInfo(player.getNum()).allowedFactions;
  716. const bool allowRandomTown = getPlayerInfo(player.getNum()).isFactionRandom;
  717. if(cur == PlayerSettings::NONE) //no change
  718. return;
  719. if(cur == PlayerSettings::RANDOM) //first/last available
  720. {
  721. if(dir > 0)
  722. cur = *allowed.begin(); //id of first town
  723. else
  724. cur = *allowed.rbegin(); //id of last town
  725. }
  726. else // next/previous available
  727. {
  728. if((cur == *allowed.begin() && dir < 0) || (cur == *allowed.rbegin() && dir > 0))
  729. {
  730. if(allowRandomTown)
  731. {
  732. cur = PlayerSettings::RANDOM;
  733. }
  734. else
  735. {
  736. if(dir > 0)
  737. cur = *allowed.begin();
  738. else
  739. cur = *allowed.rbegin();
  740. }
  741. }
  742. else
  743. {
  744. assert(dir >= -1 && dir <= 1); //othervice std::advance may go out of range
  745. auto iter = allowed.find(FactionID(cur));
  746. std::advance(iter, dir);
  747. cur = *iter;
  748. }
  749. }
  750. if(s.hero >= 0 && !getPlayerInfo(player.getNum()).hasCustomMainHero()) // remove hero unless it set to fixed one in map editor
  751. {
  752. s.hero = PlayerSettings::RANDOM;
  753. }
  754. if(cur < 0 && s.bonus == PlayerSettings::RESOURCE)
  755. s.bonus = PlayerSettings::RANDOM;
  756. }
  757. void CVCMIServer::setCampaignMap(CampaignScenarioID mapId)
  758. {
  759. campaignMap = mapId;
  760. si->difficulty = si->campState->scenarios[mapId].difficulty;
  761. campaignBonus = -1;
  762. updateStartInfoOnMapChange(si->campState->getMapInfo(mapId));
  763. }
  764. void CVCMIServer::setCampaignBonus(int bonusId)
  765. {
  766. campaignBonus = bonusId;
  767. const CampaignScenario & scenario = si->campState->scenarios[campaignMap];
  768. const std::vector<CampaignBonus> & bonDescs = scenario.travelOptions.bonusesToChoose;
  769. if(bonDescs[bonusId].type == CampaignBonusType::HERO)
  770. {
  771. for(auto & elem : si->playerInfos)
  772. {
  773. if(elem.first == PlayerColor(bonDescs[bonusId].info1))
  774. setPlayerConnectedId(elem.second, 1);
  775. else
  776. setPlayerConnectedId(elem.second, PlayerSettings::PLAYER_AI);
  777. }
  778. }
  779. }
  780. void CVCMIServer::optionNextHero(PlayerColor player, int dir)
  781. {
  782. PlayerSettings & s = si->playerInfos[player];
  783. if(s.castle < 0 || s.hero == PlayerSettings::NONE)
  784. return;
  785. if(s.hero == PlayerSettings::RANDOM) // first/last available
  786. {
  787. int max = static_cast<int>(VLC->heroh->size()),
  788. min = 0;
  789. s.hero = nextAllowedHero(player, min, max, 0, dir);
  790. }
  791. else
  792. {
  793. if(dir > 0)
  794. s.hero = nextAllowedHero(player, s.hero, (int)VLC->heroh->size(), 1, dir);
  795. else
  796. s.hero = nextAllowedHero(player, -1, s.hero, 1, dir); // min needs to be -1 -- hero at index 0 would be skipped otherwise
  797. }
  798. }
  799. int CVCMIServer::nextAllowedHero(PlayerColor player, int min, int max, int incl, int dir)
  800. {
  801. if(dir > 0)
  802. {
  803. for(int i = min + incl; i <= max - incl; i++)
  804. if(canUseThisHero(player, i))
  805. return i;
  806. }
  807. else
  808. {
  809. for(int i = max - incl; i >= min + incl; i--)
  810. if(canUseThisHero(player, i))
  811. return i;
  812. }
  813. return -1;
  814. }
  815. void CVCMIServer::optionNextBonus(PlayerColor player, int dir)
  816. {
  817. PlayerSettings & s = si->playerInfos[player];
  818. PlayerSettings::Ebonus & ret = s.bonus = static_cast<PlayerSettings::Ebonus>(static_cast<int>(s.bonus) + dir);
  819. if(s.hero == PlayerSettings::NONE &&
  820. !getPlayerInfo(player.getNum()).heroesNames.size() &&
  821. ret == PlayerSettings::ARTIFACT) //no hero - can't be artifact
  822. {
  823. if(dir < 0)
  824. ret = PlayerSettings::RANDOM;
  825. else
  826. ret = PlayerSettings::GOLD;
  827. }
  828. if(ret > PlayerSettings::RESOURCE)
  829. ret = PlayerSettings::RANDOM;
  830. if(ret < PlayerSettings::RANDOM)
  831. ret = PlayerSettings::RESOURCE;
  832. if(s.castle == PlayerSettings::RANDOM && ret == PlayerSettings::RESOURCE) //random castle - can't be resource
  833. {
  834. if(dir < 0)
  835. ret = PlayerSettings::GOLD;
  836. else
  837. ret = PlayerSettings::RANDOM;
  838. }
  839. }
  840. bool CVCMIServer::canUseThisHero(PlayerColor player, int ID)
  841. {
  842. return VLC->heroh->size() > ID
  843. && si->playerInfos[player].castle == VLC->heroh->objects[ID]->heroClass->faction
  844. && !vstd::contains(getUsedHeroes(), ID)
  845. && mi->mapHeader->allowedHeroes[ID];
  846. }
  847. std::vector<int> CVCMIServer::getUsedHeroes()
  848. {
  849. std::vector<int> heroIds;
  850. for(auto & p : si->playerInfos)
  851. {
  852. const auto & heroes = getPlayerInfo(p.first.getNum()).heroesNames;
  853. for(auto & hero : heroes)
  854. if(hero.heroId >= 0) //in VCMI map format heroId = -1 means random hero
  855. heroIds.push_back(hero.heroId);
  856. if(p.second.hero != PlayerSettings::RANDOM)
  857. heroIds.push_back(p.second.hero);
  858. }
  859. return heroIds;
  860. }
  861. ui8 CVCMIServer::getIdOfFirstUnallocatedPlayer() const
  862. {
  863. for(auto i = playerNames.cbegin(); i != playerNames.cend(); i++)
  864. {
  865. if(!si->getPlayersSettings(i->first))
  866. return i->first;
  867. }
  868. return 0;
  869. }
  870. static void handleCommandOptions(int argc, const char * argv[], boost::program_options::variables_map & options)
  871. {
  872. namespace po = boost::program_options;
  873. po::options_description opts("Allowed options");
  874. opts.add_options()
  875. ("help,h", "display help and exit")
  876. ("version,v", "display version information and exit")
  877. ("run-by-client", "indicate that server launched by client on same machine")
  878. ("uuid", po::value<std::string>(), "")
  879. ("enable-shm-uuid", "use UUID for shared memory identifier")
  880. ("enable-shm", "enable usage of shared memory")
  881. ("port", po::value<ui16>(), "port at which server will listen to connections from client")
  882. ("lobby", po::value<std::string>(), "address to remote lobby")
  883. ("lobby-port", po::value<ui16>(), "port at which server connect to remote lobby")
  884. ("lobby-uuid", po::value<std::string>(), "")
  885. ("connections", po::value<ui16>(), "amount of connections to remote lobby");
  886. if(argc > 1)
  887. {
  888. try
  889. {
  890. po::store(po::parse_command_line(argc, argv, opts), options);
  891. }
  892. catch(std::exception & e)
  893. {
  894. std::cerr << "Failure during parsing command-line options:\n" << e.what() << std::endl;
  895. }
  896. }
  897. #ifdef SINGLE_PROCESS_APP
  898. options.emplace("run-by-client", po::variable_value{true, true});
  899. #endif
  900. po::notify(options);
  901. #ifndef SINGLE_PROCESS_APP
  902. if(options.count("help"))
  903. {
  904. auto time = std::time(0);
  905. printf("%s - A Heroes of Might and Magic 3 clone\n", GameConstants::VCMI_VERSION.c_str());
  906. printf("Copyright (C) 2007-%d VCMI dev team - see AUTHORS file\n", std::localtime(&time)->tm_year + 1900);
  907. printf("This is free software; see the source for copying conditions. There is NO\n");
  908. printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
  909. printf("\n");
  910. std::cout << opts;
  911. exit(0);
  912. }
  913. if(options.count("version"))
  914. {
  915. printf("%s\n", GameConstants::VCMI_VERSION.c_str());
  916. std::cout << VCMIDirs::get().genHelpString();
  917. exit(0);
  918. }
  919. #endif
  920. }
  921. #ifdef SINGLE_PROCESS_APP
  922. #define main server_main
  923. #endif
  924. #if VCMI_ANDROID_DUAL_PROCESS
  925. void CVCMIServer::create()
  926. {
  927. const int argc = 1;
  928. const char * argv[argc] = { "android-server" };
  929. #else
  930. int main(int argc, const char * argv[])
  931. {
  932. #endif
  933. #if !defined(VCMI_ANDROID) && !defined(SINGLE_PROCESS_APP)
  934. // Correct working dir executable folder (not bundle folder) so we can use executable relative paths
  935. boost::filesystem::current_path(boost::filesystem::system_complete(argv[0]).parent_path());
  936. #endif
  937. #ifndef VCMI_IOS
  938. console = new CConsoleHandler();
  939. #endif
  940. CBasicLogConfigurator logConfig(VCMIDirs::get().userLogsPath() / "VCMI_Server_log.txt", console);
  941. logConfig.configureDefault();
  942. logGlobal->info(SERVER_NAME);
  943. boost::program_options::variables_map opts;
  944. handleCommandOptions(argc, argv, opts);
  945. preinitDLL(console);
  946. logConfig.configure();
  947. loadDLLClasses();
  948. srand((ui32)time(nullptr));
  949. #ifdef SINGLE_PROCESS_APP
  950. boost::condition_variable * cond = reinterpret_cast<boost::condition_variable *>(const_cast<char *>(argv[0]));
  951. cond->notify_one();
  952. #endif
  953. try
  954. {
  955. boost::asio::io_service io_service;
  956. CVCMIServer server(opts);
  957. try
  958. {
  959. while(server.state != EServerState::SHUTDOWN)
  960. {
  961. server.run();
  962. }
  963. io_service.run();
  964. }
  965. catch(boost::system::system_error & e) //for boost errors just log, not crash - probably client shut down connection
  966. {
  967. logNetwork->error(e.what());
  968. server.state = EServerState::SHUTDOWN;
  969. }
  970. catch(...)
  971. {
  972. handleException();
  973. }
  974. }
  975. catch(boost::system::system_error & e)
  976. {
  977. logNetwork->error(e.what());
  978. //catch any startup errors (e.g. can't access port) errors
  979. //and return non-zero status so client can detect error
  980. throw;
  981. }
  982. #if VCMI_ANDROID_DUAL_PROCESS
  983. CAndroidVMHelper envHelper;
  984. envHelper.callStaticVoidMethod(CAndroidVMHelper::NATIVE_METHODS_DEFAULT_CLASS, "killServer");
  985. #endif
  986. logConfig.deconfigure();
  987. vstd::clear_pointer(VLC);
  988. #if !VCMI_ANDROID_DUAL_PROCESS
  989. return 0;
  990. #endif
  991. }
  992. #if VCMI_ANDROID_DUAL_PROCESS
  993. extern "C" JNIEXPORT void JNICALL Java_eu_vcmi_vcmi_NativeMethods_createServer(JNIEnv * env, jclass cls)
  994. {
  995. __android_log_write(ANDROID_LOG_INFO, "VCMI", "Got jni call to init server");
  996. CAndroidVMHelper::cacheVM(env);
  997. CVCMIServer::create();
  998. }
  999. extern "C" JNIEXPORT void JNICALL Java_eu_vcmi_vcmi_NativeMethods_initClassloader(JNIEnv * baseEnv, jclass cls)
  1000. {
  1001. CAndroidVMHelper::initClassloader(baseEnv);
  1002. }
  1003. #elif defined(SINGLE_PROCESS_APP)
  1004. void CVCMIServer::create(boost::condition_variable * cond, const std::vector<std::string> & args)
  1005. {
  1006. std::vector<const void *> argv = {cond};
  1007. for(auto & a : args)
  1008. argv.push_back(a.c_str());
  1009. main(argv.size(), reinterpret_cast<const char **>(&*argv.begin()));
  1010. }
  1011. #ifdef VCMI_ANDROID
  1012. void CVCMIServer::reuseClientJNIEnv(void * jniEnv)
  1013. {
  1014. CAndroidVMHelper::initClassloader(jniEnv);
  1015. CAndroidVMHelper::alwaysUseLoadedClass = true;
  1016. }
  1017. #endif // VCMI_ANDROID
  1018. #endif // VCMI_ANDROID_DUAL_PROCESS