World.cpp 12 KB

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