Chunk.cpp 11 KB

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