1. #include "stdafx.h"
  2. #include "../../libgame/include/attribute.h"
  3. #include "../../libgame/include/targa.h"
  4. #include "../../common/d3dtype.h"
  5. #include "utils.h"
  6. #include "minilzo.h"
  7. #include "sectree.h"
  8. #include "sectree_manager.h"
  9. #include "vector.h"
  10. #include "lzo_manager.h"
  11. #include "char_manager.h"
  12. #include "desc_manager.h"
  13. #include "questmanager.h"
  14. #include "arena.h"
  15. #include "pvp.h"
  16. #include "cmd.h"
  18. enum
  19. {
  20. COLLISION_TYPE_PLANE,
  21. COLLISION_TYPE_BOX,
  22. COLLISION_TYPE_SPHERE,
  23. COLLISION_TYPE_CYLINDER,
  24. };
  26. typedef struct SSphereData
  27. {
  28. D3DXVECTOR3 v3Position;
  29. float fRadius;
  30. } TSphereData;
  32. typedef struct SPlaneData
  33. {
  34. D3DXVECTOR3 v3Position;
  35. D3DXVECTOR3 v3Normal;
  37. D3DXVECTOR3 v3QuadPosition[4];
  38. D3DXVECTOR3 v3InsideVector[4];
  39. } TPlaneData;
  41. typedef struct SCylinderData
  42. {
  43. D3DXVECTOR3 v3Position;
  44. float fRadius;
  45. float fHeight;
  46. } TCylinderData;
  48. LPSECTREE_MAP g_pkMapSectree;
  50. int max_bytes_written = 0;
  51. int total_bytes_written = 0;
  52. int current_bytes_written = 0;
  54. int g_bx;
  55. int g_by;
  57. LPFDWATCH main_fdw = NULL;
  58. socket_t udp_socket = 0;
  60. bool g_bShutdown = false;
  62. void ConvertAttribute(const char * c_pszCollisionDataFileName, const char * c_pszMapDirectory);
  63. void ReadColorMapRecursive(const char * c_pszFileName);
  64. void ConvertAttribute2(const char * filename);
  66. void ContinueOnFatalError()
  67. {
  68. }
  70. void ShutdownOnFatalError()
  71. {
  72. }
  74. void heartbeat(LPHEART heart, int pulse)
  75. {
  76. }
  78. bool Metin2Server_IsInvalid()
  79. {
  80. return false;
  81. }
  83. void SectreeTest(LPSECTREE pSec)
  84. {
  85. sys_log(0, " %d %d section attribute ------------------------------", pSec->GetID().coord.x, pSec->GetID().coord.y);
  87. DWORD * line = M2_NEW DWORD[SECTREE_SIZE / CELL_SIZE];
  89. for (int y = 0; y < SECTREE_SIZE / CELL_SIZE; y++)
  90. {
  91. pSec->GetAttributePtr()->CopyRow(y, line);
  93. for (int x = 0; x < SECTREE_SIZE / CELL_SIZE; x++)
  94. printf("%c", line[x] ? 'X' : ' ');
  96. puts("");
  97. }
  99. M2_DELETE_ARRAY(line);
  100. }
  102. int start(int argc, char ** argv)
  103. {
  104. extern const char * _malloc_options;
  105. _malloc_options = "A";
  107. if (lzo_init() != LZO_E_OK)
  108. {
  109. sys_err("lzo_init() failed");
  110. return 0;
  111. }
  113. thecore_init(25, heartbeat);
  114. signal_timer_disable();
  115. return 1;
  116. }
  118. int main(int argc, char ** argv)
  119. {
  120. SECTREE_MANAGER sectree_manager;
  121. DESC_MANAGER desc_manager;
  122. CHARACTER_MANAGER char_manager;
  123. quest::CQuestManager quest_manager; // CHARACTER::Intiailize에서 필요함
  124. CArenaManager arena_manager;
  125. CPVPManager pvp_manager;
  126. LZOManager lzo;
  128. if (!start(argc, argv))
  129. return 0;
  131. signal_timer_disable();
  133. char buf[256];
  134. char last_cmd[256];
  135. char * p;
  137. bool bEnd = false;
  139. while (!bEnd && fgets(buf, 256, stdin))
  140. {
  141. while ((p = strrchr(buf, '\r'))) *p = '\0';
  142. while ((p = strrchr(buf, '\n'))) *p = '\0';
  144. if (buf[0] == '!')
  145. strlcpy(buf, last_cmd, sizeof(buf));
  147. strlcpy(last_cmd, buf, sizeof(last_cmd));
  149. char arg1[64], arg2[64];//, arg3[64], arg4[64];
  150. const char * line = one_argument(buf, arg1, sizeof(arg1));
  152. switch (arg1[0])
  153. {
  154. case 'a':
  155. {
  156. two_arguments(line, arg1, sizeof(arg1), arg2, sizeof(arg2));
  158. if (!*arg1 || !*arg2)
  159. {
  160. printf("Syntax: a <collision data filename> <map directory>\n");
  161. break;
  162. }
  164. ConvertAttribute(arg1, arg2);
  165. puts("build server_attr done");
  166. }
  167. break;
  169. case 'c':
  170. {
  171. one_argument(line, arg1, sizeof(arg1));
  173. if (!*arg1)
  174. {
  175. printf("Syntax: c <filename>\n");
  176. break;
  177. }
  179. ConvertAttribute2(arg1);
  180. }
  181. //ReadColorMapRecursive(line);
  182. break;
  184. case 'b':
  185. {
  186. // Buffer overflow test (must use with valgrind or gdb at least)
  187. LPCHARACTER ch = CHARACTER_MANAGER::instance().CreateCharacter("test");
  189. // 스택에 할당하면 valgrind가 제대로 오류를 잡지 못함
  190. size_t bufsize = 512 + 1;
  191. size_t linesize = 1024 + 1;
  193. if (bufsize > 0 && linesize > 0)
  194. {
  195. char *buf = (char *) malloc(bufsize);
  196. char *line = (char *) malloc(linesize);
  198. memset(buf, 0, bufsize);
  199. memset(line, 0, linesize);
  201. for (size_t i = 0; i < bufsize - 1; ++i)
  202. {
  203. buf[i] = '$';
  204. int linelen = snprintf(line, linesize, "pvp %s", buf);
  206. if (linelen < 0 || linelen >= (int) linesize)
  207. linelen = linesize - 1;
  209. printf("%d %s\n", i, line);
  210. interpret_command(ch, line, linelen);
  211. }
  213. free(buf);
  214. free(line);
  215. }
  216. else
  217. {
  218. printf("size error!\n");
  219. abort();
  220. }
  222. printf("Buffer overflow test finished\n");
  223. }
  224. break;
  226. case 'q':
  227. bEnd = true;
  228. break;
  229. }
  230. }
  232. thecore_destroy();
  233. event_destroy();
  234. return 0;
  235. }
  237. const int region[8][2] =
  238. {
  239. { 0, 64 },
  240. { 64, 128 },
  241. { 128, 192 },
  242. { 192, 256 }
  243. /*{ 0, 32 },
  244. { 32, 64 },
  245. { 64, 96 },
  246. { 96, 128 },
  247. { 128, 160 },
  248. { 160, 192 },
  249. { 192, 224 },
  250. { 224, 256 },*/
  251. };
  253. bool ReadMapAttribute(DWORD dwAreaX, DWORD dwAreaY, const char * c_pszFileName)
  254. {
  255. FILE * fp = fopen(c_pszFileName, "rb");
  257. if (!fp)
  258. {
  259. sys_err("cannot open %s", c_pszFileName);
  260. return false;
  261. }
  263. WORD wCC, wWidth, wHeight;
  264. fread(&wCC, sizeof(WORD), 1, fp);
  266. if (wCC != 2634)
  267. {
  268. sys_err("not a attribute file: %s cc: %d", c_pszFileName, wCC);
  269. fclose(fp);
  270. return false;
  271. }
  273. fread(&wWidth, sizeof(WORD), 1, fp);
  274. fread(&wHeight, sizeof(WORD), 1, fp);
  276. sys_log(0, "Reading attribute on %d %d (w %d h %d)", dwAreaX, dwAreaY, wWidth, wHeight);
  277. //printf("Reading attribute on %d %d (w %d h %d)", dwAreaX, dwAreaY, wWidth, wHeight);
  279. BYTE * pbAttr = M2_NEW BYTE [wWidth * wHeight];
  281. if (fread(pbAttr, sizeof(BYTE), wWidth * wHeight, fp) != (DWORD) (wWidth * wHeight))
  282. {
  283. sys_err("cannot read %s", c_pszFileName);
  284. M2_DELETE_ARRAY(pbAttr);
  285. fclose(fp);
  286. return false;
  287. }
  289. fclose(fp); // close file
  291. //
  292. // 하나의 SECTREE는 6400 PIXEL을 차지 100픽셀이 1미터 이므로
  293. // 1 SECTREE = 64m = 6400px
  294. //
  295. // 클라이언트의 하나의 Area는 256m를 차지하므로 SECTREE 네개를 처리해야
  296. // 한다.
  297. //
  298. DWORD dwStartX, dwStartY, dwEndX, dwEndY;
  300. dwEndX = (dwAreaX + 1) * (25600 / SECTREE_SIZE);
  301. dwEndY = (dwAreaY + 1) * (25600 / SECTREE_SIZE);
  302. dwStartX = dwEndX - (25600 / SECTREE_SIZE);
  303. dwStartY = dwEndY - (25600 / SECTREE_SIZE);
  305. for (DWORD y = dwStartY; y < dwEndY; ++y)
  306. {
  307. for (DWORD x = dwStartX; x < dwEndX; ++x)
  308. {
  309. SECTREEID id;
  311. id.coord.x = x+g_bx;
  312. id.coord.y = y+g_by;
  314. LPSECTREE pSec;
  316. if (!(pSec = g_pkMapSectree->Find(id.package)))
  317. {
  318. sys_err("cannot get sectree (id %d %d)", id.coord.x, id.coord.y);
  319. break;
  320. }
  322. // 64 128 192 256
  323. // 0 1 2 3
  324. for (int ay = region[y - dwStartY][0], py = 0; ay < region[y - dwStartY][1]; ++ay, py += 2)
  325. {
  326. for (int ax = region[x - dwStartX][0], px = 0; ax < region[x - dwStartX][1]; ++ax, px += 2)
  327. {
  328. // AREA의 경우 속성 해상도가 1m 이므로
  329. // CELL 1개가 50x50cm인 SECTREE에서는
  330. // AREA의 속성 한개가 2x2개를 차지 한다.
  331. BYTE bAttr = pbAttr[ay * wHeight + ax];
  333. if (bAttr & ATTR_OBJECT)
  334. {
  335. printf("8");
  336. REMOVE_BIT(bAttr, ATTR_OBJECT);
  337. }
  339. printf("%u", bAttr);
  341. pSec->SetAttribute(px , py , bAttr);
  342. pSec->SetAttribute(px , py + 1, bAttr);
  343. pSec->SetAttribute(px + 1, py , bAttr);
  344. pSec->SetAttribute(px + 1, py + 1, bAttr);
  345. }
  346. }
  347. }
  348. }
  350. M2_DELETE_ARRAY(pbAttr);
  351. return true;
  352. }
  354. void ReadMapRecursive(const char * c_pszFileName)
  355. {
  356. struct stat s;
  357. char buf[512 + 1];
  359. //printf("%s\n",c_pszFileName);
  361. if (stat(c_pszFileName, &s) != 0)
  362. {
  363. sys_log(0, "No map directory: %s", c_pszFileName);
  364. return;
  365. }
  367. if (S_ISDIR(s.st_mode))
  368. {
  369. struct dirent ** namelist;
  370. int n;
  372. n = scandir(c_pszFileName, &namelist, 0, alphasort);
  374. if (n < 0)
  375. perror("scandir");
  376. else
  377. {
  378. while (n-- > 0)
  379. {
  380. if (namelist[n]->d_name[0] == '.')
  381. continue;
  383. snprintf(buf, sizeof(buf), "%s/%s", c_pszFileName, namelist[n]->d_name);
  384. ReadMapRecursive(buf);
  385. }
  386. }
  388. free(namelist);
  389. return;
  390. }
  392. const char * p;
  394. if ((p = strrchr(c_pszFileName, '.')))
  395. {
  396. ++p;
  398. if (!strncmp(p, "atr", 3))
  399. {
  400. int count = 0;
  401. int i;
  403. for (i = strlen(c_pszFileName); i >= 0; --i)
  404. if (c_pszFileName[i] == '/' && ++count == 2)
  405. break;
  407. if (i > 0)
  408. p = &c_pszFileName[i + 1];
  409. else
  410. return;
  412. char szCoordX[4];
  413. char szCoordY[4];
  414. strlcpy(szCoordX, p, sizeof(szCoordX));
  415. strlcpy(szCoordY, p + 3, sizeof(szCoordY));
  417. ReadMapAttribute(atoi(szCoordX), atoi(szCoordY), c_pszFileName);
  418. }
  419. }
  420. }
  422. void ReadColorMap(const char * c_pszFileName)
  423. {
  424. FILE * fp = fopen(c_pszFileName, "rb");
  426. WORD wMagic, wWidth, wHeight;
  427. WORD awTileMap[256 * 256];
  429. fread(&wMagic, sizeof(WORD), 1, fp);
  430. fread(&wWidth, sizeof(WORD), 1, fp);
  431. fread(&wHeight, sizeof(WORD), 1, fp);
  432. fread(&awTileMap, sizeof(WORD), 256 * 256, fp);
  434. bool abUsed[32];
  436. memset(&abUsed, 0, sizeof(abUsed));
  438. for (int y = 0; y < 256; ++y)
  439. for (int x = 0; x < 256; ++x)
  440. {
  441. BYTE t = awTileMap[y * 256 + x] >> 8;
  443. if (t >= 32)
  444. {
  445. printf("ERROR! %d %dx%d\n", t, x, y);
  446. continue;
  447. }
  448. else
  449. abUsed[t] = true;
  450. }
  452. int iUsed = 0;
  454. for (int i = 0; i < 32; ++i)
  455. if (abUsed[i])
  456. ++iUsed;
  458. printf("%s %d\n", c_pszFileName, iUsed);
  459. fclose(fp);
  460. }
  462. void ReadColorMapRecursive(const char * c_pszFileName)
  463. {
  464. struct stat s;
  465. char buf[512 + 1];
  467. if (stat(c_pszFileName, &s) != 0)
  468. {
  469. sys_log(0, "No map directory: %s", c_pszFileName);
  470. return;
  471. }
  473. if (S_ISDIR(s.st_mode))
  474. {
  475. struct dirent ** namelist;
  476. int n;
  478. n = scandir(c_pszFileName, &namelist, 0, alphasort);
  480. if (n < 0)
  481. perror("scandir");
  482. else
  483. {
  484. while (n-- > 0)
  485. {
  486. if (namelist[n]->d_name[0] == '.')
  487. continue;
  489. snprintf(buf, sizeof(buf), "%s/%s", c_pszFileName, namelist[n]->d_name);
  490. ReadColorMapRecursive(buf);
  491. }
  492. }
  494. free(namelist);
  495. return;
  496. }
  498. char * p;
  500. if ((p = strrchr(c_pszFileName, '.')))
  501. {
  502. ++p;
  504. if (!strncmp(p, "cmp", 3))
  505. ReadColorMap(c_pszFileName);
  506. }
  507. }
  509. template <typename _f>
  510. void ProcessLine(int sx, int sy, int ex, int ey, _f f)
  511. {
  512. int mode = 0;
  513. int w, h;
  514. int x = 0, y = 0;
  515. int d;
  516. int px, py;
  518. // 0: dx > 0 && dy > 0
  519. // 1: dx < 0 && dy > 0
  520. // 2: dx > 0 && dy < 0
  521. // 3: dx < 0 && dy < 0
  522. if (sx > ex)
  523. {
  524. mode |= 1;
  525. w = sx - ex;
  526. }
  527. else
  528. w = ex - sx;
  530. if (sy > ey)
  531. {
  532. mode |= 2;
  533. h = sy - ey;
  534. }
  535. else
  536. h = ey - sy;
  538. // distance = (w * w) + (h * h); // 거리
  539. if (w > h)
  540. {
  541. d = (h << 1) - w;
  543. while (x < w)
  544. {
  545. if (d < 0)
  546. {
  547. d += (h << 1);
  548. x++;
  549. }
  550. else
  551. {
  552. d += ((h - w) << 1);
  554. x++;
  555. y++;
  556. }
  558. switch (mode)
  559. {
  560. case 0: px = sx + x; py = sy + y; break;
  561. case 1: px = sx - x; py = sy + y; break;
  562. case 2: px = sx + x; py = sy - y; break;
  563. case 3: px = sx - x; py = sy - y; break;
  564. default: return;
  565. }
  567. if (!f(px, py)) // false 가 리턴 되면 중단 한다.
  568. {
  569. printf("putting error %d %d", px, py);
  570. return;
  571. }
  572. }
  573. }
  574. else
  575. {
  576. d = h - (w << 1);
  578. while (y < h)
  579. {
  580. if (d > 0)
  581. {
  582. d += -(w << 1);
  583. y++;
  584. }
  585. else
  586. {
  587. d += ((h - w) << 1);
  588. x++;
  589. y++;
  590. }
  592. switch (mode)
  593. {
  594. case 0: px = sx + x; py = sy + y; break;
  595. case 1: px = sx - x; py = sy + y; break;
  596. case 2: px = sx + x; py = sy - y; break;
  597. case 3: px = sx - x; py = sy - y; break;
  598. default: return;
  599. }
  601. if (!f(px, py)) // false 가 리턴 되면 중단 한다.
  602. {
  603. printf("putting error %d %d", px, py);
  604. return;
  605. }
  606. }
  607. }
  608. }
  610. template <typename _f>
  611. void ProcessSphere(float x, float y, float fRadius, _f f)
  612. {
  613. //printf("%f %f %f\n", x, y, fRadius);
  614. int r = (int)fRadius + 1;
  615. int ix = (int)x;
  616. int iy = (int)y;
  617. //int ex = (int) (ix + r);
  618. //int ey = (int) (iy + r);
  619. //printf("%d %d %d\n", ix, iy, r);
  621. for (int rx = - r; rx < + r; rx+=25)
  622. for (int ry = - r; ry < + r; ry+=25)
  623. {
  624. //printf("%d %d %d %d %d %d\n", rx, ry, ix-rx, iy-ry, (ix-rx)*(ix-rx)+(iy-ry)*(iy-ry), r*r);
  625. //if ((ix-rx)*(ix-rx)+(iy-ry)*(iy-ry)<r*r)
  626. if (rx*rx + ry*ry < r*r)
  627. {
  628. //printf("#%d %d\n", rx+ix, ry+iy);
  629. if (!f(rx+ix, ry+iy))
  630. {
  631. printf("putting error");
  632. return;
  633. }
  634. }
  635. }
  636. }
  638. bool BlockAttribute(int x, int y)
  639. {
  640. int bx = x / SECTREE_SIZE;
  641. int by = y / SECTREE_SIZE;
  643. SECTREEID id;
  645. id.coord.x = bx;
  646. id.coord.y = by;
  648. LPSECTREE pSec = g_pkMapSectree->Find(id.package);
  650. if (!pSec)
  651. {
  652. printf("BlockAttribute: no sectree on %d %d", bx, by);
  653. return false;
  654. }
  656. pSec->SetAttribute((x % SECTREE_SIZE) / CELL_SIZE, (y % SECTREE_SIZE) / CELL_SIZE, 1);
  657. //printf("BlockAttribute: put on %d %d", x, y);
  658. return true;
  659. }
  661. void ReadCollisionData(const char * c_pszFileName, int iBaseX, int iBaseY)
  662. {
  663. FILE * fp = fopen(c_pszFileName, "rb");
  665. printf("Reading collision data file: %s\n", c_pszFileName);
  667. if (!fp)
  668. {
  669. printf("No collision data file: %s\n", c_pszFileName);
  670. return;
  671. }
  673. DWORD dwFourCC;
  674. fread(&dwFourCC, sizeof(DWORD), 1, fp);
  676. if (dwFourCC != MAKEFOURCC('M', '2', 'C', 'D'))
  677. {
  678. printf("Not a collision data file: %s", c_pszFileName);
  679. fclose(fp);
  680. return;
  681. }
  683. WORD wxSize, wySize;
  684. fread(&wxSize, sizeof(WORD), 1, fp);
  685. fread(&wySize, sizeof(WORD), 1, fp);
  687. printf("collision area size: %d %d", wxSize, wySize);
  689. for (DWORD x = 0; x < wxSize; ++x)
  690. {
  691. for (DWORD y = 0; y < wySize; ++y)
  692. {
  693. DWORD dwCount;
  694. fread(&dwCount, sizeof(DWORD), 1, fp);
  696. printf("\n%ux%u %u ", x, y, dwCount);
  698. for (DWORD j = 0; j < dwCount; ++j)
  699. {
  700. BYTE bType;
  701. fread(&bType, sizeof(BYTE), 1, fp);
  703. switch (bType)
  704. {
  705. case COLLISION_TYPE_PLANE:
  706. printf("P");
  707. {
  708. TPlaneData PlaneData;
  709. fread(&PlaneData, sizeof(TPlaneData), 1, fp);
  711. int pairs[6][2] =
  712. {
  713. { 0, 3 },
  714. { 0, 1 },
  715. { 0, 2 },
  716. { 1, 2 },
  717. { 1, 3 },
  718. { 2, 3 },
  719. };
  721. for (int iPairIndex = 0; iPairIndex < 6; iPairIndex++)
  722. {
  723. int iFrom = pairs[iPairIndex][0];
  724. int iTo = pairs[iPairIndex][1];
  726. if (fabs(PlaneData.v3QuadPosition[iFrom].x - PlaneData.v3QuadPosition[iTo].x) > 100000.0f ||
  727. fabs(PlaneData.v3QuadPosition[iFrom].y - PlaneData.v3QuadPosition[iTo].y) > 100000.0f)
  728. {
  729. sys_log(0, "Blcok too big: %d %d %d %d",
  730. iBaseX + (int) PlaneData.v3QuadPosition[iFrom].x,
  731. iBaseY + (int) -PlaneData.v3QuadPosition[iFrom].y,
  732. iBaseX + (int) PlaneData.v3QuadPosition[iTo].x,
  733. iBaseY + (int) -PlaneData.v3QuadPosition[iTo].y);
  734. }
  735. else
  736. {
  737. printf("Block %d %d %d %d\n",
  738. iBaseX + (int) PlaneData.v3QuadPosition[iFrom].x,
  739. iBaseY + (int) -PlaneData.v3QuadPosition[iFrom].y,
  740. iBaseX + (int) PlaneData.v3QuadPosition[iTo].x,
  741. iBaseY + (int) -PlaneData.v3QuadPosition[iTo].y);
  744. ProcessLine(
  745. iBaseX + (int) PlaneData.v3QuadPosition[iFrom].x,
  746. iBaseY + (int) -PlaneData.v3QuadPosition[iFrom].y,
  747. iBaseX + (int) PlaneData.v3QuadPosition[iTo].x,
  748. iBaseY + (int) -PlaneData.v3QuadPosition[iTo].y,
  749. BlockAttribute);
  751. }
  752. }
  753. // 사각형 채우기도 합시다
  754. // 0 1 2 3 순서대로
  755. // -- +- -+ ++
  756. // 근데 y 는 마이너스 취하는거 확인하시길
  757. // TODO
  758. }
  759. break;
  761. case COLLISION_TYPE_SPHERE:
  762. printf("S");
  763. {
  764. TSphereData SphereData;
  765. fread(&SphereData, sizeof(TSphereData), 1, fp);
  766. ProcessSphere(
  767. iBaseX + SphereData.v3Position.x,
  768. iBaseY - SphereData.v3Position.y,
  769. SphereData.fRadius,
  770. BlockAttribute);
  771. }
  772. break;
  774. case COLLISION_TYPE_CYLINDER:
  775. printf("C");
  776. {
  777. TCylinderData CylinderData;
  778. fread(&CylinderData, sizeof(TCylinderData), 1, fp);
  779. ProcessSphere(
  780. iBaseX + CylinderData.v3Position.x,
  781. iBaseY - CylinderData.v3Position.y,
  782. CylinderData.fRadius,
  783. BlockAttribute);
  784. }
  785. break;
  787. default:
  788. printf("invalid type!");
  789. break;
  790. }
  791. }
  792. }
  793. }
  795. printf("%d %d\n", iBaseX, iBaseY);
  797. fclose(fp);
  798. }
  800. void ConvertAttribute(const char * c_pszCollisionDataFileName, const char * c_pszMapDirectory)
  801. {
  802. char szFilename[256];
  803. snprintf(szFilename, sizeof(szFilename), "%s/Setting.txt", c_pszMapDirectory);
  804. TMapSetting setting;
  805. SECTREE_MANAGER::instance().LoadSettingFile(0, szFilename, setting);
  806. g_pkMapSectree = SECTREE_MANAGER::instance().BuildSectreeFromSetting(setting);
  807. int iMapHeight = setting.iHeight / 128 / 200;
  808. int iMapWidth = setting.iWidth / 128 / 200;
  810. if (iMapHeight < 0 || iMapWidth < 0)
  811. {
  812. printf("SYSERR: setting.w/h %d %d, base %d %d\n", setting.iWidth, setting.iHeight, setting.iBaseX, setting.iBaseY);
  813. return;
  814. }
  816. int bx = setting.iBaseX;
  817. int by = setting.iBaseY;
  819. printf("w %d h %d\n", iMapWidth, iMapHeight);
  820. bx /= SECTREE_SIZE;
  821. by /= SECTREE_SIZE;
  822. g_bx = bx;
  823. g_by = by;
  825. printf("bx by %d %d\n", bx, by);
  826. int x, y;
  828. // 일단 속성 초기화
  829. for (y = 0; y < iMapHeight * (25600 / SECTREE_SIZE); ++y)
  830. {
  831. for (x = 0; x < iMapWidth * (25600 / SECTREE_SIZE); ++x)
  832. {
  833. SECTREEID id;
  835. id.coord.x = x + bx;
  836. id.coord.y = y + by;
  838. g_pkMapSectree->Find(id.package)->BindAttribute(M2_NEW CAttribute(SECTREE_SIZE / CELL_SIZE, SECTREE_SIZE / CELL_SIZE));
  839. }
  840. }
  842. ReadMapRecursive(c_pszMapDirectory);
  844. printf("iMapWidth %d iMapHeight %d\n", iMapWidth, iMapHeight);
  846. ReadCollisionData(c_pszCollisionDataFileName, setting.iBaseX, setting.iBaseY);
  848. SECTREE_MANAGER::instance().SaveAttributeToImage(0, "test.tga", g_pkMapSectree);
  850. snprintf(szFilename, sizeof(szFilename), "%s/server_attr", c_pszMapDirectory);
  852. FILE * fp = fopen(szFilename, "wb");
  854. if (!fp)
  855. {
  856. sys_err("cannot open %s for writing", szFilename);
  857. return;
  858. }
  860. iMapWidth *= 4;
  861. iMapHeight *= 4;
  863. fwrite(&iMapWidth, sizeof(int), 1, fp);
  864. fwrite(&iMapHeight, sizeof(int), 1, fp);
  866. unsigned int uiBlockSize = sizeof(DWORD) * (SECTREE_SIZE / CELL_SIZE) * (SECTREE_SIZE / CELL_SIZE);
  867. unsigned int uiMemSize = iMapWidth * iMapHeight;
  868. unsigned int uiCompSize;
  870. printf("Attribute size: %u block %u\n", uiMemSize, uiBlockSize);
  871. char * pAttr = (char *) malloc(LZOManager::instance().GetMaxCompressedSize(sizeof(DWORD) * (SECTREE_SIZE / CELL_SIZE) * (SECTREE_SIZE / CELL_SIZE)));
  873. for (y = 0; y < iMapHeight; ++y)
  874. for (x = 0; x < iMapWidth; ++x)
  875. {
  876. SECTREEID id;
  878. id.coord.x = x+bx;
  879. id.coord.y = y+by;
  881. LPSECTREE pSec = g_pkMapSectree->Find(id.package);
  883. LZOManager::instance().Compress((unsigned char *) pSec->GetAttributePtr()->GetDataPtr(),
  884. uiBlockSize,
  885. (unsigned char *) pAttr,
  886. &uiCompSize);
  888. fwrite(&uiCompSize, sizeof(int), 1, fp);
  889. fwrite(pAttr, sizeof(char), uiCompSize, fp);
  890. }
  892. fclose(fp);
  893. free(pAttr);
  894. }
  896. void ConvertAttribute2(const char * filename)
  897. {
  898. std::string newFileName = std::string(filename) + ".new";
  899. FILE * fp = fopen(filename, "rb");
  900. FILE * wfp = fopen(newFileName.c_str(), "wb");
  902. if (!fp)
  903. {
  904. printf("cannot open %s\n", filename);
  905. return;
  906. }
  908. if (!wfp)
  909. {
  910. printf("cannot open %s\n", newFileName.c_str());
  911. return;
  912. }
  914. unsigned int uiSize;
  915. unsigned int uiDestSize;
  917. size_t maxMemSize = LZOManager::instance().GetMaxCompressedSize(sizeof(DWORD) * (SECTREE_SIZE / CELL_SIZE) * (SECTREE_SIZE / CELL_SIZE));
  919. BYTE abComp[maxMemSize];
  920. DWORD * attr = M2_NEW DWORD[maxMemSize];
  922. int iWidth, iHeight;
  924. fread(&iWidth, sizeof(int), 1, fp);
  925. fread(&iHeight, sizeof(int), 1, fp);
  927. fwrite(&iWidth, sizeof(int), 1, wfp);
  928. fwrite(&iHeight, sizeof(int), 1, wfp);
  930. printf("width %d height %d\n", iWidth, iHeight);
  931. sleep(1);
  933. for (int y = 0; y < iHeight; ++y)
  934. for (int x = 0; x < iWidth; ++x)
  935. {
  936. fread(&uiSize, sizeof(int), 1, fp);
  937. fread(abComp, sizeof(char), uiSize, fp);
  939. printf("orig_size %d ", uiSize);
  940. uiDestSize = sizeof(DWORD) * maxMemSize;
  941. LZOManager::instance().Decompress(abComp, uiSize, (BYTE *) attr, &uiDestSize);
  943. if (uiDestSize != sizeof(DWORD) * (SECTREE_SIZE / CELL_SIZE) * (SECTREE_SIZE / CELL_SIZE))
  944. {
  945. printf("SECTREE_MANAGER::LoadAttribte: %s: size mismatch! %d\n", filename, uiDestSize);
  946. fclose(fp);
  948. M2_DELETE_ARRAY(attr);
  949. continue;
  950. }
  952. bool found = false;
  954. for (int i = 0; i < (SECTREE_SIZE / CELL_SIZE) * (SECTREE_SIZE / CELL_SIZE); ++i)
  955. if (IS_SET(attr[i], 0xFFFFFFF8))
  956. {
  957. if (!found)
  958. {
  959. printf("!!! ");
  960. found = true;
  961. }
  963. REMOVE_BIT(attr[i], 0xFFFFFFF8);
  964. }
  966. LZOManager::instance().Compress((unsigned char *) attr, uiDestSize, abComp, &uiDestSize);
  967. printf("new_size %d\n", uiDestSize);
  969. fwrite(&uiDestSize, sizeof(int), 1, wfp);
  970. fwrite(abComp, uiDestSize, 1, wfp);
  971. }
  973. fclose(fp);
  974. fclose(wfp);
  975. }