World.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414
  1. #include "World.h"
  2. #include <AsynchronCall.h>
  3. #include <GraphicsApi.h>
  4. #include <iostream>
  5. #include <Network.h>
  6. #include <Welt3D.h>
  7. #include "Constants.h"
  8. #include "Game.h"
  9. #include "Globals.h"
  10. #include "Registries.h"
  11. #include "WorldUpdate.h"
  12. using namespace Network;
  13. using namespace Framework;
  14. World* World::INSTANCE = 0;
  15. World::World(Bildschirm3D* zScreen, FactoryClient* client)
  16. : Thread(),
  17. client(client)
  18. {
  19. renderedWorld = new Welt3D();
  20. renderedWorld->addDiffuseLight(DiffuseLight{
  21. Vec3<float>(0.5f, 0.5f, -1.f), Vec3<float>(1.f, 1.f, 1.f)});
  22. currentDimension = new Dimension();
  23. zScreenPtr = zScreen;
  24. kam = new PlayerKam(zScreen);
  25. kam->setWelt(renderedWorld);
  26. zScreen->addKamera(kam);
  27. firstMessage = 1;
  28. ownEntityId = -1;
  29. currentTarget = 0;
  30. start();
  31. }
  32. World::~World()
  33. {
  34. zScreenPtr->removeKamera(kam);
  35. currentDimension->release();
  36. if (currentTarget) currentTarget->release();
  37. client->release();
  38. World::INSTANCE = 0;
  39. }
  40. void World::update(bool background)
  41. {
  42. NetworkReader* serverMessageReader = 0;
  43. unsigned char type = 0;
  44. while (background
  45. ? serverMessageReader = client->getNextBackgroundMessage()
  46. : serverMessageReader = client->getNextForegroundMessage())
  47. {
  48. serverMessageReader->lese((char*)&type, 1);
  49. if (type == 2) // WORLD UPDATE
  50. {
  51. int id = 0;
  52. serverMessageReader->lese((char*)&id, 4);
  53. STATIC_REGISTRY(WorldUpdateType)
  54. .zElement(id)
  55. ->applyUpdateAndCheck(serverMessageReader);
  56. }
  57. if (type == 3) // API MESSAGE
  58. {
  59. int length;
  60. serverMessageReader->lese((char*)&length, 4);
  61. char* data = new char[length];
  62. serverMessageReader->lese(data, length);
  63. switch (data[0])
  64. {
  65. case 1: // dimension message
  66. {
  67. int dimId = *(int*)(data + 1);
  68. if (dimId == currentDimension->getId())
  69. {
  70. currentDimension->api(data + 5);
  71. }
  72. break;
  73. }
  74. case 2: // gui message
  75. ((Game*)(Menu*)menuRegister->get("game"))->api(data + 1);
  76. break;
  77. case 3: // set target
  78. {
  79. switch (data[1])
  80. {
  81. case 0:
  82. setTarget(0);
  83. ((Game*)(Menu*)menuRegister->get("game"))
  84. ->setTargetUIML("");
  85. break;
  86. case 1:
  87. setTarget(zEntity(*(int*)(data + 2)));
  88. ((Game*)(Menu*)menuRegister->get("game"))
  89. ->setTargetUIML("");
  90. break;
  91. case 2:
  92. setTarget(zBlockAt(Vec3<int>(*(int*)(data + 2),
  93. *(int*)(data + 6),
  94. *(int*)(data + 10))));
  95. int side = *(int*)(data + 14);
  96. short len = *(short*)(data + 18);
  97. char* uiml = new char[len + 1];
  98. memcpy(uiml, data + 20, len);
  99. uiml[len] = 0;
  100. ((Game*)(Menu*)menuRegister->get("game"))
  101. ->setTargetUIML(uiml);
  102. delete[] uiml;
  103. break;
  104. }
  105. break;
  106. }
  107. case 4: // chat message
  108. {
  109. ((Game*)(Menu*)menuRegister->get("game"))
  110. ->zChat()
  111. ->addMessage(data + 1);
  112. break;
  113. }
  114. case 5: // chat options
  115. {
  116. ((Game*)(Menu*)menuRegister->get("game"))
  117. ->zChat()
  118. ->initOptions(data + 1);
  119. break;
  120. }
  121. case 6: // map data
  122. {
  123. ByteArrayReader reader(data + 1, length - 1, 0);
  124. ChunkMap* map = new ChunkMap(&reader);
  125. ((Game*)(Menu*)menuRegister->get("game"))
  126. ->zMap()
  127. ->addChunk(map);
  128. break;
  129. }
  130. case 7: // map player data
  131. {
  132. ((Game*)(Menu*)menuRegister->get("game"))
  133. ->zMap()
  134. ->updatePlayerData(data + 1);
  135. break;
  136. }
  137. }
  138. delete[] data;
  139. // TODO: process messages
  140. }
  141. if (type == 4) // POSITION UPDATE
  142. {
  143. int old = ownEntityId;
  144. serverMessageReader->lese((char*)&ownEntityId, 4);
  145. int dimensionId = 0;
  146. serverMessageReader->lese((char*)&dimensionId, 4);
  147. currentDimension->setId(dimensionId);
  148. kam->setEntityId(ownEntityId);
  149. Entity* p = zEntity(ownEntityId);
  150. if (p) p->setPlayerControlled();
  151. if (old != ownEntityId) client->sendPlayerAction("\5", 1);
  152. }
  153. client->endMessageReading(background);
  154. }
  155. client->endMessageReading(background);
  156. Entity* player = getCurrentPlayerEntity();
  157. if (player)
  158. {
  159. renderedWorld->lock();
  160. currentDimension->removeDistantChunks(
  161. {(int)player->getPos().x, (int)player->getPos().y});
  162. Punkt currentChunk
  163. = getChunkCenter((int)player->getX(), (int)player->getY());
  164. for (int x = 0; x <= CHUNK_VISIBILITY_RANGE; x++)
  165. {
  166. for (int y = 0; y <= CHUNK_VISIBILITY_RANGE; y++)
  167. {
  168. std::function<void(Punkt)> requestChunk = [this](Punkt center) {
  169. Chunk* zC = currentDimension->zChunk(center);
  170. if (!zC)
  171. {
  172. char msg[1];
  173. msg[0] = 0; // add observer and request chaunk data
  174. Punkt pos = center;
  175. subLock.lock();
  176. bool found = 0;
  177. for (Punkt p : subscriptions)
  178. {
  179. if (p == pos)
  180. {
  181. found = 1;
  182. break;
  183. }
  184. }
  185. if (!found)
  186. {
  187. client->chunkAPIRequest(pos, msg, 1);
  188. subscriptions.add(pos);
  189. }
  190. subLock.unlock();
  191. }
  192. };
  193. requestChunk(
  194. currentChunk + Punkt(x * CHUNK_SIZE, y * CHUNK_SIZE));
  195. if (y > 0)
  196. requestChunk(
  197. currentChunk + Punkt(x * CHUNK_SIZE, -y * CHUNK_SIZE));
  198. if (x > 0)
  199. {
  200. requestChunk(
  201. currentChunk + Punkt(-x * CHUNK_SIZE, y * CHUNK_SIZE));
  202. if (y > 0)
  203. requestChunk(currentChunk
  204. + Punkt(-x * CHUNK_SIZE, -y * CHUNK_SIZE));
  205. }
  206. }
  207. }
  208. renderedWorld->unlock();
  209. }
  210. }
  211. void World::setChunk(Chunk* chunk)
  212. {
  213. zScreenPtr->lock();
  214. renderedWorld->lock();
  215. currentDimension->setChunk(chunk, chunk->getCenter());
  216. renderedWorld->unlock();
  217. zScreenPtr->unlock();
  218. }
  219. void World::thread()
  220. {
  221. new AsynchronCall("World Update", [this]() {
  222. while (client->isConnected())
  223. {
  224. zScreenPtr->lock();
  225. if (World::INSTANCE != this)
  226. {
  227. zScreenPtr->unlock();
  228. return;
  229. }
  230. zScreenPtr->unlock();
  231. update(0);
  232. Sleep(10);
  233. }
  234. std::cout << "foreground connection lost\n";
  235. });
  236. while (client->isConnected())
  237. {
  238. zScreenPtr->lock();
  239. if (World::INSTANCE != this)
  240. {
  241. zScreenPtr->unlock();
  242. return;
  243. }
  244. zScreenPtr->unlock();
  245. update(1);
  246. Sleep(10);
  247. }
  248. Sleep(1000);
  249. zScreenPtr->lock();
  250. std::cout << "background connection lost\n";
  251. menuRegister->get("game")->hide();
  252. menuRegister->get("serverSelection")->show();
  253. release();
  254. zScreenPtr->unlock();
  255. }
  256. Block* World::zBlockAt(Framework::Vec3<int> location) const
  257. {
  258. return currentDimension->zBlock(location);
  259. return 0;
  260. }
  261. Block* World::getBlockAt(Framework::Vec3<int> location) const
  262. {
  263. return currentDimension->getBlock(location);
  264. return 0;
  265. }
  266. Dimension* World::zDimension() const
  267. {
  268. return currentDimension;
  269. }
  270. void World::setVisibility(Chunk* zChunk, bool visible)
  271. {
  272. renderedWorld->lock();
  273. if (visible)
  274. renderedWorld->addCollection(
  275. dynamic_cast<Framework::Model3DCollection*>(zChunk->getThis()));
  276. else
  277. renderedWorld->removeCollection(zChunk);
  278. renderedWorld->unlock();
  279. }
  280. void World::setVisibility(Entity* zEntity, bool visible)
  281. {
  282. renderedWorld->lock();
  283. if (visible)
  284. renderedWorld->addZeichnung(
  285. dynamic_cast<Framework::Model3D*>(zEntity->getThis()));
  286. else
  287. renderedWorld->removeZeichnung(zEntity);
  288. renderedWorld->unlock();
  289. }
  290. Framework::Punkt World::getChunkCenter(int x, int y) const
  291. {
  292. return Punkt(((x < 0 ? x + 1 : x) / CHUNK_SIZE) * CHUNK_SIZE
  293. + (x < 0 ? -CHUNK_SIZE : CHUNK_SIZE) / 2,
  294. ((y < 0 ? y + 1 : y) / CHUNK_SIZE) * CHUNK_SIZE
  295. + (y < 0 ? -CHUNK_SIZE : CHUNK_SIZE) / 2);
  296. }
  297. Entity* World::zEntity(int id) const
  298. {
  299. Entity* e = currentDimension->zEntity(id);
  300. if (e) return e;
  301. return 0;
  302. }
  303. Entity* World::getEntity(int id) const
  304. {
  305. Entity* e = currentDimension->getEntity(id);
  306. if (e) return e;
  307. return 0;
  308. }
  309. void World::removeEntity(int id)
  310. {
  311. currentDimension->removeEntity(id);
  312. }
  313. PlayerKam* World::zKamera() const
  314. {
  315. return kam;
  316. }
  317. int World::getCurrentPlayerId() const
  318. {
  319. return ownEntityId;
  320. }
  321. Entity* World::getCurrentPlayerEntity() const
  322. {
  323. return zEntity(ownEntityId);
  324. }
  325. void World::setTarget(Framework::Model3D* zTarget)
  326. {
  327. if (zTarget != currentTarget)
  328. {
  329. targetLock.lock();
  330. if (currentTarget)
  331. {
  332. currentTarget->setAmbientFactor(
  333. currentTarget->getAmbientFactor() - 0.2f);
  334. currentTarget->release();
  335. currentTarget = 0;
  336. }
  337. if (zTarget)
  338. {
  339. currentTarget
  340. = dynamic_cast<Framework::Model3D*>(zTarget->getThis());
  341. if (currentTarget)
  342. currentTarget->setAmbientFactor(
  343. currentTarget->getAmbientFactor() + 0.2f);
  344. }
  345. targetLock.unlock();
  346. }
  347. }
  348. void World::lockWorld()
  349. {
  350. renderedWorld->lock();
  351. }
  352. void World::unlockWorld()
  353. {
  354. renderedWorld->unlock();
  355. }
  356. void World::onChunkAdded(Punkt pos)
  357. {
  358. subLock.lock();
  359. int index = 0;
  360. for (Punkt p : subscriptions)
  361. {
  362. if (p == pos)
  363. {
  364. subscriptions.remove(index);
  365. break;
  366. }
  367. index++;
  368. }
  369. subLock.unlock();
  370. }
  371. Framework::Model3D* World::getCurrentTarget() const
  372. {
  373. while (targetLock.isLocked())
  374. Sleep(1);
  375. return currentTarget
  376. ? dynamic_cast<Framework::Model3D*>(currentTarget->getThis())
  377. : 0;
  378. }
  379. Chunk* World::zChunk(Punkt center)
  380. {
  381. return currentDimension->zChunk(center);
  382. }
  383. FactoryClient* World::zClient() const
  384. {
  385. return client;
  386. }