/miku/plugins/extendMap.enchant.js

https://github.com/tkayama/hanachin.github.com · JavaScript · 313 lines · 280 code · 9 blank · 24 comment · 91 complexity · 3a99726a93722d4780260aaa7b886492 MD5 · raw file 

    

  1. /**
    2. 

  2.  *  extendMap.enchant.js
    3. 

  3.  *
    4. 

  4.  *  enchantMapEditor:
    5. 

  5.  *  http://github.com/wise9/enchantMapEditor
    6. 

  6.  */
    7. 

  7. 

  8. enchant.extendMap = {};
    9. 

  9. enchant.extendMap.ExMap = enchant.Class.create(enchant.Map, {
    10. 

  10.     type2data: function() {
    11. 

  11.         var len = this._typeData.length;
    12. 

  12.         var xlen = this._typeData[0][0].length;
    13. 

  13.         var ylen = this._typeData[0].length;
    14. 

  14.         for (var index = 0; index < len; index++) { 
    15. 

  15.             this._data[index] = new Array();
    16. 

  16.             for (var y = 0; y < ylen; y++) {
    17. 

  17.                 this._data[index][y] = new Array();
    18. 

  18.                 for (var x = 0; x < xlen; x++) {
    19. 

  19.                     this._data[index][y][x] = this.searchPattern(index, x, y);
    20. 

  20.                 }
    21. 

  21.             }
    22. 

  22.         }
    23. 

  23.     },
    24. 

  24.     data2type: function() {
    25. 

  25.         var len = this._data.length;
    26. 

  26.         var xlen = this._data[0][0].length;
    27. 

  27.         var ylen = this._data[0].length;
    28. 

  28.         this._typeData = new Array();
    29. 

  29.         for (var index = 0; index < len; index++) { 
    30. 

  30.             this._typeData[index] = new Array();
    31. 

  31.             for (var y = 0; y < ylen; y++) {
    32. 

  32.                 this._typeData[index][y] = new Array();
    33. 

  33.                 for (var x = 0; x < xlen; x++) {
    34. 

  34.                     this._typeData[index][y][x] = Math.floor(this._data[index][y][x] / 68);
    35. 

  35.                     if (this._data[index][y][x] % 17 > 12) {
    36. 

  36.                         this._typeData[index][y][x] = -1;
    37. 

  37.                     }
    38. 

  38.                 }
    39. 

  39.             }
    40. 

  40.         }
    41. 

  41.     },
    42. 

  42.     isOwn: function(index, x, y, own) {
    43. 

  43.         var data = this._typeData[index][y][x];
    44. 

  44.         if (data == own
    45. 

  45.             || data == -1
    46. 

  46.             || data > 7
    47. 

  47.             || (typeof this._types != 'undefined')
    48. 

  48.             && this._types[data].parentNum == this._types[own].baseNum) {
    49. 

  49.             return true;
    50. 

  50.         } else {
    51. 

  51.             return false;
    52. 

  52.         }
    53. 

  53.     },
    54. 

  54.     searchPattern: function(index, x, y) {
    55. 

  55.         var patternTable = {
    56. 

  56.               0:42,   2:54,   8: 3,  10:53,  11:57,  16: 1,  18:51,  22:55,  24: 2,  26:52,
    57. 

  57.              27:44,  30:45,  31:56,  64:20,  66:37,  72:19,  74:36,  75:10,  80:17,  82:34,
    58. 

  58.              86:11,  88:18,  90:35,  91:60,  94:58,  95:59, 104:23, 106:27, 107:40, 120:61,
    59. 

  59.             122:26, 123:43, 126: 9, 127: 6, 208:21, 210:28, 214:38, 216:62, 218:24, 222:41,
    60. 

  60.             223: 7, 219: 8, 248:22, 250:25, 251: 4, 254: 5, 255:39
    61. 

  61.         };
    62. 

  62.         var patternNumber = 0;
    63. 

  63.         var own = this._typeData[index][y][x];
    64. 

  64.         var xlen = this._typeData[index][y].length - 1;
    65. 

  65.         var ylen = this._typeData[index].length - 1;
    66. 

  66.         if (own == -1) {
    67. 

  67.             return -1;
    68. 

  68.         } else if (own > 7) {
    69. 

  69.             return this._data[index][y][x];
    70. 

  70.         }
    71. 

  71.         if (x == 0) {
    72. 

  72.             patternNumber |= 41;
    73. 

  73.         } else if (x == xlen) {
    74. 

  74.             patternNumber |= 148;
    75. 

  75.         }
    76. 

  76.         if (y == 0) {
    77. 

  77.             patternNumber |= 7;
    78. 

  78.         } else if (y == ylen) {
    79. 

  79.             patternNumber |= 224;
    80. 

  80.         }
    81. 

  81. 

  82.         if (x > 0) {
    83. 

  83.             if (this.isOwn(index, x - 1, y, own)) {
    84. 

  84.                 patternNumber += 8;
    85. 

  85.             }
    86. 

  86. 

  87.         }
    88. 

  88.         if (x < xlen) {
    89. 

  89.             if (this.isOwn(index, x + 1, y, own)) {
    90. 

  90.                 patternNumber += 16;
    91. 

  91.             }
    92. 

  92.         }
    93. 

  93.         if (y > 0) {
    94. 

  94.             if (this.isOwn(index, x, y - 1, own)) {
    95. 

  95.                 patternNumber += 2;
    96. 

  96.             }
    97. 

  97.         }
    98. 

  98.         if (y < ylen) {
    99. 

  99.             if (this.isOwn(index, x, y + 1, own)) {
    100. 

  100.                 patternNumber += 64;
    101. 

  101.             }
    102. 

  102.         }
    103. 

  103.         if (x > 0 && y > 0) {
    104. 

  104.             if (this.isOwn(index, x - 1, y - 1, own)) {
    105. 

  105.                 patternNumber += 1;
    106. 

  106.             }
    107. 

  107.         }
    108. 

  108.         if (x < xlen && y > 0) {
    109. 

  109.             if (this.isOwn(index, x + 1, y - 1, own)) {
    110. 

  110.                 patternNumber += 4;
    111. 

  111.             }
    112. 

  112.         }
    113. 

  113.         if (x > 0 && y < ylen) {
    114. 

  114.             if (this.isOwn(index, x - 1, y + 1, own)) {
    115. 

  115.                 patternNumber += 32;
    116. 

  116.             }
    117. 

  117.         }
    118. 

  118.         if (x < xlen && y < ylen) {
    119. 

  119.             if (this.isOwn(index, x + 1, y + 1, own)) {
    120. 

  120.                 patternNumber += 128;
    121. 

  121.             }
    122. 

  122.         }
    123. 

  123. 

  124.         if (!((patternNumber & 1) && (patternNumber & 2) && (patternNumber & 8))) {
    125. 

  125.             patternNumber &= 254;
    126. 

  126.         }
    127. 

  127.         if (!((patternNumber & 4) && (patternNumber & 2) && (patternNumber & 16))) {
    128. 

  128.             patternNumber &= 251;
    129. 

  129.         }
    130. 

  130.         if (!((patternNumber & 32) && (patternNumber & 64) && (patternNumber & 8))) {
    131. 

  131.             patternNumber &= 223;
    132. 

  132.         }
    133. 

  133.         if (!((patternNumber & 128) && (patternNumber & 64) && (patternNumber & 16))) {
    134. 

  134.             patternNumber &= 127;
    135. 

  135.         }
    136. 

  136. 

  137.         if (patternTable.hasOwnProperty(patternNumber)) {
    138. 

  138.             var ret = own * 68 + patternTable[patternNumber];
    139. 

  139.         } else {
    140. 

  140.             var ret = -1;
    141. 

  141.             console.log('this._typeData[' + index + '][' + y + '][' + x + '] = ' + patternNumber + ' // undefined');
    142. 

  142.         }
    143. 

  143.         return ret;
    144. 

  144.     },
    145. 

  145.     match: function(ind1, ind2) {
    146. 

  146.         var i = 0;
    147. 

  147.         while (i < 1024) {
    148. 

  148.             if(this._types[ind1].baseType[i] ^ this._types[ind2].parentType[i]) {
    149. 

  149.                 return false;
    150. 

  150.             } else {
    151. 

  151.                 i++;
    152. 

  152.             }
    153. 

  153.         }
    154. 

  154.         return true;
    155. 

  155.     },
    156. 

  156.     loadTypeData: function(data) {
    157. 

  157.         this._typeData = Array.prototype.slice.apply(arguments);
    158. 

  158.         this._dirty = true;
    159. 

  159.         this.type2data();
    160. 

  160.         var c = 0;
    161. 

  161.         for (var index = 0, l = this._data.length; index < l; index++) {
    162. 

  162.             for (var y = 0, ll = this._data[0].length; y < ll; y++) {
    163. 

  163.                 for (var x = 0, lll = this._data[0][0].length; x < lll; x++) {
    164. 

  164.                     if (this._typeData[index][y][x] > 7) {
    165. 

  165.                         this._typeData[index][y][x] = -1;
    166. 

  166.                     }
    167. 

  167.                     if (this._data[index][y][x] >= 0) {
    168. 

  168.                         c++;
    169. 

  169.                     }
    170. 

  170.                 }
    171. 

  171.             }
    172. 

  172.         }
    173. 

  173.         if (c / (data.length * data[0].length) > 0.2) {
    174. 

  174.             this._tight = true;
    175. 

  175.         } else {
    176. 

  176.             this._tight = false;
    177. 

  177.         }
    178. 

  178.     },
    179. 

  179.     loadData: function(data) {
    180. 

  180.         this._data = Array.prototype.slice.apply(arguments);
    181. 

  181.         this._dirty = true;
    182. 

  182.         this.data2type();
    183. 

  183.         var c = 0;
    184. 

  184.         for (var index = 0, l = this._data.length; index < l; index++) {
    185. 

  185.             for (var y = 0, ll = this._data[0].length; y < ll; y++) {
    186. 

  186.                 for (var x = 0, lll = this._data[0][0].length; x < lll; x++) {
    187. 

  187.                     if (this._data[index][y][x] >= 0) {
    188. 

  188.                         c++;
    189. 

  189.                     }
    190. 

  190.                 }
    191. 

  191.             }
    192. 

  192.         }
    193. 

  193.         if (c / (data.length * data[0].length) > 0.2) {
    194. 

  194.             this._tight = true;
    195. 

  195.         } else {
    196. 

  196.             this._tight = false;
    197. 

  197.         }
    198. 

  198.     },
    199. 

  199.     image: {
    200. 

  200.         get: function() {
    201. 

  201.             return this._image;
    202. 

  202.         },
    203. 

  203.         set: function(image) {
    204. 

  204.             var img = image.clone();
    205. 

  205.             var game = enchant.Game.instance;
    206. 

  206.             var surface = new Surface(272, 512);
    207. 

  207.             var Type = function(image, left, top, tileWidth, tileHeight) {
    208. 

  208.                 this.baseType = [];
    209. 

  209.                 this.parentType = [];
    210. 

  210.                 this.baseType = image.context.getImageData(left, top, tileWidth, tileHeight).data;
    211. 

  211.                 this.parentType = image.context.getImageData(left + tileWidth, top, tileWidth, tileHeight).data;
    212. 

  212.             };
    213. 

  213.             var extract = function(left, top, sx, sy) {
    214. 

  214.                 var params = [
    215. 

  215.                     [  0, 16, 48,  8, 16, 0, 48,  8 ], [  0, 56, 48,  8, 16, 8, 48,  8 ],
    216. 

  216.                     [  0, 16,  8, 48, 48,16,  8, 48 ], [ 40, 16,  8, 48, 56,16,  8, 48 ],
    217. 

  217.                     [  0, 16, 48, 48,  0,16, 48, 48 ], [ 40,  8,  8,  8,  8,24,  8,  8 ],
    218. 

  218.                     [ 40,  0,  8,  8,  8,48,  8,  8 ], [ 32,  8,  8,  8, 32,24,  8,  8 ],
    219. 

  219.                     [ 32,  0,  8,  8, 32,48,  8,  8 ], [ 40,  0,  8,  8,  8,32,  8,  8 ],
    220. 

  220.                     [ 40,  8,  8,  8,  8,40,  8,  8 ], [ 32,  0,  8,  8, 32,32,  8,  8 ],
    221. 

  221.                     [ 32,  8,  8,  8, 32,40,  8,  8 ], [ 32,  8,  8,  8, 16,24,  8,  8 ],
    222. 

  222.                     [ 40,  8,  8,  8, 24,24,  8,  8 ], [ 40,  0,  8,  8, 24,48,  8,  8 ],
    223. 

  223.                     [ 32,  0,  8,  8, 16,48,  8,  8 ], [ 32,  0, 16, 16,112,16, 16, 16 ],
    224. 

  224.                     [ 32,  0, 16, 16,112,32, 16, 16 ], [ 32,  0, 16, 16,112,48, 16, 16 ],
    225. 

  225.                     [ 32,  0, 16, 16,128,16, 16, 16 ], [ 32,  0, 16, 16,128,48, 16, 16 ],
    226. 

  226.                     [ 32,  0, 16, 16,144,16, 16, 16 ], [ 32,  0, 16, 16,144,32, 16, 16 ],
    227. 

  227.                     [ 32,  0, 16, 16,144,48, 16, 16 ], [ 24, 32,  8,  8,120,48,  8,  8 ],
    228. 

  228.                     [ 24, 40,  8,  8,120,24,  8,  8 ], [ 16, 32,  8,  8,144,48,  8,  8 ],
    229. 

  229.                     [ 16, 40,  8,  8,144,24,  8,  8 ], [ 16, 40, 16,  8,128,24, 16,  8 ],
    230. 

  230.                     [ 16, 32, 16,  8,128,48, 16,  8 ], [ 24, 32,  8, 16,120,32,  8, 16 ],
    231. 

  231.                     [ 16, 32,  8, 16,144,32,  8, 16 ], [  0, 16,  8,  8,128,32,  8,  8 ],
    232. 

  232.                     [ 40, 16,  8,  8,136,32,  8,  8 ], [  0, 56,  8,  8,128,40,  8,  8 ],
    233. 

  233.                     [ 40, 56,  8,  8,136,40,  8,  8 ], [ 16, 32, 16, 16, 64, 0, 16, 16 ],
    234. 

  234.                     [ 40,  0,  8,  8, 72, 0,  8,  8 ], [ 16, 32, 16, 16, 80, 0, 16, 16 ],
    235. 

  235.                     [ 32,  0,  8,  8, 80, 0,  8,  8 ], [ 16, 32, 16, 16, 96, 0, 16, 16 ],
    236. 

  236.                     [ 40,  8,  8,  8,104, 8,  8,  8 ], [ 16, 32, 16, 16,112, 0, 16, 16 ],
    237. 

  237.                     [ 32,  8,  8,  8,112, 8,  8,  8 ], [ 16, 32, 16, 16,128, 0, 16, 16 ],
    238. 

  238.                     [ 40,  0,  8,  8,136, 0,  8,  8 ], [ 32,  8,  8,  8,128, 8,  8,  8 ],
    239. 

  239.                     [ 16, 32, 16, 16,144, 0, 16, 16 ], [ 32,  0,  8,  8,144, 0,  8,  8 ],
    240. 

  240.                     [ 40,  8,  8,  8,152, 8,  8,  8 ], [ 32, 32, 16, 16,160, 0, 16, 16 ],
    241. 

  241.                     [ 32, 32, 16, 16,160,16, 16, 16 ], [ 32,  8,  8,  8,160, 8,  8,  8 ],
    242. 

  242.                     [ 32,  0,  8,  8,160,16,  8,  8 ], [  0, 32, 16, 16,176, 0, 16, 16 ],
    243. 

  243.                     [  0, 32, 16, 16,176,16, 16, 16 ], [ 40,  8,  8,  8,184, 8,  8,  8 ],
    244. 

  244.                     [ 40,  0,  8,  8,184,16,  8,  8 ], [  8, 48, 16, 16,160,32, 16, 16 ],
    245. 

  245.                     [  8, 48, 16, 16,176,32, 16, 16 ], [ 40,  0,  8,  8,168,32,  8,  8 ],
    246. 

  246.                     [ 32,  0,  8,  8,176,32,  8,  8 ], [  8, 16, 16, 16,160,48, 16, 16 ],
    247. 

  247.                     [  8, 16, 16, 16,176,48, 16, 16 ], [ 40,  8,  8,  8,168,56,  8,  8 ],
    248. 

  248.                     [ 32,  8,  8,  8,176,56,  8,  8 ], [  0,  0, 16, 16,  0, 0, 16, 16 ],
    249. 

  249.                     [  0, 16, 48, 48, 64,16, 48, 48 ], [ 32,  0, 16, 16, 16,32, 16, 16 ]
    250. 

  250.                 ];
    251. 

  251.                 for (var i = 0, l = params.length; i < l; i++) {
    252. 

  252.                     params[i][0] += left;
    253. 

  253.                     params[i][1] += top;
    254. 

  254.                     params[i][4] += sx;
    255. 

  255.                     params[i][5] += sy;
    256. 

  256.                     params[i].unshift(image);
    257. 

  257.                     surface.draw.apply(surface, params[i]);
    258. 

  258.                 }
    259. 

  259.             };
    260. 

  260. 

  261.             // イメージの展開
    262. 

  262.             surface.draw(image, 96, 0, 80, 256, 192, 0, 80, 256);
    263. 

  263.             surface.draw(image, 176, 0, 80, 256, 192, 256, 80, 256);
    264. 

  264.             for (var y = 0; y < 4; y++) {
    265. 

  265.                 for(var x = 0; x < 2; x++) {
    266. 

  266.                     var left = x * 48;
    267. 

  267.                     var top = y * 64;
    268. 

  268.                     extract(left, top, 0, (x+y*2)*64); 
    269. 

  269.                 }
    270. 

  270.             }
    271. 

  271.     
    272. 

  272.             this._image = surface;
    273. 

  273.             this._types = new Array();
    274. 

  274. 

  275.             for (var y = 0; y < 4; y++) {
    276. 

  276.                 for(var x = 0; x < 2; x++) {
    277. 

  277.                     var left = x * 48;
    278. 

  278.                     var top = y * 64;
    279. 

  279.                     this._types[x+y*2] = new Type(img, left, top, this.tileWidth, this.tileHeight);
    280. 

  280.                 }
    281. 

  281.             }
    282. 

  282.             for (var i = 0; i < 8; i++) {
    283. 

  283.                 for (var j = 0; j < 8; j++) {
    284. 

  284.                     if (this.match(i, j)) {
    285. 

  285.                         this._types[j].parentNum = i;
    286. 

  286.                     }
    287. 

  287.                 }
    288. 

  288.                 if (this._types[i].parentNum == undefined) {
    289. 

  289.                     this._types[i].parentNum = i;
    290. 

  290.                 }
    291. 

  291.                 this._types[i].baseNum = i;
    292. 

  292.             }
    293. 

  293. 

  294.             /*
    295. 

  295.             if (RETINA_DISPLAY && game.scale == 2) { 
    296. 

  296.                 var img = new Surface(image.width * 2, image.height * 2);
    297. 

  297.                 var tileWidth = this._tileWidth || image.width;
    298. 

  298.                 var tileHeight = this._tileHeight || image.height;
    299. 

  299.                 var row = image.width / tileWidth | 0; 
    300. 

  300.                 var col = image.height / tileHeight | 0; 
    301. 

  301.                 for (var y = 0; y < col; y++) {
    302. 

  302.                     for (var x = 0; x < row; x++) {
    303. 

  303.                         img.draw(image, x * tileWidth, y * tileHeight, tileWidth, tileHeight,
    304. 

  304.                             x * tileWidth * 2, y * tileHeight * 2, tileWidth * 2, tileHeight * 2);
    305. 

  305.                     }    
    306. 

  306.                 }    
    307. 

  307.                 this._doubledImage = img; 
    308. 

  308.             }    
    309. 

  309.             this._dirty = true;
    310. 

  310.             */
    311. 

  311.         }    
    312. 

  312.     }   
    313. 

  313. });
    314.