Chunk.cpp 9.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333
  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::api(char* message)
  21. {
  22. switch (message[0])
  23. {
  24. case 0: // set block
  25. {
  26. int index = *(int*)(message + 1);
  27. int id = *(int*)(message + 5);
  28. Framework::Vec3<int> location((index / WORLD_HEIGHT) / CHUNK_SIZE,
  29. (index / WORLD_HEIGHT) % CHUNK_SIZE,
  30. index % WORLD_HEIGHT);
  31. location.x += this->location.x - CHUNK_SIZE / 2;
  32. location.y += this->location.y - CHUNK_SIZE / 2;
  33. if (blockTypes[id]->doesNeedInstance())
  34. {
  35. Block* zB = blockTypes[id]->createBlock(location);
  36. setBlock(zB);
  37. }
  38. else
  39. {
  40. Block* zB = zBlockAt(location);
  41. if (zB) removeBlock(zB);
  42. }
  43. break;
  44. }
  45. }
  46. }
  47. Block* Chunk::zBlockAt(Framework::Vec3<int> location)
  48. {
  49. cs.lock();
  50. for (Block* b : blocks)
  51. {
  52. if (b->getLocation() == location)
  53. {
  54. cs.unlock();
  55. return b;
  56. }
  57. }
  58. cs.unlock();
  59. return 0;
  60. }
  61. void Chunk::setBlock(Block* block)
  62. {
  63. cs.lock();
  64. Framework::Vec3<int> pos = block->getLocation();
  65. for (Framework::Iterator<Block*> iterator = blocks.begin(); iterator;
  66. iterator++)
  67. {
  68. if (pos == iterator->getLocation())
  69. {
  70. vcs.lock();
  71. for (Framework::Iterator<Block*> vi = visibleBlocks.begin(); vi;
  72. vi++)
  73. {
  74. if ((Block*)iterator == (Block*)vi)
  75. {
  76. vi.remove();
  77. break;
  78. }
  79. }
  80. vcs.unlock();
  81. iterator->copyLightTo(block);
  82. iterator->release();
  83. iterator.set(block);
  84. cs.unlock();
  85. vcs.lock();
  86. if (block->isVisible())
  87. {
  88. visibleBlocks.add(block);
  89. }
  90. vcs.unlock();
  91. return;
  92. }
  93. }
  94. blocks.add(block);
  95. cs.unlock();
  96. vcs.lock();
  97. if (block->isVisible())
  98. {
  99. visibleBlocks.add(block);
  100. }
  101. vcs.unlock();
  102. }
  103. void Chunk::removeBlock(Block* zBlock)
  104. {
  105. cs.lock();
  106. vcs.lock();
  107. for (Framework::Iterator<Block*> iterator = visibleBlocks.begin(); iterator;
  108. iterator++)
  109. {
  110. if (zBlock == (Block*)iterator)
  111. {
  112. iterator.remove();
  113. break;
  114. }
  115. }
  116. vcs.unlock();
  117. for (Framework::Iterator<Block*> iterator = blocks.begin(); iterator;
  118. iterator++)
  119. {
  120. if (zBlock == (Block*)iterator)
  121. {
  122. iterator.remove();
  123. break;
  124. }
  125. }
  126. cs.unlock();
  127. }
  128. void Chunk::load(Framework::StreamReader* zReader)
  129. {
  130. cs.lock();
  131. blocks.leeren();
  132. cs.unlock();
  133. Trie<Block> blockCache;
  134. isLoading = 1;
  135. Framework::Vec3<int> pos = {0, 0, 0};
  136. unsigned short id;
  137. zReader->lese((char*)&id, 2);
  138. while (id)
  139. {
  140. int index;
  141. zReader->lese((char*)&index, 4);
  142. pos = Vec3<int>((index / WORLD_HEIGHT) / CHUNK_SIZE,
  143. (index / WORLD_HEIGHT) % CHUNK_SIZE,
  144. index % WORLD_HEIGHT);
  145. if (blockTypes[id]->doesNeedInstance())
  146. {
  147. cs.lock();
  148. Block* b = blockTypes[id]->createBlock(
  149. {pos.x + location.x - CHUNK_SIZE / 2,
  150. pos.y + location.y - CHUNK_SIZE / 2,
  151. pos.z});
  152. blocks.add(b);
  153. blockCache.set((char*)&index, 4, dynamic_cast<Block*>(b->getThis()));
  154. cs.unlock();
  155. vcs.lock();
  156. if (b->isVisible())
  157. {
  158. visibleBlocks.add(b);
  159. }
  160. vcs.unlock();
  161. }
  162. zReader->lese((char*)&id, 2);
  163. }
  164. int index = 0;
  165. // light
  166. zReader->lese((char*)&index, 4);
  167. char lightData[6];
  168. while (index >= -1)
  169. {
  170. if (index == -1)
  171. {
  172. int x = 0;
  173. int y = 0;
  174. int z = 0;
  175. zReader->lese((char*)&x, 4);
  176. zReader->lese((char*)&y, 4);
  177. zReader->lese((char*)&z, 4);
  178. zReader->lese(lightData, 6);
  179. if (x == -1)
  180. {
  181. int cacheIndex
  182. = y * WORLD_HEIGHT + z;
  183. Block* zB = blockCache.z((char*)&cacheIndex, 4);
  184. if (zB)
  185. {
  186. zB->setLightData(WEST, (unsigned char*)lightData);
  187. }
  188. }
  189. else if (y == -1)
  190. {
  191. int cacheIndex = (x * CHUNK_SIZE) * WORLD_HEIGHT + z;
  192. Block* zB = blockCache.z((char*)&cacheIndex, 4);
  193. if (zB)
  194. {
  195. zB->setLightData(NORTH, (unsigned char*)lightData);
  196. }
  197. }
  198. else if (x == CHUNK_SIZE)
  199. {
  200. int cacheIndex = ((CHUNK_SIZE - 1) * CHUNK_SIZE + y) * WORLD_HEIGHT + z;
  201. Block* zB = blockCache.z((char*)&cacheIndex, 4);
  202. if (zB)
  203. {
  204. zB->setLightData(EAST, (unsigned char*)lightData);
  205. }
  206. }
  207. else if (y == CHUNK_SIZE)
  208. {
  209. int cacheIndex
  210. = (x * CHUNK_SIZE + (CHUNK_SIZE - 1)) * WORLD_HEIGHT + z;
  211. Block* zB = blockCache.z((char*)&cacheIndex, 4);
  212. if (zB)
  213. {
  214. zB->setLightData(SOUTH, (unsigned char*)lightData);
  215. }
  216. }
  217. }
  218. else
  219. {
  220. zReader->lese(lightData, 6);
  221. Framework::Vec3<int> location((index / WORLD_HEIGHT) / CHUNK_SIZE,
  222. (index / WORLD_HEIGHT) % CHUNK_SIZE,
  223. index % WORLD_HEIGHT);
  224. for (int i = 0; i < 6; i++)
  225. {
  226. Framework::Vec3<int> pos
  227. = location + getDirection(getDirectionFromIndex(i));
  228. if (pos.z >= 0 && pos.z < WORLD_HEIGHT)
  229. {
  230. if (pos.x >= 0 && pos.x < CHUNK_SIZE && pos.y >= 0
  231. && pos.y < CHUNK_SIZE)
  232. {
  233. int cacheIndex
  234. = (pos.x * CHUNK_SIZE + pos.y) * WORLD_HEIGHT
  235. + pos.z;
  236. Block* zB = blockCache.z((char*)&cacheIndex, 4);
  237. if (zB)
  238. {
  239. bool visible = zB->isVisible();
  240. zB->setLightData(
  241. getOppositeDirection(getDirectionFromIndex(i)),
  242. (unsigned char*)lightData);
  243. if (zB->isVisible() && !visible)
  244. {
  245. vcs.lock();
  246. visibleBlocks.add(zB);
  247. vcs.unlock();
  248. }
  249. }
  250. }
  251. else
  252. {
  253. pos.x += this->location.x - CHUNK_SIZE / 2;
  254. pos.y += this->location.y - CHUNK_SIZE / 2;
  255. Block* zB = World::INSTANCE->zBlockAt(pos);
  256. if (zB)
  257. {
  258. bool visible = zB->isVisible();
  259. zB->setLightData(
  260. getOppositeDirection(getDirectionFromIndex(i)),
  261. (unsigned char*)lightData);
  262. if (zB->isVisible() && !visible)
  263. {
  264. Chunk* c = World::INSTANCE->zChunk(
  265. World::INSTANCE->getChunkCenter(
  266. pos.x, pos.y));
  267. c->vcs.lock();
  268. c->visibleBlocks.add(zB);
  269. c->vcs.unlock();
  270. }
  271. }
  272. }
  273. }
  274. }
  275. }
  276. zReader->lese((char*)&index, 4);
  277. }
  278. isLoading = 0;
  279. }
  280. void Chunk::blockVisibilityChanged(Block* zB)
  281. {
  282. vcs.lock();
  283. if (zB->isVisible())
  284. visibleBlocks.add(zB);
  285. else
  286. {
  287. for (Framework::Iterator<Block*> iterator = visibleBlocks.begin();
  288. iterator;
  289. iterator++)
  290. {
  291. if (zB == (Block*)iterator)
  292. {
  293. iterator.remove();
  294. break;
  295. }
  296. }
  297. }
  298. vcs.unlock();
  299. }
  300. Framework::Punkt Chunk::getCenter() const
  301. {
  302. return location;
  303. }
  304. Framework::Vec3<int> Chunk::getMin() const
  305. {
  306. return {location.x - CHUNK_SIZE / 2, location.y - CHUNK_SIZE / 2, 0};
  307. }
  308. Framework::Vec3<int> Chunk::getMax() const
  309. {
  310. return {
  311. location.x + CHUNK_SIZE / 2, location.y + CHUNK_SIZE / 2, WORLD_HEIGHT};
  312. }
  313. void Chunk::forAll(std::function<void(Model3D*)> f)
  314. {
  315. vcs.lock();
  316. for (Block* b : visibleBlocks)
  317. f(b);
  318. vcs.unlock();
  319. }