API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 25th, 2017
100
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 25.98 KB | None | 0 0
raw download clone embed print report
  1. package com.runescape.cache.graphics;
  2. import java.awt.*;
  3. import java.awt.image.PixelGrabber;
  4.  
  5. import javax.swing.ImageIcon;
  6.  
  7. import org.seven.util.FileUtils;
  8.  
  9. import com.runescape.Client;
  10. import com.runescape.cache.FileArchive;
  11. import com.runescape.draw.Rasterizer2D;
  12. import com.runescape.io.Buffer;
  13. import com.runescape.sign.SignLink;
  14.  
  15. public final class Sprite extends Rasterizer2D {
  16.  
  17. public Sprite(int i, int j) {
  18. myPixels = new int[i * j];
  19. myWidth = maxWidth = i;
  20. myHeight = maxHeight = j;
  21. drawOffsetX = drawOffsetY = 0;
  22. }
  23.  
  24.  
  25. public Sprite(byte data[], Component component) {
  26. try {
  27. this.image = Toolkit.getDefaultToolkit().createImage(data);
  28. MediaTracker mediatracker = new MediaTracker(component);
  29. mediatracker.addImage(image, 0);
  30. mediatracker.waitForAll();
  31. myWidth = image.getWidth(component);
  32. myHeight = image.getHeight(component);
  33. maxWidth = myWidth;
  34. maxHeight = myHeight;
  35. drawOffsetX = 0;
  36. drawOffsetY = 0;
  37. myPixels = new int[myWidth * myHeight];
  38. PixelGrabber pixelgrabber = new PixelGrabber(image, 0, 0, myWidth, myHeight, myPixels, 0, myWidth);
  39. pixelgrabber.grabPixels();
  40. } catch (Exception _ex) {
  41. System.out.println("Error converting jpg");
  42. }
  43. }
  44.  
  45. public Sprite(String img, int width, int height) {
  46. try {
  47. this.image = Toolkit.getDefaultToolkit().createImage(FileUtils.readFile(img));
  48. myWidth = width;
  49. myHeight = height;
  50. maxWidth = myWidth;
  51. maxHeight = myHeight;
  52. drawOffsetX = 0;
  53. drawOffsetY = 0;
  54. myPixels = new int[myWidth * myHeight];
  55. PixelGrabber pixelgrabber = new PixelGrabber(image, 0, 0, myWidth, myHeight, myPixels, 0, myWidth);
  56. pixelgrabber.grabPixels();
  57. image = null;
  58. } catch (Exception _ex) {
  59. System.out.println(_ex);
  60. }
  61. }
  62.  
  63. public Sprite(Sprite img, int width, int height) {
  64. try {
  65. Image image = img.image;
  66. myWidth = width;
  67. myHeight = height;
  68. maxWidth = myWidth;
  69. maxHeight = myHeight;
  70. drawOffsetX = 0;
  71. drawOffsetY = 0;
  72. myPixels = new int[myWidth * myHeight];
  73. PixelGrabber pixelgrabber = new PixelGrabber(image, 0, 0, myWidth, myHeight, myPixels, 0, myWidth);
  74. pixelgrabber.grabPixels();
  75. image = null;
  76. } catch (Exception _ex) {
  77. System.out.println(_ex);
  78. }
  79. }
  80.  
  81. public Sprite(String img) {
  82. try {
  83. this.image = Toolkit.getDefaultToolkit().getImage(SignLink.findcachedir() + "Sprites/" + img + ".png");
  84. ImageIcon sprite = new ImageIcon(image);
  85. myWidth = sprite.getIconWidth();
  86. myHeight = sprite.getIconHeight();
  87. maxWidth = myWidth;
  88. maxHeight = myHeight;
  89. drawOffsetX = 0;
  90. drawOffsetY = 0;
  91. myPixels = new int[myWidth * myHeight];
  92. PixelGrabber pixelgrabber = new PixelGrabber(image, 0, 0, myWidth, myHeight, myPixels, 0, myWidth);
  93. pixelgrabber.grabPixels();
  94. image = null;
  95. setTransparency(255, 0, 255);
  96. } catch (Exception _ex) {
  97. System.out.println(_ex);
  98. }
  99. }
  100.  
  101. public void drawHoverSprite(int x, int y, int offsetX, int offsetY, Sprite hover) {
  102. this.drawSprite(x, y);
  103. if (Client.instance.mouseX >= offsetX + x && Client.instance.mouseX <= offsetX + x + this.myWidth
  104. && Client.instance.mouseY >= offsetY + y && Client.instance.mouseY <= offsetY + y + this.myHeight) {
  105. hover.drawSprite(x, y);
  106. }
  107. }
  108.  
  109. public void draw24BitSprite(int x, int y) {
  110. int alpha = 256;
  111. x += this.drawOffsetX;// offsetX
  112. y += this.drawOffsetY;// offsetY
  113. int destOffset = x + y * Rasterizer2D.width;
  114. int srcOffset = 0;
  115. int height = this.myHeight;
  116. int width = this.myWidth;
  117. int destStep = Rasterizer2D.width - width;
  118. int srcStep = 0;
  119. if (y < Rasterizer2D.topY) {
  120. int trimHeight = Rasterizer2D.topY - y;
  121. height -= trimHeight;
  122. y = Rasterizer2D.topY;
  123. srcOffset += trimHeight * width;
  124. destOffset += trimHeight * Rasterizer2D.width;
  125. }
  126. if (y + height > Rasterizer2D.bottomY) {
  127. height -= (y + height) - Rasterizer2D.bottomY;
  128. }
  129. if (x < Rasterizer2D.leftX) {
  130. int trimLeft = Rasterizer2D.leftX - x;
  131. width -= trimLeft;
  132. x = Rasterizer2D.leftX;
  133. srcOffset += trimLeft;
  134. destOffset += trimLeft;
  135. srcStep += trimLeft;
  136. destStep += trimLeft;
  137. }
  138. if (x + width > Rasterizer2D.bottomX) {
  139. int trimRight = (x + width) - Rasterizer2D.bottomX;
  140. width -= trimRight;
  141. srcStep += trimRight;
  142. destStep += trimRight;
  143. }
  144. if (!((width <= 0) || (height <= 0))) {
  145. set24BitPixels(width, height, Rasterizer2D.pixels, myPixels, alpha, destOffset, srcOffset, destStep, srcStep);
  146. }
  147. }
  148.  
  149. public void drawTransparentSprite(int x, int y, int opacity) {
  150. int k = opacity;// was parameter
  151. x += drawOffsetX;
  152. y += drawOffsetY;
  153. int i1 = x + y * Rasterizer2D.width;
  154. int j1 = 0;
  155. int k1 = myHeight;
  156. int l1 = myWidth;
  157. int i2 = Rasterizer2D.width - l1;
  158. int j2 = 0;
  159. if (y < Rasterizer2D.topY) {
  160. int k2 = Rasterizer2D.topY - y;
  161. k1 -= k2;
  162. y = Rasterizer2D.topY;
  163. j1 += k2 * l1;
  164. i1 += k2 * Rasterizer2D.width;
  165. }
  166. if (y + k1 > Rasterizer2D.bottomY)
  167. k1 -= (y + k1) - Rasterizer2D.bottomY;
  168. if (x < Rasterizer2D.leftX) {
  169. int l2 = Rasterizer2D.leftX - x;
  170. l1 -= l2;
  171. x = Rasterizer2D.leftX;
  172. j1 += l2;
  173. i1 += l2;
  174. j2 += l2;
  175. i2 += l2;
  176. }
  177. if (x + l1 > Rasterizer2D.bottomX) {
  178. int i3 = (x + l1) - Rasterizer2D.bottomX;
  179. l1 -= i3;
  180. j2 += i3;
  181. i2 += i3;
  182. }
  183. if (!(l1 <= 0 || k1 <= 0)) {
  184. method351(j1, l1, Rasterizer2D.pixels, myPixels, j2, k1, i2, k, i1);
  185. }
  186. }
  187.  
  188. private void set24BitPixels(int width, int height, int destPixels[], int srcPixels[], int srcAlpha, int destOffset, int srcOffset, int destStep, int srcStep) {
  189. int srcColor;
  190. int destAlpha;
  191. for (int loop = -height; loop < 0; loop++) {
  192. for (int loop2 = -width; loop2 < 0; loop2++) {
  193. srcAlpha = ((this.myPixels[srcOffset] >> 24) & 255);
  194. destAlpha = 256 - srcAlpha;
  195. srcColor = srcPixels[srcOffset++];
  196. if (srcColor != 0 && srcColor != 0xffffff) {
  197. int destColor = destPixels[destOffset];
  198. destPixels[destOffset++] = ((srcColor & 0xff00ff) * srcAlpha + (destColor & 0xff00ff) * destAlpha & 0xff00ff00) + ((srcColor & 0xff00) * srcAlpha + (destColor & 0xff00) * destAlpha & 0xff0000) >> 8;
  199. } else {
  200. destOffset++;
  201. }
  202. }
  203. destOffset += destStep;
  204. srcOffset += srcStep;
  205. }
  206. }
  207.  
  208. public void setTransparency(int transRed, int transGreen, int transBlue) {
  209. for (int index = 0; index < myPixels.length; index++)
  210. if (((myPixels[index] >> 16) & 255) == transRed && ((myPixels[index] >> 8) & 255) == transGreen && (myPixels[index] & 255) == transBlue)
  211. myPixels[index] = 0;
  212. }
  213.  
  214. public Sprite(FileArchive archive, String name, int i) {
  215. Buffer dataBuffer = new Buffer(archive.readFile(name + ".dat"));
  216. Buffer indexBuffer = new Buffer(archive.readFile("index.dat"));
  217.  
  218. indexBuffer.currentPosition = dataBuffer.readUShort();
  219.  
  220. maxWidth = indexBuffer.readUShort();
  221. maxHeight = indexBuffer.readUShort();
  222. int pixelCount = indexBuffer.readUnsignedByte();
  223. int raster[] = new int[pixelCount];
  224.  
  225. for (int pixel = 0; pixel < pixelCount - 1; pixel++) {
  226. raster[pixel + 1] = indexBuffer.readTriByte();
  227. if (raster[pixel + 1] == 0)
  228. raster[pixel + 1] = 1;
  229. }
  230.  
  231. for (int index = 0; index < i; index++) {
  232. indexBuffer.currentPosition += 2;
  233. dataBuffer.currentPosition += indexBuffer.readUShort() * indexBuffer.readUShort();
  234. indexBuffer.currentPosition++;
  235. }
  236.  
  237. drawOffsetX = indexBuffer.readUnsignedByte();
  238. drawOffsetY = indexBuffer.readUnsignedByte();
  239. myWidth = indexBuffer.readUShort();
  240. myHeight = indexBuffer.readUShort();
  241.  
  242. int type = indexBuffer.readUnsignedByte();
  243.  
  244. int spriteSize = myWidth * myHeight;
  245.  
  246. myPixels = new int[spriteSize];
  247. if (type == 0) {
  248. for (int pixel = 0; pixel < spriteSize; pixel++) {
  249. myPixels[pixel] = raster[dataBuffer.readUnsignedByte()];
  250. }
  251. setTransparency(255, 0, 255);
  252. return;
  253. }
  254. if (type == 1) {
  255. for (int x = 0; x < myWidth; x++) {
  256. for (int y = 0; y < myHeight; y++) {
  257. myPixels[x + y * myWidth] = raster[dataBuffer.readUnsignedByte()];
  258. }
  259. }
  260.  
  261. }
  262. setTransparency(255, 0, 255);
  263. }
  264.  
  265. public void init() {
  266. Rasterizer2D.initDrawingArea(myHeight, myWidth, myPixels, null);
  267. }
  268.  
  269. public void method344(int i, int j, int k) {
  270. for (int i1 = 0; i1 < myPixels.length; i1++) {
  271. int j1 = myPixels[i1];
  272. if (j1 != 0) {
  273. int k1 = j1 >> 16 & 0xff;
  274. k1 += i;
  275. if (k1 < 1)
  276. k1 = 1;
  277. else if (k1 > 255)
  278. k1 = 255;
  279. int l1 = j1 >> 8 & 0xff;
  280. l1 += j;
  281. if (l1 < 1)
  282. l1 = 1;
  283. else if (l1 > 255)
  284. l1 = 255;
  285. int i2 = j1 & 0xff;
  286. i2 += k;
  287. if (i2 < 1)
  288. i2 = 1;
  289. else if (i2 > 255)
  290. i2 = 255;
  291. myPixels[i1] = (k1 << 16) + (l1 << 8) + i2;
  292. }
  293. }
  294.  
  295. }
  296.  
  297. public void method345() {
  298. int ai[] = new int[maxWidth * maxHeight];
  299. for (int j = 0; j < myHeight; j++) {
  300. System.arraycopy(myPixels, j * myWidth, ai, j + drawOffsetY * maxWidth + drawOffsetX, myWidth);
  301. }
  302.  
  303. myPixels = ai;
  304. myWidth = maxWidth;
  305. myHeight = maxHeight;
  306. drawOffsetX = 0;
  307. drawOffsetY = 0;
  308. }
  309.  
  310. public void method346(int x, int y) {
  311. x += drawOffsetX;
  312. y += drawOffsetY;
  313. int l = x + y * Rasterizer2D.width;
  314. int i1 = 0;
  315. int height = myHeight;
  316. int width = myWidth;
  317. int l1 = Rasterizer2D.width - width;
  318. int i2 = 0;
  319. if (y < Rasterizer2D.topY) {
  320. int j2 = Rasterizer2D.topY - y;
  321. height -= j2;
  322. y = Rasterizer2D.topY;
  323. i1 += j2 * width;
  324. l += j2 * Rasterizer2D.width;
  325. }
  326. if (y + height > Rasterizer2D.bottomY)
  327. height -= (y + height) - Rasterizer2D.bottomY;
  328. if (x < Rasterizer2D.leftX) {
  329. int k2 = Rasterizer2D.leftX - x;
  330. width -= k2;
  331. x = Rasterizer2D.leftX;
  332. i1 += k2;
  333. l += k2;
  334. i2 += k2;
  335. l1 += k2;
  336. }
  337. if (x + width > Rasterizer2D.bottomX) {
  338. int l2 = (x + width) - Rasterizer2D.bottomX;
  339. width -= l2;
  340. i2 += l2;
  341. l1 += l2;
  342. }
  343. if (width <= 0 || height <= 0) {
  344. } else {
  345. method347(l, width, height, i2, i1, l1, myPixels, Rasterizer2D.pixels);
  346. }
  347. }
  348.  
  349. private void method347(int i, int j, int k, int l, int i1, int k1, int ai[], int ai1[]) {
  350. int l1 = -(j >> 2);
  351. j = -(j & 3);
  352. for (int i2 = -k; i2 < 0; i2++) {
  353. for (int j2 = l1; j2 < 0; j2++) {
  354. ai1[i++] = ai[i1++];
  355. ai1[i++] = ai[i1++];
  356. ai1[i++] = ai[i1++];
  357. ai1[i++] = ai[i1++];
  358. }
  359.  
  360. for (int k2 = j; k2 < 0; k2++)
  361. ai1[i++] = ai[i1++];
  362.  
  363. i += k1;
  364. i1 += l;
  365. }
  366. }
  367.  
  368. public void drawSprite1(int i, int j) {
  369. drawSprite1(i, j, 128);
  370. }
  371.  
  372. public void drawSprite1(int i, int j, int k, boolean overrideCanvas) {
  373. i += drawOffsetX;
  374. j += drawOffsetY;
  375. int i1 = i + j * Rasterizer2D.width;
  376. int j1 = 0;
  377. int k1 = myHeight;
  378. int l1 = myWidth;
  379. int i2 = Rasterizer2D.width - l1;
  380. int j2 = 0;
  381. if (!(overrideCanvas && j > 0) && j < Rasterizer2D.topY) {
  382. int k2 = Rasterizer2D.topY - j;
  383. k1 -= k2;
  384. j = Rasterizer2D.topY;
  385. j1 += k2 * l1;
  386. i1 += k2 * Rasterizer2D.width;
  387. }
  388. if (j + k1 > Rasterizer2D.bottomY)
  389. k1 -= (j + k1) - Rasterizer2D.bottomY;
  390. if (!overrideCanvas && i < Rasterizer2D.leftX) {
  391. int l2 = Rasterizer2D.leftX - i;
  392. l1 -= l2;
  393. i = Rasterizer2D.leftX;
  394. j1 += l2;
  395. i1 += l2;
  396. j2 += l2;
  397. i2 += l2;
  398. }
  399. if (i + l1 > Rasterizer2D.bottomX) {
  400. int i3 = (i + l1) - Rasterizer2D.bottomX;
  401. l1 -= i3;
  402. j2 += i3;
  403. i2 += i3;
  404. }
  405. if (!(l1 <= 0 || k1 <= 0)) {
  406. method351(j1, l1, Rasterizer2D.pixels, myPixels, j2, k1, i2, k, i1);
  407. }
  408. }
  409.  
  410. public void drawSprite1(int i, int j, int k) {
  411. i += drawOffsetX;
  412. j += drawOffsetY;
  413. int i1 = i + j * Rasterizer2D.width;
  414. int j1 = 0;
  415. int k1 = myHeight;
  416. int l1 = myWidth;
  417. int i2 = Rasterizer2D.width - l1;
  418. int j2 = 0;
  419. if (j < Rasterizer2D.topY) {
  420. int k2 = Rasterizer2D.topY - j;
  421. k1 -= k2;
  422. j = Rasterizer2D.topY;
  423. j1 += k2 * l1;
  424. i1 += k2 * Rasterizer2D.width;
  425. }
  426. if (j + k1 > Rasterizer2D.bottomY)
  427. k1 -= (j + k1) - Rasterizer2D.bottomY;
  428. if (i < Rasterizer2D.leftX) {
  429. int l2 = Rasterizer2D.leftX - i;
  430. l1 -= l2;
  431. i = Rasterizer2D.leftX;
  432. j1 += l2;
  433. i1 += l2;
  434. j2 += l2;
  435. i2 += l2;
  436. }
  437. if (i + l1 > Rasterizer2D.bottomX) {
  438. int i3 = (i + l1) - Rasterizer2D.bottomX;
  439. l1 -= i3;
  440. j2 += i3;
  441. i2 += i3;
  442. }
  443. if (!(l1 <= 0 || k1 <= 0)) {
  444. method351(j1, l1, Rasterizer2D.pixels, myPixels, j2, k1, i2, k, i1);
  445. }
  446. }
  447.  
  448. public void drawSprite(int x, int y)
  449. {
  450. x += drawOffsetX;
  451. y += drawOffsetY;
  452. int rasterClip = x + y * Rasterizer2D.width;
  453. int imageClip = 0;
  454. int height = myHeight;
  455. int width = myWidth;
  456. int rasterOffset = Rasterizer2D.width - width;
  457. int imageOffset = 0;
  458. if(y < Rasterizer2D.topY)
  459. {
  460. int dy = Rasterizer2D.topY - y;
  461. height -= dy;
  462. y = Rasterizer2D.topY;
  463. imageClip += dy * width;
  464. rasterClip += dy * Rasterizer2D.width;
  465. }
  466. if(y + height > Rasterizer2D.bottomY)
  467. height -= (y + height) - Rasterizer2D.bottomY;
  468. if(x < Rasterizer2D.leftX)
  469. {
  470. int dx = Rasterizer2D.leftX - x;
  471. width -= dx;
  472. x = Rasterizer2D.leftX;
  473. imageClip += dx;
  474. rasterClip += dx;
  475. imageOffset += dx;
  476. rasterOffset += dx;
  477. }
  478. if(x + width > Rasterizer2D.bottomX)
  479. {
  480. int dx = (x + width) - Rasterizer2D.bottomX;
  481. width -= dx;
  482. imageOffset += dx;
  483. rasterOffset += dx;
  484. }
  485. if(!(width <= 0 || height <= 0))
  486. {
  487. method349(Rasterizer2D.pixels, myPixels, imageClip, rasterClip, width, height, rasterOffset, imageOffset);
  488. }
  489. }
  490.  
  491. public void drawSprite(int i, int k, int color) {
  492. int tempWidth = myWidth + 2;
  493. int tempHeight = myHeight + 2;
  494. int[] tempArray = new int[tempWidth * tempHeight];
  495. for (int x = 0; x < myWidth; x++) {
  496. for (int y = 0; y < myHeight; y++) {
  497. if (myPixels[x + y * myWidth] != 0)
  498. tempArray[(x + 1) + (y + 1) * tempWidth] = myPixels[x + y * myWidth];
  499. }
  500. }
  501. for (int x = 0; x < tempWidth; x++) {
  502. for (int y = 0; y < tempHeight; y++) {
  503. if (tempArray[(x) + (y) * tempWidth] == 0) {
  504. if (x < tempWidth - 1 && tempArray[(x + 1) + ((y) * tempWidth)] > 0 && tempArray[(x + 1) + ((y) * tempWidth)] != 0xffffff) {
  505. tempArray[(x) + (y) * tempWidth] = color;
  506. }
  507. if (x > 0 && tempArray[(x - 1) + ((y) * tempWidth)] > 0 && tempArray[(x - 1) + ((y) * tempWidth)] != 0xffffff) {
  508. tempArray[(x) + (y) * tempWidth] = color;
  509. }
  510. if (y < tempHeight - 1 && tempArray[(x) + ((y + 1) * tempWidth)] > 0 && tempArray[(x) + ((y + 1) * tempWidth)] != 0xffffff) {
  511. tempArray[(x) + (y) * tempWidth] = color;
  512. }
  513. if (y > 0 && tempArray[(x) + ((y - 1) * tempWidth)] > 0 && tempArray[(x) + ((y - 1) * tempWidth)] != 0xffffff) {
  514. tempArray[(x) + (y) * tempWidth] = color;
  515. }
  516. }
  517. }
  518. }
  519. i--;
  520. k--;
  521. i += drawOffsetX;
  522. k += drawOffsetY;
  523. int l = i + k * Rasterizer2D.width;
  524. int i1 = 0;
  525. int j1 = tempHeight;
  526. int k1 = tempWidth;
  527. int l1 = Rasterizer2D.width - k1;
  528. int i2 = 0;
  529. if (k < Rasterizer2D.topY) {
  530. int j2 = Rasterizer2D.topY - k;
  531. j1 -= j2;
  532. k = Rasterizer2D.topY;
  533. i1 += j2 * k1;
  534. l += j2 * Rasterizer2D.width;
  535. }
  536. if (k + j1 > Rasterizer2D.bottomY) {
  537. j1 -= (k + j1) - Rasterizer2D.bottomY;
  538. }
  539. if (i < Rasterizer2D.leftX) {
  540. int k2 = Rasterizer2D.leftX - i;
  541. k1 -= k2;
  542. i = Rasterizer2D.leftX;
  543. i1 += k2;
  544. l += k2;
  545. i2 += k2;
  546. l1 += k2;
  547. }
  548. if (i + k1 > Rasterizer2D.bottomX) {
  549. int l2 = (i + k1) - Rasterizer2D.bottomX;
  550. k1 -= l2;
  551. i2 += l2;
  552. l1 += l2;
  553. }
  554. if (!(k1 <= 0 || j1 <= 0)) {
  555. method349(Rasterizer2D.pixels, tempArray, i1, l, k1, j1, l1, i2);
  556. }
  557. }
  558.  
  559. public void drawSprite2(int i, int j) {
  560. int k = 225;// was parameter
  561. i += drawOffsetX;
  562. j += drawOffsetY;
  563. int i1 = i + j * Rasterizer2D.width;
  564. int j1 = 0;
  565. int k1 = myHeight;
  566. int l1 = myWidth;
  567. int i2 = Rasterizer2D.width - l1;
  568. int j2 = 0;
  569. if (j < Rasterizer2D.topY) {
  570. int k2 = Rasterizer2D.topY - j;
  571. k1 -= k2;
  572. j = Rasterizer2D.topY;
  573. j1 += k2 * l1;
  574. i1 += k2 * Rasterizer2D.width;
  575. }
  576. if (j + k1 > Rasterizer2D.bottomY)
  577. k1 -= (j + k1) - Rasterizer2D.bottomY;
  578. if (i < Rasterizer2D.leftX) {
  579. int l2 = Rasterizer2D.leftX - i;
  580. l1 -= l2;
  581. i = Rasterizer2D.leftX;
  582. j1 += l2;
  583. i1 += l2;
  584. j2 += l2;
  585. i2 += l2;
  586. }
  587. if (i + l1 > Rasterizer2D.bottomX) {
  588. int i3 = (i + l1) - Rasterizer2D.bottomX;
  589. l1 -= i3;
  590. j2 += i3;
  591. i2 += i3;
  592. }
  593. if (!(l1 <= 0 || k1 <= 0)) {
  594. method351(j1, l1, Rasterizer2D.pixels, myPixels, j2, k1, i2, k, i1);
  595. }
  596. }
  597.  
  598. private void method349(int ai[], int ai1[], int j, int k, int l, int i1, int j1, int k1) {
  599. int i;// was parameter
  600. int l1 = -(l >> 2);
  601. l = -(l & 3);
  602. for (int i2 = -i1; i2 < 0; i2++) {
  603. for (int j2 = l1; j2 < 0; j2++) {
  604. i = ai1[j++];
  605. if (i != 0 && i != -1) {
  606. ai[k++] = i;
  607. } else {
  608. k++;
  609. }
  610. i = ai1[j++];
  611. if (i != 0 && i != -1) {
  612. ai[k++] = i;
  613. } else {
  614. k++;
  615. }
  616. i = ai1[j++];
  617. if (i != 0 && i != -1) {
  618. ai[k++] = i;
  619. } else {
  620. k++;
  621. }
  622. i = ai1[j++];
  623. if (i != 0 && i != -1) {
  624. ai[k++] = i;
  625. } else {
  626. k++;
  627. }
  628. }
  629.  
  630. for (int k2 = l; k2 < 0; k2++) {
  631. i = ai1[j++];
  632. if (i != 0 && i != -1) {
  633. ai[k++] = i;
  634. } else {
  635. k++;
  636. }
  637. }
  638. k += j1;
  639. j += k1;
  640. }
  641. }
  642.  
  643. private void method351(int i, int j, int ai[], int ai1[], int l, int i1, int j1, int k1, int l1) {
  644. int k;// was parameter
  645. int j2 = 256 - k1;
  646. for (int k2 = -i1; k2 < 0; k2++) {
  647. for (int l2 = -j; l2 < 0; l2++) {
  648. k = ai1[i++];
  649. if (k != 0) {
  650. int i3 = ai[l1];
  651. ai[l1++] = ((k & 0xff00ff) * k1 + (i3 & 0xff00ff) * j2 & 0xff00ff00) + ((k & 0xff00) * k1 + (i3 & 0xff00) * j2 & 0xff0000) >> 8;
  652. } else {
  653. l1++;
  654. }
  655. }
  656.  
  657. l1 += j1;
  658. i += l;
  659. }
  660. }
  661.  
  662. public void rotate(int i, int j, int ai[], int k, int ai1[], int i1, int j1, int k1, int l1, int i2) {
  663. try {
  664. int j2 = -l1 / 2;
  665. int k2 = -i / 2;
  666. int l2 = (int) (Math.sin((double) j / 326.11000000000001D) * 65536D);
  667. int i3 = (int) (Math.cos((double) j / 326.11000000000001D) * 65536D);
  668. l2 = l2 * k >> 8;
  669. i3 = i3 * k >> 8;
  670. int j3 = (i2 << 16) + (k2 * l2 + j2 * i3);
  671. int k3 = (i1 << 16) + (k2 * i3 - j2 * l2);
  672. int l3 = k1 + j1 * Rasterizer2D.width;
  673. for (j1 = 0; j1 < i; j1++) {
  674. int i4 = ai1[j1];
  675. int j4 = l3 + i4;
  676. int k4 = j3 + i3 * i4;
  677. int l4 = k3 - l2 * i4;
  678. for (k1 = -ai[j1]; k1 < 0; k1++) {
  679. int x1 = k4 >> 16;
  680. int y1 = l4 >> 16;
  681. int x2 = x1 + 1;
  682. int y2 = y1 + 1;
  683. int c1 = myPixels[x1 + y1 * myWidth];
  684. int c2 = myPixels[x2 + y1 * myWidth];
  685. int c3 = myPixels[x1 + y2 * myWidth];
  686. int c4 = myPixels[x2 + y2 * myWidth];
  687. int u1 = (k4 >> 8) - (x1 << 8);
  688. int v1 = (l4 >> 8) - (y1 << 8);
  689. int u2 = (x2 << 8) - (k4 >> 8);
  690. int v2 = (y2 << 8) - (l4 >> 8);
  691. int a1 = u2 * v2;
  692. int a2 = u1 * v2;
  693. int a3 = u2 * v1;
  694. int a4 = u1 * v1;
  695. int r = (c1 >> 16 & 0xff) * a1 + (c2 >> 16 & 0xff) * a2 + (c3 >> 16 & 0xff) * a3 + (c4 >> 16 & 0xff) * a4 & 0xff0000;
  696. int g = (c1 >> 8 & 0xff) * a1 + (c2 >> 8 & 0xff) * a2 + (c3 >> 8 & 0xff) * a3 + (c4 >> 8 & 0xff) * a4 >> 8 & 0xff00;
  697. int b = (c1 & 0xff) * a1 + (c2 & 0xff) * a2 + (c3 & 0xff) * a3 + (c4 & 0xff) * a4 >> 16;
  698. Rasterizer2D.pixels[j4++] = r | g | b;
  699. k4 += i3;
  700. l4 -= l2;
  701. }
  702.  
  703. j3 += l2;
  704. k3 += i3;
  705. l3 += Rasterizer2D.width;
  706. }
  707.  
  708. } catch (Exception _ex) {
  709. }
  710. }
  711.  
  712. public void method353(int i, double d, int l1) {
  713. // all of the following were parameters
  714. int j = 15;
  715. int k = 20;
  716. int l = 15;
  717. int j1 = 256;
  718. int k1 = 20;
  719. // all of the previous were parameters
  720. try {
  721. int i2 = -k / 2;
  722. int j2 = -k1 / 2;
  723. int k2 = (int) (Math.sin(d) * 65536D);
  724. int l2 = (int) (Math.cos(d) * 65536D);
  725. k2 = k2 * j1 >> 8;
  726. l2 = l2 * j1 >> 8;
  727. int i3 = (l << 16) + (j2 * k2 + i2 * l2);
  728. int j3 = (j << 16) + (j2 * l2 - i2 * k2);
  729. int k3 = l1 + i * Rasterizer2D.width;
  730. for (i = 0; i < k1; i++) {
  731. int l3 = k3;
  732. int i4 = i3;
  733. int j4 = j3;
  734. for (l1 = -k; l1 < 0; l1++) {
  735. int k4 = myPixels[(i4 >> 16) + (j4 >> 16) * myWidth];
  736. if (k4 != 0)
  737. Rasterizer2D.pixels[l3++] = k4;
  738. else
  739. l3++;
  740. i4 += l2;
  741. j4 -= k2;
  742. }
  743.  
  744. i3 += k2;
  745. j3 += l2;
  746. k3 += Rasterizer2D.width;
  747. }
  748.  
  749. } catch (Exception _ex) {
  750. }
  751. }
  752.  
  753. public Sprite(byte spriteData[]) {
  754. try {
  755. this.image = Toolkit.getDefaultToolkit().createImage(spriteData);
  756. ImageIcon sprite = new ImageIcon(image);
  757. myWidth = sprite.getIconWidth();
  758. myHeight = sprite.getIconHeight();
  759. maxWidth = myWidth;
  760. maxHeight = myHeight;
  761. drawOffsetX = 0;
  762. drawOffsetY = 0;
  763. myPixels = new int[myWidth * myHeight];
  764. PixelGrabber pixelgrabber = new PixelGrabber(image, 0, 0, myWidth, myHeight, myPixels, 0, myWidth);
  765. pixelgrabber.grabPixels();
  766. image = null;
  767. setTransparency(255, 0, 255);
  768. } catch (Exception _ex) {
  769. System.out.println(_ex);
  770. }
  771. }
  772.  
  773. public void method354(IndexedImage background, int i, int j) {
  774. j += drawOffsetX;
  775. i += drawOffsetY;
  776. int k = j + i * Rasterizer2D.width;
  777. int l = 0;
  778. int i1 = myHeight;
  779. int j1 = myWidth;
  780. int k1 = Rasterizer2D.width - j1;
  781. int l1 = 0;
  782. if (i < Rasterizer2D.topY) {
  783. int i2 = Rasterizer2D.topY - i;
  784. i1 -= i2;
  785. i = Rasterizer2D.topY;
  786. l += i2 * j1;
  787. k += i2 * Rasterizer2D.width;
  788. }
  789. if (i + i1 > Rasterizer2D.bottomY)
  790. i1 -= (i + i1) - Rasterizer2D.bottomY;
  791. if (j < Rasterizer2D.leftX) {
  792. int j2 = Rasterizer2D.leftX - j;
  793. j1 -= j2;
  794. j = Rasterizer2D.leftX;
  795. l += j2;
  796. k += j2;
  797. l1 += j2;
  798. k1 += j2;
  799. }
  800. if (j + j1 > Rasterizer2D.bottomX) {
  801. int k2 = (j + j1) - Rasterizer2D.bottomX;
  802. j1 -= k2;
  803. l1 += k2;
  804. k1 += k2;
  805. }
  806. if (!(j1 <= 0 || i1 <= 0)) {
  807. method355(myPixels, j1, background.palettePixels, i1, Rasterizer2D.pixels, 0, k1, k, l1, l);
  808. }
  809. }
  810.  
  811. public void drawAdvancedSprite(int xPos, int yPos) {
  812. drawAdvancedSprite(xPos, yPos, 256);
  813. }
  814.  
  815. public void drawAdvancedSprite(int xPos, int yPos, int alpha) {
  816. int alphaValue = alpha;
  817. xPos += drawOffsetX;
  818. yPos += drawOffsetY;
  819. int i1 = xPos + yPos * Rasterizer2D.width;
  820. int j1 = 0;
  821. int spriteHeight = myHeight;
  822. int spriteWidth = myWidth;
  823. int i2 = Rasterizer2D.width - spriteWidth;
  824. int j2 = 0;
  825. if (yPos < Rasterizer2D.topY) {
  826. int k2 = Rasterizer2D.topY - yPos;
  827. spriteHeight -= k2;
  828. yPos = Rasterizer2D.topY;
  829. j1 += k2 * spriteWidth;
  830. i1 += k2 * Rasterizer2D.width;
  831. }
  832. if (yPos + spriteHeight > Rasterizer2D.bottomY)
  833. spriteHeight -= (yPos + spriteHeight) - Rasterizer2D.bottomY;
  834. if (xPos < Rasterizer2D.leftX) {
  835. int l2 = Rasterizer2D.leftX - xPos;
  836. spriteWidth -= l2;
  837. xPos = Rasterizer2D.leftX;
  838. j1 += l2;
  839. i1 += l2;
  840. j2 += l2;
  841. i2 += l2;
  842. }
  843. if (xPos + spriteWidth > Rasterizer2D.bottomX) {
  844. int i3 = (xPos + spriteWidth) - Rasterizer2D.bottomX;
  845. spriteWidth -= i3;
  846. j2 += i3;
  847. i2 += i3;
  848. }
  849. if (!(spriteWidth <= 0 || spriteHeight <= 0)) {
  850. renderARGBPixels(spriteWidth, spriteHeight, myPixels, Rasterizer2D.pixels, i1, alphaValue, j1, j2, i2);
  851. }
  852. }
  853.  
  854. private void renderARGBPixels(int spriteWidth, int spriteHeight, int spritePixels[], int renderAreaPixels[], int pixel, int alphaValue, int i, int l, int j1) {
  855. int pixelColor;
  856. int alphaLevel;
  857. int alpha = alphaValue;
  858. for (int height = -spriteHeight; height < 0; height++) {
  859. for (int width = -spriteWidth; width < 0; width++) {
  860. alphaValue = ((myPixels[i] >> 24) & (alpha - 1));
  861. alphaLevel = 256 - alphaValue;
  862. if (alphaLevel > 256) {
  863. alphaValue = 0;
  864. }
  865. if (alpha == 0) {
  866. alphaLevel = 256;
  867. alphaValue = 0;
  868. }
  869. pixelColor = spritePixels[i++];
  870. if (pixelColor != 0) {
  871. int pixelValue = renderAreaPixels[pixel];
  872. renderAreaPixels[pixel++] = ((pixelColor & 0xff00ff) * alphaValue + (pixelValue & 0xff00ff) * alphaLevel & 0xff00ff00) + ((pixelColor & 0xff00) * alphaValue + (pixelValue & 0xff00) * alphaLevel & 0xff0000) >> 8;
  873. } else {
  874. pixel++;
  875. }
  876. }
  877. pixel += j1;
  878. i += l;
  879. }
  880. }
  881.  
  882. private void method355(int ai[], int i, byte abyte0[], int j, int ai1[], int k, int l, int i1, int j1, int k1) {
  883. int l1 = -(i >> 2);
  884. i = -(i & 3);
  885. for (int j2 = -j; j2 < 0; j2++) {
  886. for (int k2 = l1; k2 < 0; k2++) {
  887. k = ai[k1++];
  888. if (k != 0 && abyte0[i1] == 0)
  889. ai1[i1++] = k;
  890. else
  891. i1++;
  892. k = ai[k1++];
  893. if (k != 0 && abyte0[i1] == 0)
  894. ai1[i1++] = k;
  895. else
  896. i1++;
  897. k = ai[k1++];
  898. if (k != 0 && abyte0[i1] == 0)
  899. ai1[i1++] = k;
  900. else
  901. i1++;
  902. k = ai[k1++];
  903. if (k != 0 && abyte0[i1] == 0)
  904. ai1[i1++] = k;
  905. else
  906. i1++;
  907. }
  908.  
  909. for (int l2 = i; l2 < 0; l2++) {
  910. k = ai[k1++];
  911. if (k != 0 && abyte0[i1] == 0)
  912. ai1[i1++] = k;
  913. else
  914. i1++;
  915. }
  916.  
  917. i1 += l;
  918. k1 += j1;
  919. }
  920.  
  921. }
  922.  
  923. private int idenfier;
  924.  
  925. private String name;
  926.  
  927. public Sprite() {
  928. }
  929.  
  930. public int getId() {
  931. return idenfier;
  932. }
  933.  
  934. public void setId(int id) {
  935. this.idenfier = id;
  936. }
  937.  
  938. public String getName() {
  939. return name;
  940. }
  941.  
  942. public void setName(String name) {
  943. this.name = name;
  944. }
  945.  
  946. public int[] getPixels() {
  947. return pixels;
  948. }
  949.  
  950. public void setPixels(int[] pixels) {
  951. Rasterizer2D.pixels = pixels;
  952. }
  953.  
  954. public int getWidth() {
  955. return width;
  956. }
  957.  
  958. public void setWidth(int width) {
  959. Rasterizer2D.width = width;
  960. }
  961.  
  962. public int getHeight() {
  963. return height;
  964. }
  965.  
  966. public void setHeight(int height) {
  967. Rasterizer2D.height = height;
  968. }
  969.  
  970. public int getOffsetX() {
  971. return drawOffsetX;
  972. }
  973.  
  974. public void setOffsetX(int offsetX) {
  975. this.drawOffsetX = offsetX;
  976. }
  977.  
  978. public int getOffsetY() {
  979. return drawOffsetY;
  980. }
  981.  
  982. public void setOffsetY(int offsetY) {
  983. this.drawOffsetY = offsetY;
  984. }
  985.  
  986. public int myPixels[];
  987. public int myWidth;
  988. public int myHeight;
  989. int drawOffsetX;
  990. public int drawOffsetY;
  991. public int maxWidth;
  992. public int maxHeight;
  993. private Image image;
  994. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!