Chunk.cpp 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311
  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. iterator.remove();
  164. break;
  165. }
  166. }
  167. vcs.unlock();
  168. iterator->release();
  169. iterator.set(block);
  170. break;
  171. }
  172. }
  173. blocks.add(block);
  174. cs.unlock();
  175. }
  176. void Chunk::removeBlock(Block* zBlock)
  177. {
  178. cs.lock();
  179. vcs.lock();
  180. for (Framework::Iterator<Block*> iterator = visibleBlocks.begin(); iterator;
  181. iterator++)
  182. {
  183. if (zBlock == (Block*)iterator)
  184. {
  185. iterator.remove();
  186. break;
  187. }
  188. }
  189. vcs.unlock();
  190. for (Framework::Iterator<Block*> iterator = blocks.begin(); iterator;
  191. iterator++)
  192. {
  193. if (zBlock == (Block*)iterator)
  194. {
  195. iterator.remove();
  196. break;
  197. }
  198. }
  199. cs.unlock();
  200. }
  201. void Chunk::load(Framework::StreamReader* zReader)
  202. {
  203. isLoading = 1;
  204. Framework::Vec3<int> pos = {0, 0, 0};
  205. unsigned short id;
  206. zReader->lese((char*)&id, 2);
  207. while (id)
  208. {
  209. int index;
  210. zReader->lese((char*)&index, 4);
  211. pos = Vec3<int>((index / WORLD_HEIGHT) / CHUNK_SIZE,
  212. (index / WORLD_HEIGHT) % CHUNK_SIZE,
  213. index % WORLD_HEIGHT);
  214. if (blockTypes[id]->doesNeedInstance())
  215. setBlock(blockTypes[id]->createBlock(
  216. {pos.x + location.x - CHUNK_SIZE / 2,
  217. pos.y + location.y - CHUNK_SIZE / 2,
  218. pos.z}));
  219. zReader->lese((char*)&id, 2);
  220. }
  221. int index = 0;
  222. // light
  223. zReader->lese((char*)&index, 4);
  224. char lightData[6];
  225. while (index >= 0)
  226. {
  227. zReader->lese(lightData, 6);
  228. Framework::Vec3<int> location((index / WORLD_HEIGHT) / CHUNK_SIZE,
  229. (index / WORLD_HEIGHT) % CHUNK_SIZE,
  230. index % WORLD_HEIGHT);
  231. for (int i = 0; i < 6; i++)
  232. {
  233. Framework::Vec3<int> pos
  234. = location + getDirection(getDirectionFromIndex(i));
  235. if (pos.z >= 0 && pos.z < WORLD_HEIGHT)
  236. {
  237. if (pos.x >= 0 && pos.x < CHUNK_SIZE && pos.y >= 0
  238. && pos.y < CHUNK_SIZE)
  239. {
  240. pos.x += this->location.x - CHUNK_SIZE / 2;
  241. pos.y += this->location.y - CHUNK_SIZE / 2;
  242. Block* zB = zBlockAt(pos);
  243. if (zB)
  244. {
  245. bool visible = zB->isVisible();
  246. zB->setLightData(
  247. getOppositeDirection(getDirectionFromIndex(i)),
  248. (unsigned char*)lightData);
  249. if (zB->isVisible() && !visible) visibleBlocks.add(zB);
  250. }
  251. }
  252. else
  253. {
  254. pos.x += this->location.x - CHUNK_SIZE / 2;
  255. pos.y += this->location.y - CHUNK_SIZE / 2;
  256. Block* zB = World::INSTANCE->zBlockAt(pos);
  257. if (zB)
  258. {
  259. bool visible = zB->isVisible();
  260. zB->setLightData(
  261. getOppositeDirection(getDirectionFromIndex(i)),
  262. (unsigned char*)lightData);
  263. if (zB->isVisible() && !visible)
  264. {
  265. Chunk* c = World::INSTANCE->zChunk(
  266. World::INSTANCE->getChunkCenter(pos.x, pos.y));
  267. c->vcs.lock();
  268. c->visibleBlocks.add(zB);
  269. c->vcs.unlock();
  270. }
  271. }
  272. }
  273. }
  274. }
  275. zReader->lese((char*)&index, 4);
  276. }
  277. isLoading = 0;
  278. }
  279. Framework::Punkt Chunk::getCenter() const
  280. {
  281. return location;
  282. }
  283. Framework::Vec3<int> Chunk::getMin() const
  284. {
  285. return {location.x - CHUNK_SIZE / 2, location.y - CHUNK_SIZE / 2, 0};
  286. }
  287. Framework::Vec3<int> Chunk::getMax() const
  288. {
  289. return {
  290. location.x + CHUNK_SIZE / 2, location.y + CHUNK_SIZE / 2, WORLD_HEIGHT};
  291. }
  292. void Chunk::forAll(std::function<void(Model3D*)> f)
  293. {
  294. vcs.lock();
  295. for (Block* b : visibleBlocks)
  296. f(b);
  297. vcs.unlock();
  298. }