Chunk.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413
  1. #include "Chunk.h"
  2. #include "Constants.h"
  3. #include "Globals.h"
  4. #include "Registries.h"
  5. Chunk::Chunk(Framework::Punkt location)
  6. : ReferenceCounter(),
  7. location(location),
  8. isLoading(0)
  9. {}
  10. Chunk::Chunk(Framework::Punkt location, Framework::StreamReader* zReader)
  11. : Chunk(location)
  12. {
  13. load(zReader);
  14. }
  15. Chunk::~Chunk()
  16. {
  17. char msg = 1; // remove observer
  18. World::INSTANCE->zClient()->chunkAPIRequest(location, &msg, 1);
  19. }
  20. void Chunk::appendAnimation(
  21. Block* zB, int boneId, double time, Vec3<float> pos, Vec3<float> rot)
  22. {
  23. if (!zB->zSkeleton() || !zB->zSkeleton()->zBone(boneId)) return;
  24. acs.lock();
  25. for (BlockAnimation* animation : animations)
  26. {
  27. if (animation->zBlock() == zB)
  28. {
  29. animation->appendAnimation(boneId, time, pos, rot);
  30. acs.unlock();
  31. return;
  32. }
  33. }
  34. SkeletonAnimation* sa = new SkeletonAnimation();
  35. Bone* bone = zB->zSkeleton()->zBone(boneId);
  36. sa->addAnimation(boneId, bone->getPosition(), bone->getRotation());
  37. sa->addKeyFrame(boneId, time, pos, rot);
  38. animations.add(new BlockAnimation(dynamic_cast<Block*>(zB->getThis()), sa));
  39. acs.unlock();
  40. }
  41. void Chunk::api(char* message)
  42. {
  43. switch (message[0])
  44. {
  45. case 0: // set block
  46. {
  47. int index = *(int*)(message + 1);
  48. int id = *(int*)(message + 5);
  49. Framework::Vec3<int> location((index / WORLD_HEIGHT) / CHUNK_SIZE,
  50. (index / WORLD_HEIGHT) % CHUNK_SIZE,
  51. index % WORLD_HEIGHT);
  52. location.x += this->location.x - CHUNK_SIZE / 2;
  53. location.y += this->location.y - CHUNK_SIZE / 2;
  54. if (blockTypes[id]->doesNeedInstance())
  55. {
  56. Block* zB = blockTypes[id]->createBlock(location);
  57. setBlock(zB);
  58. }
  59. else
  60. {
  61. Block* zB = zBlockAt(location);
  62. if (zB) removeBlock(zB);
  63. }
  64. break;
  65. }
  66. case 1: // animate block
  67. {
  68. int index = *(int*)(message + 1);
  69. int boneId = *(int*)(message + 5);
  70. double time = *(double*)(message + 9);
  71. Framework::Vec3<float> pos;
  72. pos.x = *(float*)(message + 17);
  73. pos.y = *(float*)(message + 21);
  74. pos.z = *(float*)(message + 25);
  75. Framework::Vec3<float> rot;
  76. rot.x = *(float*)(message + 29);
  77. rot.y = *(float*)(message + 33);
  78. rot.z = *(float*)(message + 37);
  79. Framework::Vec3<int> location((index / WORLD_HEIGHT) / CHUNK_SIZE,
  80. (index / WORLD_HEIGHT) % CHUNK_SIZE,
  81. index % WORLD_HEIGHT);
  82. location.x += this->location.x - CHUNK_SIZE / 2;
  83. location.y += this->location.y - CHUNK_SIZE / 2;
  84. Block* zB = zBlockAt(location);
  85. if (zB) appendAnimation(zB, boneId, time, pos, rot);
  86. break;
  87. }
  88. }
  89. }
  90. Block* Chunk::zBlockAt(Framework::Vec3<int> location)
  91. {
  92. cs.lock();
  93. for (Block* b : blocks)
  94. {
  95. if (b->getLocation() == location)
  96. {
  97. cs.unlock();
  98. return b;
  99. }
  100. }
  101. cs.unlock();
  102. return 0;
  103. }
  104. void Chunk::setBlock(Block* block)
  105. {
  106. cs.lock();
  107. Framework::Vec3<int> pos = block->getLocation();
  108. for (Framework::Iterator<Block*> iterator = blocks.begin(); iterator;
  109. iterator++)
  110. {
  111. if (pos == iterator->getLocation())
  112. {
  113. vcs.lock();
  114. for (Framework::Iterator<Block*> vi = visibleBlocks.begin(); vi;
  115. vi++)
  116. {
  117. if ((Block*)iterator == (Block*)vi)
  118. {
  119. vi.remove();
  120. break;
  121. }
  122. }
  123. vcs.unlock();
  124. iterator->copyLightTo(block);
  125. iterator->release();
  126. iterator.set(block);
  127. cs.unlock();
  128. vcs.lock();
  129. if (block->isVisible())
  130. {
  131. block->tick(0);
  132. visibleBlocks.add(block);
  133. }
  134. vcs.unlock();
  135. return;
  136. }
  137. }
  138. blocks.add(block);
  139. cs.unlock();
  140. vcs.lock();
  141. if (block->isVisible())
  142. {
  143. block->tick(0);
  144. visibleBlocks.add(block);
  145. }
  146. vcs.unlock();
  147. }
  148. void Chunk::removeBlock(Block* zBlock)
  149. {
  150. cs.lock();
  151. vcs.lock();
  152. for (Framework::Iterator<Block*> iterator = visibleBlocks.begin(); iterator;
  153. iterator++)
  154. {
  155. if (zBlock == (Block*)iterator)
  156. {
  157. iterator.remove();
  158. break;
  159. }
  160. }
  161. vcs.unlock();
  162. for (Framework::Iterator<Block*> iterator = blocks.begin(); iterator;
  163. iterator++)
  164. {
  165. if (zBlock == (Block*)iterator)
  166. {
  167. iterator.remove();
  168. break;
  169. }
  170. }
  171. cs.unlock();
  172. }
  173. void Chunk::load(Framework::StreamReader* zReader)
  174. {
  175. cs.lock();
  176. blocks.leeren();
  177. cs.unlock();
  178. RCTrie<Block> blockCache;
  179. isLoading = 1;
  180. Framework::Vec3<int> pos = {0, 0, 0};
  181. unsigned short id;
  182. zReader->lese((char*)&id, 2);
  183. while (id)
  184. {
  185. int index;
  186. zReader->lese((char*)&index, 4);
  187. pos = Vec3<int>((index / WORLD_HEIGHT) / CHUNK_SIZE,
  188. (index / WORLD_HEIGHT) % CHUNK_SIZE,
  189. index % WORLD_HEIGHT);
  190. if (blockTypes[id]->doesNeedInstance())
  191. {
  192. cs.lock();
  193. Block* b = blockTypes[id]->createBlock(
  194. {pos.x + location.x - CHUNK_SIZE / 2,
  195. pos.y + location.y - CHUNK_SIZE / 2,
  196. pos.z});
  197. blocks.add(b);
  198. blockCache.set(
  199. (char*)&index, 4, dynamic_cast<Block*>(b->getThis()));
  200. cs.unlock();
  201. vcs.lock();
  202. if (b->isVisible())
  203. {
  204. b->tick(0);
  205. visibleBlocks.add(b);
  206. }
  207. vcs.unlock();
  208. }
  209. zReader->lese((char*)&id, 2);
  210. }
  211. int index = 0;
  212. // light
  213. zReader->lese((char*)&index, 4);
  214. char lightData[6];
  215. while (index >= -1)
  216. {
  217. if (index == -1)
  218. {
  219. int x = 0;
  220. int y = 0;
  221. int z = 0;
  222. zReader->lese((char*)&x, 4);
  223. zReader->lese((char*)&y, 4);
  224. zReader->lese((char*)&z, 4);
  225. zReader->lese(lightData, 6);
  226. if (x == -1)
  227. {
  228. int cacheIndex = y * WORLD_HEIGHT + z;
  229. Block* zB = blockCache.z((char*)&cacheIndex, 4);
  230. if (zB)
  231. {
  232. zB->setLightData(WEST, (unsigned char*)lightData);
  233. }
  234. }
  235. else if (y == -1)
  236. {
  237. int cacheIndex = (x * CHUNK_SIZE) * WORLD_HEIGHT + z;
  238. Block* zB = blockCache.z((char*)&cacheIndex, 4);
  239. if (zB)
  240. {
  241. zB->setLightData(NORTH, (unsigned char*)lightData);
  242. }
  243. }
  244. else if (x == CHUNK_SIZE)
  245. {
  246. int cacheIndex
  247. = ((CHUNK_SIZE - 1) * CHUNK_SIZE + y) * WORLD_HEIGHT + z;
  248. Block* zB = blockCache.z((char*)&cacheIndex, 4);
  249. if (zB)
  250. {
  251. zB->setLightData(EAST, (unsigned char*)lightData);
  252. }
  253. }
  254. else if (y == CHUNK_SIZE)
  255. {
  256. int cacheIndex
  257. = (x * CHUNK_SIZE + (CHUNK_SIZE - 1)) * WORLD_HEIGHT + z;
  258. Block* zB = blockCache.z((char*)&cacheIndex, 4);
  259. if (zB)
  260. {
  261. zB->setLightData(SOUTH, (unsigned char*)lightData);
  262. }
  263. }
  264. }
  265. else
  266. {
  267. zReader->lese(lightData, 6);
  268. Framework::Vec3<int> location((index / WORLD_HEIGHT) / CHUNK_SIZE,
  269. (index / WORLD_HEIGHT) % CHUNK_SIZE,
  270. index % WORLD_HEIGHT);
  271. for (int i = 0; i < 6; i++)
  272. {
  273. Framework::Vec3<int> pos
  274. = location + getDirection(getDirectionFromIndex(i));
  275. if (pos.z >= 0 && pos.z < WORLD_HEIGHT)
  276. {
  277. if (pos.x >= 0 && pos.x < CHUNK_SIZE && pos.y >= 0
  278. && pos.y < CHUNK_SIZE)
  279. {
  280. int cacheIndex
  281. = (pos.x * CHUNK_SIZE + pos.y) * WORLD_HEIGHT
  282. + pos.z;
  283. Block* zB = blockCache.z((char*)&cacheIndex, 4);
  284. if (zB)
  285. {
  286. bool visible = zB->isVisible();
  287. zB->setLightData(
  288. getOppositeDirection(getDirectionFromIndex(i)),
  289. (unsigned char*)lightData);
  290. if (zB->isVisible() && !visible)
  291. {
  292. vcs.lock();
  293. zB->tick(0);
  294. visibleBlocks.add(zB);
  295. vcs.unlock();
  296. }
  297. }
  298. }
  299. else
  300. {
  301. pos.x += this->location.x - CHUNK_SIZE / 2;
  302. pos.y += this->location.y - CHUNK_SIZE / 2;
  303. Block* zB = World::INSTANCE->zBlockAt(pos);
  304. if (zB)
  305. {
  306. bool visible = zB->isVisible();
  307. zB->setLightData(
  308. getOppositeDirection(getDirectionFromIndex(i)),
  309. (unsigned char*)lightData);
  310. if (zB->isVisible() && !visible)
  311. {
  312. Chunk* c = World::INSTANCE->zChunk(
  313. World::INSTANCE->getChunkCenter(
  314. pos.x, pos.y));
  315. c->vcs.lock();
  316. zB->tick(0);
  317. c->visibleBlocks.add(zB);
  318. c->vcs.unlock();
  319. }
  320. }
  321. }
  322. }
  323. }
  324. }
  325. zReader->lese((char*)&index, 4);
  326. }
  327. isLoading = 0;
  328. }
  329. void Chunk::blockVisibilityChanged(Block* zB)
  330. {
  331. vcs.lock();
  332. if (zB->isVisible())
  333. {
  334. zB->tick(0);
  335. visibleBlocks.add(zB);
  336. }
  337. else
  338. {
  339. for (Framework::Iterator<Block*> iterator = visibleBlocks.begin();
  340. iterator;
  341. iterator++)
  342. {
  343. if (zB == (Block*)iterator)
  344. {
  345. iterator.remove();
  346. break;
  347. }
  348. }
  349. }
  350. vcs.unlock();
  351. }
  352. Framework::Punkt Chunk::getCenter() const
  353. {
  354. return location;
  355. }
  356. Framework::Vec3<int> Chunk::getMin() const
  357. {
  358. return {location.x - CHUNK_SIZE / 2, location.y - CHUNK_SIZE / 2, 0};
  359. }
  360. Framework::Vec3<int> Chunk::getMax() const
  361. {
  362. return {
  363. location.x + CHUNK_SIZE / 2, location.y + CHUNK_SIZE / 2, WORLD_HEIGHT};
  364. }
  365. void Chunk::forAll(std::function<void(Model3D*)> f)
  366. {
  367. vcs.lock();
  368. for (Block* b : visibleBlocks)
  369. f(b);
  370. vcs.unlock();
  371. }
  372. bool Chunk::tick(std::function<void(Model3D*)> f, double time)
  373. {
  374. bool res = 0;
  375. acs.lock();
  376. auto iterator = animations.begin();
  377. while (iterator)
  378. {
  379. if (iterator->tick(time))
  380. {
  381. res |= iterator->zBlock()->tick(time);
  382. if (iterator->isFinished())
  383. {
  384. iterator.remove();
  385. continue;
  386. }
  387. }
  388. else
  389. {
  390. iterator.remove();
  391. continue;
  392. }
  393. ++iterator;
  394. }
  395. acs.unlock();
  396. return res;
  397. }