2016 lines
70 KiB
Java
2016 lines
70 KiB
Java
public class Surface {
|
|
|
|
public static int anInt346;
|
|
public static int anInt347;
|
|
public static int anInt348;
|
|
static byte gameFonts[][] = new byte[50][];
|
|
static int characterWidth[];
|
|
public int width2;
|
|
public int height2;
|
|
public int area;
|
|
public int width1;
|
|
public int height1;
|
|
public int pixels[];
|
|
//private Component unused;
|
|
//public Image image;
|
|
public int surfacePixels[][];
|
|
public byte spriteColoursUsed[][];
|
|
public int spriteColourList[][];
|
|
public int spriteWidth[];
|
|
public int spriteHeight[];
|
|
public int spriteTranslateX[];
|
|
public int spriteTranslateY[];
|
|
public int spriteWidthFull[];
|
|
public int spriteHeightFull[];
|
|
public boolean spriteTranslate[];
|
|
public boolean interlace;
|
|
public boolean loggedIn;
|
|
//ColorModel colorModel;
|
|
//ImageConsumer imageconsumer;
|
|
int landscapeColours[];
|
|
int anIntArray340[];
|
|
int anIntArray341[];
|
|
int anIntArray342[];
|
|
int anIntArray343[];
|
|
int anIntArray344[];
|
|
int anIntArray345[];
|
|
private int boundsTopY;
|
|
private int boundsBottomY;
|
|
private int boundsTopX;
|
|
private int boundsBottomX;
|
|
|
|
static {
|
|
String s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"\243$%^&*()-_=+[{]};:'@#~,<.>/?\\| ";
|
|
characterWidth = new int[256];
|
|
for (int i = 0; i < 256; i++) {
|
|
int j = s.indexOf(i);
|
|
if (j == -1)
|
|
j = 74;
|
|
characterWidth[i] = j * 9;
|
|
}
|
|
|
|
}
|
|
|
|
public Surface(int width, int height, int limit, mudclient component) {
|
|
interlace = false;
|
|
loggedIn = false;
|
|
//unused = component;
|
|
boundsBottomY = height;
|
|
boundsBottomX = width;
|
|
width1 = width2 = width;
|
|
height1 = height2 = height;
|
|
area = width * height;
|
|
pixels = new int[width * height];
|
|
surfacePixels = new int[limit][];
|
|
spriteTranslate = new boolean[limit];
|
|
spriteColoursUsed = new byte[limit][];
|
|
spriteColourList = new int[limit][];
|
|
spriteWidth = new int[limit];
|
|
spriteHeight = new int[limit];
|
|
spriteWidthFull = new int[limit];
|
|
spriteHeightFull = new int[limit];
|
|
spriteTranslateX = new int[limit];
|
|
spriteTranslateY = new int[limit];
|
|
|
|
/*
|
|
if (width > 1 && height > 1 && component != null) {
|
|
colorModel = new DirectColorModel(32, 0xff0000, 65280, 255);
|
|
int l = width2 * height2;
|
|
for (int i1 = 0; i1 < l; i1++)
|
|
pixels[i1] = 0;
|
|
|
|
image = component.createImage(this);
|
|
setcomplete();
|
|
component.prepareImage(image, component);
|
|
setcomplete();
|
|
component.prepareImage(image, component);
|
|
setcomplete();
|
|
component.prepareImage(image, component);
|
|
}*/
|
|
}
|
|
|
|
public static int rgb2long(int red, int green, int blue) {
|
|
return (red << 16) + (green << 8) + blue;
|
|
}
|
|
|
|
public static void createFont(byte bytes[], int id) {
|
|
gameFonts[id] = bytes;
|
|
}
|
|
|
|
/*public synchronized void addConsumer(ImageConsumer imageconsumer) {
|
|
this.imageconsumer = imageconsumer;
|
|
imageconsumer.setDimensions(width2, height2);
|
|
imageconsumer.setProperties(null);
|
|
imageconsumer.setColorModel(colorModel);
|
|
imageconsumer.setHints(14);
|
|
}
|
|
|
|
public synchronized boolean isConsumer(ImageConsumer imageconsumer) {
|
|
return this.imageconsumer == imageconsumer;
|
|
}
|
|
|
|
public synchronized void removeConsumer(ImageConsumer imageconsumer) {
|
|
if (this.imageconsumer == imageconsumer)
|
|
this.imageconsumer = null;
|
|
}
|
|
|
|
public void startProduction(ImageConsumer imageconsumer) {
|
|
addConsumer(imageconsumer);
|
|
}
|
|
|
|
public void requestTopDownLeftRightResend(ImageConsumer imageconsumer) {
|
|
System.out.println("TDLR");
|
|
}*/
|
|
|
|
public synchronized void setcomplete() {
|
|
/*if (imageconsumer == null) {
|
|
return;
|
|
} else {
|
|
imageconsumer.setPixels(0, 0, width2, height2, colorModel, pixels, 0, width2);
|
|
imageconsumer.imageComplete(2);
|
|
return;
|
|
}*/
|
|
}
|
|
|
|
public void setBounds(int x1, int y1, int x2, int y2) {
|
|
if (x1 < 0)
|
|
x1 = 0;
|
|
if (y1 < 0)
|
|
y1 = 0;
|
|
if (x2 > width2)
|
|
x2 = width2;
|
|
if (y2 > height2)
|
|
y2 = height2;
|
|
boundsTopX = x1;
|
|
boundsTopY = y1;
|
|
boundsBottomX = x2;
|
|
boundsBottomY = y2;
|
|
}
|
|
|
|
public void resetBounds() {
|
|
boundsTopX = 0;
|
|
boundsTopY = 0;
|
|
boundsBottomX = width2;
|
|
boundsBottomY = height2;
|
|
}
|
|
|
|
public void draw(/*Graphics g,*/int x, int y) {
|
|
setcomplete();
|
|
//g.drawImage(image, x, y, this);
|
|
}
|
|
|
|
public void blackScreen() {
|
|
int area = width2 * height2;
|
|
if (!interlace) {
|
|
for (int j = 0; j < area; j++)
|
|
pixels[j] = 0;
|
|
|
|
return;
|
|
}
|
|
int k = 0;
|
|
for (int l = -height2; l < 0; l += 2) {
|
|
for (int i1 = -width2; i1 < 0; i1++)
|
|
pixels[k++] = 0;
|
|
|
|
k += width2;
|
|
}
|
|
|
|
}
|
|
|
|
public void drawCircle(int x, int y, int radius, int colour, int alpha) {
|
|
int bgAlpha = 256 - alpha;
|
|
int red = (colour >> 16 & 0xff) * alpha;
|
|
int green = (colour >> 8 & 0xff) * alpha;
|
|
int blue = (colour & 0xff) * alpha;
|
|
int top = y - radius;
|
|
if (top < 0)
|
|
top = 0;
|
|
int bottom = y + radius;
|
|
if (bottom >= height2)
|
|
bottom = height2 - 1;
|
|
byte vertInc = 1;
|
|
if (interlace) {
|
|
vertInc = 2;
|
|
if ((top & 1) != 0)
|
|
top++;
|
|
}
|
|
for (int yy = top; yy <= bottom; yy += vertInc) {
|
|
int l3 = yy - y;
|
|
int i4 = (int) Math.sqrt(radius * radius - l3 * l3);
|
|
int j4 = x - i4;
|
|
if (j4 < 0)
|
|
j4 = 0;
|
|
int k4 = x + i4;
|
|
if (k4 >= width2)
|
|
k4 = width2 - 1;
|
|
int pixelIdx = j4 + yy * width2;
|
|
for (int i5 = j4; i5 <= k4; i5++) {
|
|
int bgRed = (pixels[pixelIdx] >> 16 & 0xff) * bgAlpha;
|
|
int bgGreen = (pixels[pixelIdx] >> 8 & 0xff) * bgAlpha;
|
|
int bgBlue = (pixels[pixelIdx] & 0xff) * bgAlpha;
|
|
int newColour = ((red + bgRed >> 8) << 16) + ((green + bgGreen >> 8) << 8) + (blue + bgBlue >> 8);
|
|
pixels[pixelIdx++] = newColour;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public void drawBoxAlpha(int x, int y, int width, int height, int colour, int alpha) {
|
|
if (x < boundsTopX) {
|
|
width -= boundsTopX - x;
|
|
x = boundsTopX;
|
|
}
|
|
if (y < boundsTopY) {
|
|
height -= boundsTopY - y;
|
|
y = boundsTopY;
|
|
}
|
|
if (x + width > boundsBottomX)
|
|
width = boundsBottomX - x;
|
|
if (y + height > boundsBottomY)
|
|
height = boundsBottomY - y;
|
|
int bgAlpha = 256 - alpha;
|
|
int red = (colour >> 16 & 0xff) * alpha;
|
|
int green = (colour >> 8 & 0xff) * alpha;
|
|
int blue = (colour & 0xff) * alpha;
|
|
int j3 = width2 - width;// wat
|
|
byte vertInc = 1;
|
|
if (interlace) {
|
|
vertInc = 2;
|
|
j3 += width2;
|
|
if ((y & 1) != 0) {
|
|
y++;
|
|
height--;
|
|
}
|
|
}
|
|
int pixelIdx = x + y * width2;
|
|
for (int l3 = 0; l3 < height; l3 += vertInc) {
|
|
for (int i4 = -width; i4 < 0; i4++) {
|
|
int bgRed = (pixels[pixelIdx] >> 16 & 0xff) * bgAlpha;
|
|
int bgGreen = (pixels[pixelIdx] >> 8 & 0xff) * bgAlpha;
|
|
int bgBlue = (pixels[pixelIdx] & 0xff) * bgAlpha;
|
|
int newColour = ((red + bgRed >> 8) << 16) + ((green + bgGreen >> 8) << 8) + (blue + bgBlue >> 8);
|
|
pixels[pixelIdx++] = newColour;
|
|
}
|
|
|
|
pixelIdx += j3;
|
|
}
|
|
|
|
}
|
|
|
|
public void drawGradient(int x, int y, int width, int height, int colourTop, int colourBottom) {
|
|
if (x < boundsTopX) {
|
|
width -= boundsTopX - x;
|
|
x = boundsTopX;
|
|
}
|
|
if (x + width > boundsBottomX)
|
|
width = boundsBottomX - x;
|
|
int btmRed = colourBottom >> 16 & 0xff;
|
|
int btmGreen = colourBottom >> 8 & 0xff;
|
|
int btmBlue = colourBottom & 0xff;
|
|
int topRed = colourTop >> 16 & 0xff;
|
|
int topGreen = colourTop >> 8 & 0xff;
|
|
int topBlue = colourTop & 0xff;
|
|
int i3 = width2 - width;// wat
|
|
byte vertInc = 1;
|
|
if (interlace) {
|
|
vertInc = 2;
|
|
i3 += width2;
|
|
if ((y & 1) != 0) {
|
|
y++;
|
|
height--;
|
|
}
|
|
}
|
|
int pixelIdx = x + y * width2;
|
|
for (int k3 = 0; k3 < height; k3 += vertInc)
|
|
if (k3 + y >= boundsTopY && k3 + y < boundsBottomY) {
|
|
int newColour = ((btmRed * k3 + topRed * (height - k3)) / height << 16) + ((btmGreen * k3 + topGreen * (height - k3)) / height << 8) + (btmBlue * k3 + topBlue * (height - k3)) / height;
|
|
for (int i4 = -width; i4 < 0; i4++)
|
|
pixels[pixelIdx++] = newColour;
|
|
|
|
pixelIdx += i3;
|
|
} else {
|
|
pixelIdx += width2;
|
|
}
|
|
|
|
}
|
|
|
|
public void drawBox(int x, int y, int w, int h, int colour) {
|
|
if (x < boundsTopX) {
|
|
w -= boundsTopX - x;
|
|
x = boundsTopX;
|
|
}
|
|
if (y < boundsTopY) {
|
|
h -= boundsTopY - y;
|
|
y = boundsTopY;
|
|
}
|
|
if (x + w > boundsBottomX)
|
|
w = boundsBottomX - x;
|
|
if (y + h > boundsBottomY)
|
|
h = boundsBottomY - y;
|
|
int j1 = width2 - w;// wat
|
|
byte vertInc = 1;
|
|
if (interlace) {
|
|
vertInc = 2;
|
|
j1 += width2;
|
|
if ((y & 1) != 0) {
|
|
y++;
|
|
h--;
|
|
}
|
|
}
|
|
int pixelIdx = x + y * width2;
|
|
for (int l1 = -h; l1 < 0; l1 += vertInc) {
|
|
for (int i2 = -w; i2 < 0; i2++)
|
|
pixels[pixelIdx++] = colour;
|
|
|
|
pixelIdx += j1;
|
|
}
|
|
|
|
}
|
|
|
|
public void drawBoxEdge(int x, int y, int width, int height, int colour) {
|
|
drawLineHoriz(x, y, width, colour);
|
|
drawLineHoriz(x, (y + height) - 1, width, colour);
|
|
drawLineVert(x, y, height, colour);
|
|
drawLineVert((x + width) - 1, y, height, colour);
|
|
}
|
|
|
|
public void drawLineHoriz(int x, int y, int width, int colour) {
|
|
if (y < boundsTopY || y >= boundsBottomY)
|
|
return;
|
|
if (x < boundsTopX) {
|
|
width -= boundsTopX - x;
|
|
x = boundsTopX;
|
|
}
|
|
if (x + width > boundsBottomX)
|
|
width = boundsBottomX - x;
|
|
int i1 = x + y * width2;
|
|
for (int j1 = 0; j1 < width; j1++)
|
|
pixels[i1 + j1] = colour;
|
|
|
|
}
|
|
|
|
public void drawLineVert(int x, int y, int height, int colour) {
|
|
if (x < boundsTopX || x >= boundsBottomX)
|
|
return;
|
|
if (y < boundsTopY) {
|
|
height -= boundsTopY - y;
|
|
y = boundsTopY;
|
|
}
|
|
if (y + height > boundsBottomX)
|
|
height = boundsBottomY - y;
|
|
int i1 = x + y * width2;
|
|
for (int j1 = 0; j1 < height; j1++)
|
|
pixels[i1 + j1 * width2] = colour;
|
|
|
|
}
|
|
|
|
public void setPixel(int x, int y, int colour) {
|
|
if (x < boundsTopX || y < boundsTopY || x >= boundsBottomX || y >= boundsBottomY) {
|
|
return;
|
|
} else {
|
|
pixels[x + y * width2] = colour;
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void fade2black() {
|
|
int k = width2 * height2;
|
|
for (int j = 0; j < k; j++) {
|
|
int i = pixels[j] & 0xffffff;
|
|
pixels[j] = (i >>> 1 & 0x7f7f7f) + (i >>> 2 & 0x3f3f3f) + (i >>> 3 & 0x1f1f1f) + (i >>> 4 & 0xf0f0f);
|
|
}
|
|
|
|
}
|
|
|
|
public void drawLineAlpha(int i, int j, int x, int y, int width, int height) {
|
|
for (int xx = x; xx < x + width; xx++) {
|
|
for (int yy = y; yy < y + height; yy++) {
|
|
int i2 = 0;
|
|
int j2 = 0;
|
|
int k2 = 0;
|
|
int l2 = 0;
|
|
for (int i3 = xx - i; i3 <= xx + i; i3++)
|
|
if (i3 >= 0 && i3 < width2) {
|
|
for (int j3 = yy - j; j3 <= yy + j; j3++)
|
|
if (j3 >= 0 && j3 < height2) {
|
|
int k3 = pixels[i3 + width2 * j3];
|
|
i2 += k3 >> 16 & 0xff;
|
|
j2 += k3 >> 8 & 0xff;
|
|
k2 += k3 & 0xff;
|
|
l2++;
|
|
}
|
|
|
|
}
|
|
|
|
pixels[xx + width2 * yy] = (i2 / l2 << 16) + (j2 / l2 << 8) + k2 / l2;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public void clear() {
|
|
for (int i = 0; i < surfacePixels.length; i++) {
|
|
surfacePixels[i] = null;
|
|
spriteWidth[i] = 0;
|
|
spriteHeight[i] = 0;
|
|
spriteColoursUsed[i] = null;
|
|
spriteColourList[i] = null;
|
|
}
|
|
|
|
}
|
|
|
|
public void parseSprite(int spriteId, byte spriteData[], byte indexData[], int frameCount) {
|
|
int indexOff = Utility.getUnsignedShort(spriteData, 0);
|
|
int fullWidth = Utility.getUnsignedShort(indexData, indexOff);
|
|
indexOff += 2;
|
|
int fullHeight = Utility.getUnsignedShort(indexData, indexOff);
|
|
indexOff += 2;
|
|
int colourCount = indexData[indexOff++] & 0xff;
|
|
int colours[] = new int[colourCount];
|
|
colours[0] = 0xff00ff;
|
|
for (int i = 0; i < colourCount - 1; i++) {
|
|
colours[i + 1] = ((indexData[indexOff] & 0xff) << 16) + ((indexData[indexOff + 1] & 0xff) << 8) + (indexData[indexOff + 2] & 0xff);
|
|
indexOff += 3;
|
|
}
|
|
|
|
int spriteOff = 2;
|
|
for (int id = spriteId; id < spriteId + frameCount; id++) {
|
|
spriteTranslateX[id] = indexData[indexOff++] & 0xff;
|
|
spriteTranslateY[id] = indexData[indexOff++] & 0xff;
|
|
spriteWidth[id] = Utility.getUnsignedShort(indexData, indexOff);
|
|
indexOff += 2;
|
|
spriteHeight[id] = Utility.getUnsignedShort(indexData, indexOff);
|
|
indexOff += 2;
|
|
int unknown = indexData[indexOff++] & 0xff;
|
|
int size = spriteWidth[id] * spriteHeight[id];
|
|
spriteColoursUsed[id] = new byte[size];
|
|
spriteColourList[id] = colours;
|
|
spriteWidthFull[id] = fullWidth;
|
|
spriteHeightFull[id] = fullHeight;
|
|
surfacePixels[id] = null;
|
|
spriteTranslate[id] = false;
|
|
if (spriteTranslateX[id] != 0 || spriteTranslateY[id] != 0)
|
|
spriteTranslate[id] = true;
|
|
if (unknown == 0) {
|
|
for (int pixel = 0; pixel < size; pixel++) {
|
|
spriteColoursUsed[id][pixel] = spriteData[spriteOff++];
|
|
if (spriteColoursUsed[id][pixel] == 0)
|
|
spriteTranslate[id] = true;
|
|
}
|
|
|
|
} else if (unknown == 1) {
|
|
for (int x = 0; x < spriteWidth[id]; x++) {
|
|
for (int y = 0; y < spriteHeight[id]; y++) {
|
|
spriteColoursUsed[id][x + y * spriteWidth[id]] = spriteData[spriteOff++];
|
|
if (spriteColoursUsed[id][x + y * spriteWidth[id]] == 0)
|
|
spriteTranslate[id] = true;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public void readSleepWord(int spriteId, byte spriteData[]) {
|
|
int pixels[] = surfacePixels[spriteId] = new int[10200];
|
|
spriteWidth[spriteId] = 255;
|
|
spriteHeight[spriteId] = 40;
|
|
spriteTranslateX[spriteId] = 0;
|
|
spriteTranslateY[spriteId] = 0;
|
|
spriteWidthFull[spriteId] = 255;
|
|
spriteHeightFull[spriteId] = 40;
|
|
spriteTranslate[spriteId] = false;
|
|
int j = 0;
|
|
int k = 1;
|
|
int l;
|
|
for (l = 0; l < 255; ) {
|
|
int i1 = spriteData[k++] & 0xff;
|
|
for (int k1 = 0; k1 < i1; k1++)
|
|
pixels[l++] = j;
|
|
|
|
j = 0xffffff - j;
|
|
}
|
|
|
|
for (int y = 1; y < 40; y++) {
|
|
for (int x = 0; x < 255; ) {
|
|
int i2 = spriteData[k++] & 0xff;
|
|
for (int j2 = 0; j2 < i2; j2++) {
|
|
pixels[l] = pixels[l - 255];
|
|
l++;
|
|
x++;
|
|
}
|
|
|
|
if (x < 255) {
|
|
pixels[l] = 0xffffff - pixels[l - 255];
|
|
l++;
|
|
x++;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public void drawWorld(int spriteId) {
|
|
int spriteSize = spriteWidth[spriteId] * spriteHeight[spriteId];
|
|
int spritePixels[] = this.surfacePixels[spriteId];
|
|
int ai1[] = new int[32768];
|
|
for (int k = 0; k < spriteSize; k++) {
|
|
int l = spritePixels[k];
|
|
ai1[((l & 0xf80000) >> 9) + ((l & 0xf800) >> 6) + ((l & 0xf8) >> 3)]++;
|
|
}
|
|
|
|
int ai2[] = new int[256];
|
|
ai2[0] = 0xff00ff;
|
|
int ai3[] = new int[256];
|
|
for (int i1 = 0; i1 < 32768; i1++) {
|
|
int j1 = ai1[i1];
|
|
if (j1 > ai3[255]) {
|
|
for (int k1 = 1; k1 < 256; k1++) {
|
|
if (j1 <= ai3[k1])
|
|
continue;
|
|
for (int i2 = 255; i2 > k1; i2--) {
|
|
ai2[i2] = ai2[i2 - 1];
|
|
ai3[i2] = ai3[i2 - 1];
|
|
}
|
|
|
|
ai2[k1] = ((i1 & 0x7c00) << 9) + ((i1 & 0x3e0) << 6) + ((i1 & 0x1f) << 3) + 0x40404;
|
|
ai3[k1] = j1;
|
|
break;
|
|
}
|
|
|
|
}
|
|
ai1[i1] = -1;
|
|
}
|
|
|
|
byte abyte0[] = new byte[spriteSize];
|
|
for (int l1 = 0; l1 < spriteSize; l1++) {
|
|
int j2 = spritePixels[l1];
|
|
int k2 = ((j2 & 0xf80000) >> 9) + ((j2 & 0xf800) >> 6) + ((j2 & 0xf8) >> 3);
|
|
int l2 = ai1[k2];
|
|
if (l2 == -1) {
|
|
int i3 = 0x3b9ac9ff;
|
|
int j3 = j2 >> 16 & 0xff;
|
|
int k3 = j2 >> 8 & 0xff;
|
|
int l3 = j2 & 0xff;
|
|
for (int i4 = 0; i4 < 256; i4++) {
|
|
int j4 = ai2[i4];
|
|
int k4 = j4 >> 16 & 0xff;
|
|
int l4 = j4 >> 8 & 0xff;
|
|
int i5 = j4 & 0xff;
|
|
int j5 = (j3 - k4) * (j3 - k4) + (k3 - l4) * (k3 - l4) + (l3 - i5) * (l3 - i5);
|
|
if (j5 < i3) {
|
|
i3 = j5;
|
|
l2 = i4;
|
|
}
|
|
}
|
|
|
|
ai1[k2] = l2;
|
|
}
|
|
abyte0[l1] = (byte) l2;
|
|
}
|
|
|
|
spriteColoursUsed[spriteId] = abyte0;
|
|
spriteColourList[spriteId] = ai2;
|
|
this.surfacePixels[spriteId] = null;
|
|
}
|
|
|
|
public void loadSprite(int spriteId) {
|
|
if (spriteColoursUsed[spriteId] == null)
|
|
return;
|
|
int size = spriteWidth[spriteId] * spriteHeight[spriteId];
|
|
byte idx[] = spriteColoursUsed[spriteId];
|
|
int cols[] = spriteColourList[spriteId];
|
|
int pixels[] = new int[size];
|
|
for (int pixel = 0; pixel < size; pixel++) {
|
|
int colour = cols[idx[pixel] & 0xff];
|
|
if (colour == 0)
|
|
colour = 1;
|
|
else if (colour == 0xff00ff)
|
|
colour = 0;
|
|
pixels[pixel] = colour;
|
|
}
|
|
|
|
surfacePixels[spriteId] = pixels;
|
|
spriteColoursUsed[spriteId] = null;
|
|
spriteColourList[spriteId] = null;
|
|
}
|
|
|
|
public void drawSpriteMinimap(int sprite, int x, int y, int width, int height) {// used from World
|
|
spriteWidth[sprite] = width;
|
|
spriteHeight[sprite] = height;
|
|
spriteTranslate[sprite] = false;
|
|
spriteTranslateX[sprite] = 0;
|
|
spriteTranslateY[sprite] = 0;
|
|
spriteWidthFull[sprite] = width;
|
|
spriteHeightFull[sprite] = height;
|
|
int area = width * height;
|
|
int pixel = 0;
|
|
surfacePixels[sprite] = new int[area];
|
|
for (int xx = x; xx < x + width; xx++) {
|
|
for (int yy = y; yy < y + height; yy++) {
|
|
surfacePixels[sprite][pixel++] = pixels[xx + yy * width2];
|
|
}
|
|
}
|
|
}
|
|
|
|
public void drawSprite(int sprite, int x, int y, int width, int height) {// used from mudclient
|
|
spriteWidth[sprite] = width;
|
|
spriteHeight[sprite] = height;
|
|
spriteTranslate[sprite] = false;
|
|
spriteTranslateX[sprite] = 0;
|
|
spriteTranslateY[sprite] = 0;
|
|
spriteWidthFull[sprite] = width;
|
|
spriteHeightFull[sprite] = height;
|
|
int area = width * height;
|
|
int pixel = 0;
|
|
surfacePixels[sprite] = new int[area];
|
|
for (int yy = y; yy < y + height; yy++) {
|
|
for (int xx = x; xx < x + width; xx++)
|
|
surfacePixels[sprite][pixel++] = pixels[xx + yy * width2];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public void drawSprite(int x, int y, int id) {
|
|
if (spriteTranslate[id]) {
|
|
x += spriteTranslateX[id];
|
|
y += spriteTranslateY[id];
|
|
}
|
|
int rY = x + y * width2;
|
|
int rX = 0;
|
|
int height = spriteHeight[id];
|
|
int width = spriteWidth[id];
|
|
int w2 = width2 - width;
|
|
int h2 = 0;
|
|
if (y < boundsTopY) {
|
|
int j2 = boundsTopY - y;
|
|
height -= j2;
|
|
y = boundsTopY;
|
|
rX += j2 * width;
|
|
rY += j2 * width2;
|
|
}
|
|
if (y + height >= boundsBottomY)
|
|
height -= ((y + height) - boundsBottomY) + 1;
|
|
if (x < boundsTopX) {
|
|
int k2 = boundsTopX - x;
|
|
width -= k2;
|
|
x = boundsTopX;
|
|
rX += k2;
|
|
rY += k2;
|
|
h2 += k2;
|
|
w2 += k2;
|
|
}
|
|
if (x + width >= boundsBottomX) {
|
|
int l2 = ((x + width) - boundsBottomX) + 1;
|
|
width -= l2;
|
|
h2 += l2;
|
|
w2 += l2;
|
|
}
|
|
if (width <= 0 || height <= 0)
|
|
return;
|
|
byte inc = 1;
|
|
if (interlace) {
|
|
inc = 2;
|
|
w2 += width2;
|
|
h2 += spriteWidth[id];
|
|
if ((y & 1) != 0) {
|
|
rY += width2;
|
|
height--;
|
|
}
|
|
}
|
|
if (surfacePixels[id] == null) {
|
|
drawSprite(pixels, spriteColoursUsed[id], spriteColourList[id], rX, rY, width, height, w2, h2, inc);
|
|
return;
|
|
} else {
|
|
drawSprite(pixels, surfacePixels[id], 0, rX, rY, width, height, w2, h2, inc);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void spriteClipping(int x, int y, int width, int height, int spriteId) {
|
|
try {
|
|
int spriteWidth = this.spriteWidth[spriteId];
|
|
int spriteHeight = this.spriteHeight[spriteId];
|
|
int l1 = 0;
|
|
int i2 = 0;
|
|
int j2 = (spriteWidth << 16) / width;
|
|
int k2 = (spriteHeight << 16) / height;
|
|
if (spriteTranslate[spriteId]) {
|
|
int l2 = spriteWidthFull[spriteId];
|
|
int j3 = spriteHeightFull[spriteId];
|
|
j2 = (l2 << 16) / width;
|
|
k2 = (j3 << 16) / height;
|
|
x += ((spriteTranslateX[spriteId] * width + l2) - 1) / l2;
|
|
y += ((spriteTranslateY[spriteId] * height + j3) - 1) / j3;
|
|
if ((spriteTranslateX[spriteId] * width) % l2 != 0)
|
|
l1 = (l2 - (spriteTranslateX[spriteId] * width) % l2 << 16) / width;
|
|
if ((spriteTranslateY[spriteId] * height) % j3 != 0)
|
|
i2 = (j3 - (spriteTranslateY[spriteId] * height) % j3 << 16) / height;
|
|
width = (width * (this.spriteWidth[spriteId] - (l1 >> 16))) / l2;
|
|
height = (height * (this.spriteHeight[spriteId] - (i2 >> 16))) / j3;
|
|
}
|
|
int i3 = x + y * width2;
|
|
int k3 = width2 - width;
|
|
if (y < boundsTopY) {
|
|
int l3 = boundsTopY - y;
|
|
height -= l3;
|
|
y = 0;
|
|
i3 += l3 * width2;
|
|
i2 += k2 * l3;
|
|
}
|
|
if (y + height >= boundsBottomY)
|
|
height -= ((y + height) - boundsBottomY) + 1;
|
|
if (x < boundsTopX) {
|
|
int i4 = boundsTopX - x;
|
|
width -= i4;
|
|
x = 0;
|
|
i3 += i4;
|
|
l1 += j2 * i4;
|
|
k3 += i4;
|
|
}
|
|
if (x + width >= boundsBottomX) {
|
|
int j4 = ((x + width) - boundsBottomX) + 1;
|
|
width -= j4;
|
|
k3 += j4;
|
|
}
|
|
byte yInc = 1;
|
|
if (interlace) {
|
|
yInc = 2;
|
|
k3 += width2;
|
|
k2 += k2;
|
|
if ((y & 1) != 0) {
|
|
i3 += width2;
|
|
height--;
|
|
}
|
|
}
|
|
plotScale(pixels, surfacePixels[spriteId], 0, l1, i2, i3, k3, width, height, j2, k2, spriteWidth, yInc);
|
|
return;
|
|
} catch (Exception Ex) {
|
|
System.out.println("error in sprite clipping routine");
|
|
}
|
|
}
|
|
|
|
public void drawSpriteAlpha(int x, int y, int spriteId, int alpha) {
|
|
if (spriteTranslate[spriteId]) {
|
|
x += spriteTranslateX[spriteId];
|
|
y += spriteTranslateY[spriteId];
|
|
}
|
|
int size = x + y * width2;
|
|
int j1 = 0;
|
|
int height = spriteHeight[spriteId];
|
|
int width = spriteWidth[spriteId];
|
|
int extraXSpace = width2 - width;
|
|
int j2 = 0;
|
|
if (y < boundsTopY) {
|
|
int k2 = boundsTopY - y;
|
|
height -= k2;
|
|
y = boundsTopY;
|
|
j1 += k2 * width;
|
|
size += k2 * width2;
|
|
}
|
|
if (y + height >= boundsBottomY)
|
|
height -= ((y + height) - boundsBottomY) + 1;
|
|
if (x < boundsTopX) {
|
|
int l2 = boundsTopX - x;
|
|
width -= l2;
|
|
x = boundsTopX;
|
|
j1 += l2;
|
|
size += l2;
|
|
j2 += l2;
|
|
extraXSpace += l2;
|
|
}
|
|
if (x + width >= boundsBottomX) {
|
|
int i3 = ((x + width) - boundsBottomX) + 1;
|
|
width -= i3;
|
|
j2 += i3;
|
|
extraXSpace += i3;
|
|
}
|
|
if (width <= 0 || height <= 0)
|
|
return;
|
|
byte yInc = 1;
|
|
if (this.interlace) {
|
|
yInc = 2;
|
|
extraXSpace += width2;
|
|
j2 += spriteWidth[spriteId];
|
|
if ((y & 1) != 0) {
|
|
size += width2;
|
|
height--;
|
|
}
|
|
}
|
|
if (surfacePixels[spriteId] == null) {
|
|
drawSpriteAlpha(pixels, spriteColoursUsed[spriteId], spriteColourList[spriteId], j1, size, width, height, extraXSpace, j2, yInc, alpha);
|
|
return;
|
|
} else {
|
|
drawSpriteAlpha(pixels, surfacePixels[spriteId], 0, j1, size, width, height, extraXSpace, j2, yInc, alpha);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void drawActionBubble(int x, int y, int scaleX, int scaleY, int sprite, int alpha) {
|
|
try {
|
|
int spriteWidth = this.spriteWidth[sprite];
|
|
int spriteHeight = this.spriteHeight[sprite];
|
|
int i2 = 0;
|
|
int j2 = 0;
|
|
int k2 = (spriteWidth << 16) / scaleX;
|
|
int l2 = (spriteHeight << 16) / scaleY;
|
|
if (spriteTranslate[sprite]) {
|
|
int i3 = spriteWidthFull[sprite];
|
|
int k3 = spriteHeightFull[sprite];
|
|
k2 = (i3 << 16) / scaleX;
|
|
l2 = (k3 << 16) / scaleY;
|
|
x += ((spriteTranslateX[sprite] * scaleX + i3) - 1) / i3;
|
|
y += ((spriteTranslateY[sprite] * scaleY + k3) - 1) / k3;
|
|
if ((spriteTranslateX[sprite] * scaleX) % i3 != 0)
|
|
i2 = (i3 - (spriteTranslateX[sprite] * scaleX) % i3 << 16) / scaleX;
|
|
if ((spriteTranslateY[sprite] * scaleY) % k3 != 0)
|
|
j2 = (k3 - (spriteTranslateY[sprite] * scaleY) % k3 << 16) / scaleY;
|
|
scaleX = (scaleX * (this.spriteWidth[sprite] - (i2 >> 16))) / i3;
|
|
scaleY = (scaleY * (this.spriteHeight[sprite] - (j2 >> 16))) / k3;
|
|
}
|
|
int j3 = x + y * width2;
|
|
int l3 = width2 - scaleX;
|
|
if (y < boundsTopY) {
|
|
int i4 = boundsTopY - y;
|
|
scaleY -= i4;
|
|
y = 0;
|
|
j3 += i4 * width2;
|
|
j2 += l2 * i4;
|
|
}
|
|
if (y + scaleY >= boundsBottomY)
|
|
scaleY -= ((y + scaleY) - boundsBottomY) + 1;
|
|
if (x < boundsTopX) {
|
|
int j4 = boundsTopX - x;
|
|
scaleX -= j4;
|
|
x = 0;
|
|
j3 += j4;
|
|
i2 += k2 * j4;
|
|
l3 += j4;
|
|
}
|
|
if (x + scaleX >= boundsBottomX) {
|
|
int k4 = ((x + scaleX) - boundsBottomX) + 1;
|
|
scaleX -= k4;
|
|
l3 += k4;
|
|
}
|
|
byte yInc = 1;
|
|
if (interlace) {
|
|
yInc = 2;
|
|
l3 += width2;
|
|
l2 += l2;
|
|
if ((y & 1) != 0) {
|
|
j3 += width2;
|
|
scaleY--;
|
|
}
|
|
}
|
|
transparentScale(pixels, surfacePixels[sprite], 0, i2, j2, j3, l3, scaleX, scaleY, k2, l2, spriteWidth, yInc, alpha);
|
|
return;
|
|
} catch (Exception ex) {
|
|
System.out.println("error in sprite clipping routine");
|
|
}
|
|
}
|
|
|
|
public void spriteClipping(int x, int y, int width, int height, int spriteId, int colour) {
|
|
try {
|
|
int k1 = spriteWidth[spriteId];
|
|
int l1 = spriteHeight[spriteId];
|
|
int i2 = 0;
|
|
int j2 = 0;
|
|
int k2 = (k1 << 16) / width;
|
|
int l2 = (l1 << 16) / height;
|
|
if (spriteTranslate[spriteId]) {
|
|
int i3 = spriteWidthFull[spriteId];
|
|
int k3 = spriteHeightFull[spriteId];
|
|
k2 = (i3 << 16) / width;
|
|
l2 = (k3 << 16) / height;
|
|
x += ((spriteTranslateX[spriteId] * width + i3) - 1) / i3;
|
|
y += ((spriteTranslateY[spriteId] * height + k3) - 1) / k3;
|
|
if ((spriteTranslateX[spriteId] * width) % i3 != 0)
|
|
i2 = (i3 - (spriteTranslateX[spriteId] * width) % i3 << 16) / width;
|
|
if ((spriteTranslateY[spriteId] * height) % k3 != 0)
|
|
j2 = (k3 - (spriteTranslateY[spriteId] * height) % k3 << 16) / height;
|
|
width = (width * (spriteWidth[spriteId] - (i2 >> 16))) / i3;
|
|
height = (height * (spriteHeight[spriteId] - (j2 >> 16))) / k3;
|
|
}
|
|
int j3 = x + y * width2;
|
|
int l3 = width2 - width;
|
|
if (y < boundsTopY) {
|
|
int i4 = boundsTopY - y;
|
|
height -= i4;
|
|
y = 0;
|
|
j3 += i4 * width2;
|
|
j2 += l2 * i4;
|
|
}
|
|
if (y + height >= boundsBottomY)
|
|
height -= ((y + height) - boundsBottomY) + 1;
|
|
if (x < boundsTopX) {
|
|
int j4 = boundsTopX - x;
|
|
width -= j4;
|
|
x = 0;
|
|
j3 += j4;
|
|
i2 += k2 * j4;
|
|
l3 += j4;
|
|
}
|
|
if (x + width >= boundsBottomX) {
|
|
int k4 = ((x + width) - boundsBottomX) + 1;
|
|
width -= k4;
|
|
l3 += k4;
|
|
}
|
|
byte yInc = 1;
|
|
if (interlace) {
|
|
yInc = 2;
|
|
l3 += width2;
|
|
l2 += l2;
|
|
if ((y & 1) != 0) {
|
|
j3 += width2;
|
|
height--;
|
|
}
|
|
}
|
|
plotScale(pixels, surfacePixels[spriteId], 0, i2, j2, j3, l3, width, height, k2, l2, k1, yInc, colour);
|
|
return;
|
|
} catch (Exception Ex) {
|
|
System.out.println("error in sprite clipping routine");
|
|
}
|
|
}
|
|
|
|
private void drawSprite(int dest[], int src[], int i, int srcPos, int destPos, int width, int height,
|
|
int j1, int k1, int yInc) {
|
|
int i2 = -(width >> 2);
|
|
width = -(width & 3);
|
|
for (int j2 = -height; j2 < 0; j2 += yInc) {
|
|
for (int k2 = i2; k2 < 0; k2++) {
|
|
i = src[srcPos++];
|
|
if (i != 0)
|
|
dest[destPos++] = i;
|
|
else
|
|
destPos++;
|
|
i = src[srcPos++];
|
|
if (i != 0)
|
|
dest[destPos++] = i;
|
|
else
|
|
destPos++;
|
|
i = src[srcPos++];
|
|
if (i != 0)
|
|
dest[destPos++] = i;
|
|
else
|
|
destPos++;
|
|
i = src[srcPos++];
|
|
if (i != 0)
|
|
dest[destPos++] = i;
|
|
else
|
|
destPos++;
|
|
}
|
|
|
|
for (int l2 = width; l2 < 0; l2++) {
|
|
i = src[srcPos++];
|
|
if (i != 0)
|
|
dest[destPos++] = i;
|
|
else
|
|
destPos++;
|
|
}
|
|
|
|
destPos += j1;
|
|
srcPos += k1;
|
|
}
|
|
|
|
}
|
|
|
|
private void drawSprite(int target[], byte colourIdx[], int colours[], int srcPos, int destPos, int width, int height,
|
|
int w2, int h2, int rowInc) {
|
|
int l1 = -(width >> 2);
|
|
width = -(width & 3);
|
|
for (int i2 = -height; i2 < 0; i2 += rowInc) {
|
|
for (int j2 = l1; j2 < 0; j2++) {
|
|
byte byte0 = colourIdx[srcPos++];
|
|
if (byte0 != 0)
|
|
target[destPos++] = colours[byte0 & 0xff];
|
|
else
|
|
destPos++;
|
|
byte0 = colourIdx[srcPos++];
|
|
if (byte0 != 0)
|
|
target[destPos++] = colours[byte0 & 0xff];
|
|
else
|
|
destPos++;
|
|
byte0 = colourIdx[srcPos++];
|
|
if (byte0 != 0)
|
|
target[destPos++] = colours[byte0 & 0xff];
|
|
else
|
|
destPos++;
|
|
byte0 = colourIdx[srcPos++];
|
|
if (byte0 != 0)
|
|
target[destPos++] = colours[byte0 & 0xff];
|
|
else
|
|
destPos++;
|
|
}
|
|
|
|
for (int k2 = width; k2 < 0; k2++) {
|
|
byte byte1 = colourIdx[srcPos++];
|
|
if (byte1 != 0)
|
|
target[destPos++] = colours[byte1 & 0xff];
|
|
else
|
|
destPos++;
|
|
}
|
|
|
|
destPos += w2;
|
|
srcPos += h2;
|
|
}
|
|
|
|
}
|
|
|
|
private void plotScale(int dest[], int src[], int i, int j, int k, int destPos, int i1,
|
|
int j1, int k1, int l1, int i2, int j2, int k2) {
|
|
try {
|
|
int l2 = j;
|
|
for (int i3 = -k1; i3 < 0; i3 += k2) {
|
|
int j3 = (k >> 16) * j2;
|
|
for (int k3 = -j1; k3 < 0; k3++) {
|
|
i = src[(j >> 16) + j3];
|
|
if (i != 0)
|
|
dest[destPos++] = i;
|
|
else
|
|
destPos++;
|
|
j += l1;
|
|
}
|
|
|
|
k += i2;
|
|
j = l2;
|
|
destPos += i1;
|
|
}
|
|
|
|
return;
|
|
} catch (Exception Ex) {
|
|
System.out.println("error in plotScale");
|
|
}
|
|
}
|
|
|
|
private void drawSpriteAlpha(int dest[], int src[], int i, int srcPos, int size, int width, int height,
|
|
int extraXSpace, int k1, int yInc, int alpha) {
|
|
int j2 = 256 - alpha;
|
|
for (int k2 = -height; k2 < 0; k2 += yInc) {
|
|
for (int l2 = -width; l2 < 0; l2++) {
|
|
i = src[srcPos++];
|
|
if (i != 0) {
|
|
int i3 = dest[size];
|
|
dest[size++] = ((i & 0xff00ff) * alpha + (i3 & 0xff00ff) * j2 & 0xff00ff00) + ((i & 0xff00) * alpha + (i3 & 0xff00) * j2 & 0xff0000) >> 8;
|
|
} else {
|
|
size++;
|
|
}
|
|
}
|
|
|
|
size += extraXSpace;
|
|
srcPos += k1;
|
|
}
|
|
|
|
}
|
|
|
|
private void drawSpriteAlpha(int dest[], byte coloursUsed[], int colourList[], int listPos, int size, int width, int height,
|
|
int extraXSpace, int j1, int yInc, int alpha) {
|
|
int i2 = 256 - alpha;
|
|
for (int j2 = -height; j2 < 0; j2 += yInc) {
|
|
for (int k2 = -width; k2 < 0; k2++) {
|
|
int l2 = coloursUsed[listPos++];
|
|
if (l2 != 0) {
|
|
l2 = colourList[l2 & 0xff];
|
|
int i3 = dest[size];
|
|
dest[size++] = ((l2 & 0xff00ff) * alpha + (i3 & 0xff00ff) * i2 & 0xff00ff00) + ((l2 & 0xff00) * alpha + (i3 & 0xff00) * i2 & 0xff0000) >> 8;
|
|
} else {
|
|
size++;
|
|
}
|
|
}
|
|
|
|
size += extraXSpace;
|
|
listPos += j1;
|
|
}
|
|
|
|
}
|
|
|
|
private void transparentScale(int dest[], int src[], int i, int j, int k, int destPos, int i1,
|
|
int j1, int k1, int l1, int i2, int j2, int yInc, int alpha) {
|
|
int i3 = 256 - alpha;
|
|
try {
|
|
int j3 = j;
|
|
for (int k3 = -k1; k3 < 0; k3 += yInc) {
|
|
int l3 = (k >> 16) * j2;
|
|
for (int i4 = -j1; i4 < 0; i4++) {
|
|
i = src[(j >> 16) + l3];
|
|
if (i != 0) {
|
|
int j4 = dest[destPos];
|
|
dest[destPos++] = ((i & 0xff00ff) * alpha + (j4 & 0xff00ff) * i3 & 0xff00ff00) + ((i & 0xff00) * alpha + (j4 & 0xff00) * i3 & 0xff0000) >> 8;
|
|
} else {
|
|
destPos++;
|
|
}
|
|
j += l1;
|
|
}
|
|
|
|
k += i2;
|
|
j = j3;
|
|
destPos += i1;
|
|
}
|
|
|
|
return;
|
|
} catch (Exception Ex) {
|
|
System.out.println("error in tranScale");
|
|
}
|
|
}
|
|
|
|
private void plotScale(int target[], int pixels[], int i, int j, int k, int l, int i1,
|
|
int width, int height, int l1, int i2, int j2, int yInc, int colour) {
|
|
int i3 = colour >> 16 & 0xff;
|
|
int j3 = colour >> 8 & 0xff;
|
|
int k3 = colour & 0xff;
|
|
try {
|
|
int l3 = j;
|
|
for (int i4 = -height; i4 < 0; i4 += yInc) {
|
|
int j4 = (k >> 16) * j2;
|
|
for (int k4 = -width; k4 < 0; k4++) {
|
|
i = pixels[(j >> 16) + j4];
|
|
if (i != 0) {
|
|
int l4 = i >> 16 & 0xff;
|
|
int i5 = i >> 8 & 0xff;
|
|
int j5 = i & 0xff;
|
|
if (l4 == i5 && i5 == j5)
|
|
target[l++] = ((l4 * i3 >> 8) << 16) + ((i5 * j3 >> 8) << 8) + (j5 * k3 >> 8);
|
|
else
|
|
target[l++] = i;
|
|
} else {
|
|
l++;
|
|
}
|
|
j += l1;
|
|
}
|
|
|
|
k += i2;
|
|
j = l3;
|
|
l += i1;
|
|
}
|
|
|
|
return;
|
|
} catch (Exception Ex) {
|
|
System.out.println("error in plotScale");
|
|
}
|
|
}
|
|
|
|
public void drawMinimapSprite(int x, int y, int sprite, int rotation, int scale) {// "scale" is not actually scaling when it comes to the landscape
|
|
int j1 = width2;
|
|
int k1 = height2;
|
|
if (landscapeColours == null) {
|
|
landscapeColours = new int[512];
|
|
for (int l1 = 0; l1 < 256; l1++) {
|
|
landscapeColours[l1] = (int) (Math.sin((double) l1 * 0.02454369D) * 32768D);
|
|
landscapeColours[l1 + 256] = (int) (Math.cos((double) l1 * 0.02454369D) * 32768D);
|
|
}
|
|
|
|
}
|
|
int i2 = -spriteWidthFull[sprite] / 2;
|
|
int j2 = -spriteHeightFull[sprite] / 2;
|
|
if (spriteTranslate[sprite]) {
|
|
i2 += spriteTranslateX[sprite];
|
|
j2 += spriteTranslateY[sprite];
|
|
}
|
|
int k2 = i2 + spriteWidth[sprite];
|
|
int l2 = j2 + spriteHeight[sprite];
|
|
int i3 = k2;
|
|
int j3 = j2;
|
|
int k3 = i2;
|
|
int l3 = l2;
|
|
rotation &= 0xff;
|
|
int i4 = landscapeColours[rotation] * scale;
|
|
int j4 = landscapeColours[rotation + 256] * scale;
|
|
int k4 = x + (j2 * i4 + i2 * j4 >> 22);
|
|
int l4 = y + (j2 * j4 - i2 * i4 >> 22);
|
|
int i5 = x + (j3 * i4 + i3 * j4 >> 22);
|
|
int j5 = y + (j3 * j4 - i3 * i4 >> 22);
|
|
int k5 = x + (l2 * i4 + k2 * j4 >> 22);
|
|
int l5 = y + (l2 * j4 - k2 * i4 >> 22);
|
|
int i6 = x + (l3 * i4 + k3 * j4 >> 22);
|
|
int j6 = y + (l3 * j4 - k3 * i4 >> 22);
|
|
if (scale == 192 && (rotation & 0x3f) == (anInt348 & 0x3f))
|
|
anInt346++;
|
|
else if (scale == 128)
|
|
anInt348 = rotation;
|
|
else
|
|
anInt347++;
|
|
int k6 = l4;
|
|
int l6 = l4;
|
|
if (j5 < k6)
|
|
k6 = j5;
|
|
else if (j5 > l6)
|
|
l6 = j5;
|
|
if (l5 < k6)
|
|
k6 = l5;
|
|
else if (l5 > l6)
|
|
l6 = l5;
|
|
if (j6 < k6)
|
|
k6 = j6;
|
|
else if (j6 > l6)
|
|
l6 = j6;
|
|
if (k6 < boundsTopY)
|
|
k6 = boundsTopY;
|
|
if (l6 > boundsBottomY)
|
|
l6 = boundsBottomY;
|
|
if (anIntArray340 == null || anIntArray340.length != k1 + 1) {
|
|
anIntArray340 = new int[k1 + 1];
|
|
anIntArray341 = new int[k1 + 1];
|
|
anIntArray342 = new int[k1 + 1];
|
|
anIntArray343 = new int[k1 + 1];
|
|
anIntArray344 = new int[k1 + 1];
|
|
anIntArray345 = new int[k1 + 1];
|
|
}
|
|
for (int i7 = k6; i7 <= l6; i7++) {
|
|
anIntArray340[i7] = 99999999;
|
|
anIntArray341[i7] = 0xfa0a1f01;
|
|
}
|
|
|
|
int i8 = 0;
|
|
int k8 = 0;
|
|
int i9 = 0;
|
|
int j9 = spriteWidth[sprite];
|
|
int k9 = spriteHeight[sprite];
|
|
i2 = 0;
|
|
j2 = 0;
|
|
i3 = j9 - 1;
|
|
j3 = 0;
|
|
k2 = j9 - 1;
|
|
l2 = k9 - 1;
|
|
k3 = 0;
|
|
l3 = k9 - 1;
|
|
if (j6 != l4) {
|
|
i8 = (i6 - k4 << 8) / (j6 - l4);
|
|
i9 = (l3 - j2 << 8) / (j6 - l4);
|
|
}
|
|
int j7;
|
|
int k7;
|
|
int l7;
|
|
int l8;
|
|
if (l4 > j6) {
|
|
l7 = i6 << 8;
|
|
l8 = l3 << 8;
|
|
j7 = j6;
|
|
k7 = l4;
|
|
} else {
|
|
l7 = k4 << 8;
|
|
l8 = j2 << 8;
|
|
j7 = l4;
|
|
k7 = j6;
|
|
}
|
|
if (j7 < 0) {
|
|
l7 -= i8 * j7;
|
|
l8 -= i9 * j7;
|
|
j7 = 0;
|
|
}
|
|
if (k7 > k1 - 1)
|
|
k7 = k1 - 1;
|
|
for (int l9 = j7; l9 <= k7; l9++) {
|
|
anIntArray340[l9] = anIntArray341[l9] = l7;
|
|
l7 += i8;
|
|
anIntArray342[l9] = anIntArray343[l9] = 0;
|
|
anIntArray344[l9] = anIntArray345[l9] = l8;
|
|
l8 += i9;
|
|
}
|
|
|
|
if (j5 != l4) {
|
|
i8 = (i5 - k4 << 8) / (j5 - l4);
|
|
k8 = (i3 - i2 << 8) / (j5 - l4);
|
|
}
|
|
int j8;
|
|
if (l4 > j5) {
|
|
l7 = i5 << 8;
|
|
j8 = i3 << 8;
|
|
j7 = j5;
|
|
k7 = l4;
|
|
} else {
|
|
l7 = k4 << 8;
|
|
j8 = i2 << 8;
|
|
j7 = l4;
|
|
k7 = j5;
|
|
}
|
|
if (j7 < 0) {
|
|
l7 -= i8 * j7;
|
|
j8 -= k8 * j7;
|
|
j7 = 0;
|
|
}
|
|
if (k7 > k1 - 1)
|
|
k7 = k1 - 1;
|
|
for (int i10 = j7; i10 <= k7; i10++) {
|
|
if (l7 < anIntArray340[i10]) {
|
|
anIntArray340[i10] = l7;
|
|
anIntArray342[i10] = j8;
|
|
anIntArray344[i10] = 0;
|
|
}
|
|
if (l7 > anIntArray341[i10]) {
|
|
anIntArray341[i10] = l7;
|
|
anIntArray343[i10] = j8;
|
|
anIntArray345[i10] = 0;
|
|
}
|
|
l7 += i8;
|
|
j8 += k8;
|
|
}
|
|
|
|
if (l5 != j5) {
|
|
i8 = (k5 - i5 << 8) / (l5 - j5);
|
|
i9 = (l2 - j3 << 8) / (l5 - j5);
|
|
}
|
|
if (j5 > l5) {
|
|
l7 = k5 << 8;
|
|
j8 = k2 << 8;
|
|
l8 = l2 << 8;
|
|
j7 = l5;
|
|
k7 = j5;
|
|
} else {
|
|
l7 = i5 << 8;
|
|
j8 = i3 << 8;
|
|
l8 = j3 << 8;
|
|
j7 = j5;
|
|
k7 = l5;
|
|
}
|
|
if (j7 < 0) {
|
|
l7 -= i8 * j7;
|
|
l8 -= i9 * j7;
|
|
j7 = 0;
|
|
}
|
|
if (k7 > k1 - 1)
|
|
k7 = k1 - 1;
|
|
for (int j10 = j7; j10 <= k7; j10++) {
|
|
if (l7 < anIntArray340[j10]) {
|
|
anIntArray340[j10] = l7;
|
|
anIntArray342[j10] = j8;
|
|
anIntArray344[j10] = l8;
|
|
}
|
|
if (l7 > anIntArray341[j10]) {
|
|
anIntArray341[j10] = l7;
|
|
anIntArray343[j10] = j8;
|
|
anIntArray345[j10] = l8;
|
|
}
|
|
l7 += i8;
|
|
l8 += i9;
|
|
}
|
|
|
|
if (j6 != l5) {
|
|
i8 = (i6 - k5 << 8) / (j6 - l5);
|
|
k8 = (k3 - k2 << 8) / (j6 - l5);
|
|
}
|
|
if (l5 > j6) {
|
|
l7 = i6 << 8;
|
|
j8 = k3 << 8;
|
|
l8 = l3 << 8;
|
|
j7 = j6;
|
|
k7 = l5;
|
|
} else {
|
|
l7 = k5 << 8;
|
|
j8 = k2 << 8;
|
|
l8 = l2 << 8;
|
|
j7 = l5;
|
|
k7 = j6;
|
|
}
|
|
if (j7 < 0) {
|
|
l7 -= i8 * j7;
|
|
j8 -= k8 * j7;
|
|
j7 = 0;
|
|
}
|
|
if (k7 > k1 - 1)
|
|
k7 = k1 - 1;
|
|
for (int k10 = j7; k10 <= k7; k10++) {
|
|
if (l7 < anIntArray340[k10]) {
|
|
anIntArray340[k10] = l7;
|
|
anIntArray342[k10] = j8;
|
|
anIntArray344[k10] = l8;
|
|
}
|
|
if (l7 > anIntArray341[k10]) {
|
|
anIntArray341[k10] = l7;
|
|
anIntArray343[k10] = j8;
|
|
anIntArray345[k10] = l8;
|
|
}
|
|
l7 += i8;
|
|
j8 += k8;
|
|
}
|
|
|
|
int l10 = k6 * j1;
|
|
int ai[] = surfacePixels[sprite];
|
|
for (int i11 = k6; i11 < l6; i11++) {
|
|
int j11 = anIntArray340[i11] >> 8;
|
|
int k11 = anIntArray341[i11] >> 8;
|
|
if (k11 - j11 <= 0) {
|
|
l10 += j1;
|
|
} else {
|
|
int l11 = anIntArray342[i11] << 9;
|
|
int i12 = ((anIntArray343[i11] << 9) - l11) / (k11 - j11);
|
|
int j12 = anIntArray344[i11] << 9;
|
|
int k12 = ((anIntArray345[i11] << 9) - j12) / (k11 - j11);
|
|
if (j11 < boundsTopX) {
|
|
l11 += (boundsTopX - j11) * i12;
|
|
j12 += (boundsTopX - j11) * k12;
|
|
j11 = boundsTopX;
|
|
}
|
|
if (k11 > boundsBottomX)
|
|
k11 = boundsBottomX;
|
|
if (!interlace || (i11 & 1) == 0)
|
|
if (!spriteTranslate[sprite])
|
|
drawMinimap(pixels, ai, 0, l10 + j11, l11, j12, i12, k12, j11 - k11, j9);
|
|
else
|
|
drawMinimapTranslate(pixels, ai, 0, l10 + j11, l11, j12, i12, k12, j11 - k11, j9);
|
|
l10 += j1;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private void drawMinimap(int ai[], int ai1[], int i, int j, int k, int l, int i1,
|
|
int j1, int k1, int l1) {
|
|
for (i = k1; i < 0; i++) {
|
|
pixels[j++] = ai1[(k >> 17) + (l >> 17) * l1];
|
|
k += i1;
|
|
l += j1;
|
|
}
|
|
|
|
}
|
|
|
|
private void drawMinimapTranslate(int ai[], int ai1[], int i, int j, int k, int l, int i1,
|
|
int j1, int k1, int l1) {
|
|
for (int i2 = k1; i2 < 0; i2++) {
|
|
i = ai1[(k >> 17) + (l >> 17) * l1];
|
|
if (i != 0)
|
|
pixels[j++] = i;
|
|
else
|
|
j++;
|
|
k += i1;
|
|
l += j1;
|
|
}
|
|
|
|
}
|
|
|
|
public void spriteClipping(int x, int y, int w, int h, int id, int tx, int ty) {
|
|
spriteClipping(x, y, w, h, id);
|
|
}
|
|
|
|
public void spriteClipping(int x, int y, int w, int h, int sprite, int colour1, int colour2,
|
|
int l1, boolean flag) {
|
|
try {
|
|
if (colour1 == 0)
|
|
colour1 = 0xffffff;
|
|
if (colour2 == 0)
|
|
colour2 = 0xffffff;
|
|
int width = spriteWidth[sprite];
|
|
int height = spriteHeight[sprite];
|
|
int k2 = 0;
|
|
int l2 = 0;
|
|
int i3 = l1 << 16;
|
|
int j3 = (width << 16) / w;
|
|
int k3 = (height << 16) / h;
|
|
int l3 = -(l1 << 16) / h;
|
|
if (spriteTranslate[sprite]) {
|
|
int fullWidth = spriteWidthFull[sprite];
|
|
int fullHeight = spriteHeightFull[sprite];
|
|
j3 = (fullWidth << 16) / w;
|
|
k3 = (fullHeight << 16) / h;
|
|
int j5 = spriteTranslateX[sprite];
|
|
int k5 = spriteTranslateY[sprite];
|
|
if (flag)
|
|
j5 = fullWidth - spriteWidth[sprite] - j5;
|
|
x += ((j5 * w + fullWidth) - 1) / fullWidth;
|
|
int l5 = ((k5 * h + fullHeight) - 1) / fullHeight;
|
|
y += l5;
|
|
i3 += l5 * l3;
|
|
if ((j5 * w) % fullWidth != 0)
|
|
k2 = (fullWidth - (j5 * w) % fullWidth << 16) / w;
|
|
if ((k5 * h) % fullHeight != 0)
|
|
l2 = (fullHeight - (k5 * h) % fullHeight << 16) / h;
|
|
w = ((((spriteWidth[sprite] << 16) - k2) + j3) - 1) / j3;
|
|
h = ((((spriteHeight[sprite] << 16) - l2) + k3) - 1) / k3;
|
|
}
|
|
int j4 = y * width2;
|
|
i3 += x << 16;
|
|
if (y < boundsTopY) {
|
|
int l4 = boundsTopY - y;
|
|
h -= l4;
|
|
y = boundsTopY;
|
|
j4 += l4 * width2;
|
|
l2 += k3 * l4;
|
|
i3 += l3 * l4;
|
|
}
|
|
if (y + h >= boundsBottomY)
|
|
h -= ((y + h) - boundsBottomY) + 1;
|
|
int i5 = j4 / width2 & 1;
|
|
if (!interlace)
|
|
i5 = 2;
|
|
if (colour2 == 0xffffff) {
|
|
if (surfacePixels[sprite] != null)
|
|
if (!flag) {
|
|
transparentSpritePlot(pixels, surfacePixels[sprite], 0, k2, l2, j4, w, h, j3, k3, width, colour1, i3, l3, i5);
|
|
return;
|
|
} else {
|
|
transparentSpritePlot(pixels, surfacePixels[sprite], 0, (spriteWidth[sprite] << 16) - k2 - 1, l2, j4, w, h, -j3, k3, width, colour1, i3, l3, i5);
|
|
return;
|
|
}
|
|
if (!flag) {
|
|
transparentSpritePlot(pixels, spriteColoursUsed[sprite], spriteColourList[sprite], 0, k2, l2, j4, w, h, j3, k3, width, colour1, i3, l3, i5);
|
|
return;
|
|
} else {
|
|
transparentSpritePlot(pixels, spriteColoursUsed[sprite], spriteColourList[sprite], 0, (spriteWidth[sprite] << 16) - k2 - 1, l2, j4, w, h, -j3, k3, width, colour1, i3, l3, i5);
|
|
return;
|
|
}
|
|
}
|
|
if (surfacePixels[sprite] != null)
|
|
if (!flag) {
|
|
transparentSpritePlot(pixels, surfacePixels[sprite], 0, k2, l2, j4, w, h, j3, k3, width, colour1, colour2, i3, l3, i5);
|
|
return;
|
|
} else {
|
|
transparentSpritePlot(pixels, surfacePixels[sprite], 0, (spriteWidth[sprite] << 16) - k2 - 1, l2, j4, w, h, -j3, k3, width, colour1, colour2, i3, l3, i5);
|
|
return;
|
|
}
|
|
if (!flag) {
|
|
transparentSpritePlot(pixels, spriteColoursUsed[sprite], spriteColourList[sprite], 0, k2, l2, j4, w, h, j3, k3, width, colour1, colour2, i3, l3, i5);
|
|
return;
|
|
} else {
|
|
transparentSpritePlot(pixels, spriteColoursUsed[sprite], spriteColourList[sprite], 0, (spriteWidth[sprite] << 16) - k2 - 1, l2, j4, w, h, -j3, k3, width, colour1, colour2, i3, l3, i5);
|
|
return;
|
|
}
|
|
} catch (Exception Ex) {
|
|
System.out.println("error in sprite clipping routine");
|
|
}
|
|
}
|
|
|
|
private void transparentSpritePlot(int dest[], int src[], int i, int j, int k, int destPos, int i1,
|
|
int j1, int k1, int l1, int i2, int j2, int k2, int l2,
|
|
int i3) {
|
|
int i4 = j2 >> 16 & 0xff;
|
|
int j4 = j2 >> 8 & 0xff;
|
|
int k4 = j2 & 0xff;
|
|
try {
|
|
int l4 = j;
|
|
for (int i5 = -j1; i5 < 0; i5++) {
|
|
int j5 = (k >> 16) * i2;
|
|
int k5 = k2 >> 16;
|
|
int l5 = i1;
|
|
if (k5 < boundsTopX) {
|
|
int i6 = boundsTopX - k5;
|
|
l5 -= i6;
|
|
k5 = boundsTopX;
|
|
j += k1 * i6;
|
|
}
|
|
if (k5 + l5 >= boundsBottomX) {
|
|
int j6 = (k5 + l5) - boundsBottomX;
|
|
l5 -= j6;
|
|
}
|
|
i3 = 1 - i3;
|
|
if (i3 != 0) {
|
|
for (int k6 = k5; k6 < k5 + l5; k6++) {
|
|
i = src[(j >> 16) + j5];
|
|
if (i != 0) {
|
|
int j3 = i >> 16 & 0xff;
|
|
int k3 = i >> 8 & 0xff;
|
|
int l3 = i & 0xff;
|
|
if (j3 == k3 && k3 == l3)
|
|
dest[k6 + destPos] = ((j3 * i4 >> 8) << 16) + ((k3 * j4 >> 8) << 8) + (l3 * k4 >> 8);
|
|
else
|
|
dest[k6 + destPos] = i;
|
|
}
|
|
j += k1;
|
|
}
|
|
|
|
}
|
|
k += l1;
|
|
j = l4;
|
|
destPos += width2;
|
|
k2 += l2;
|
|
}
|
|
|
|
return;
|
|
} catch (Exception Ex) {
|
|
System.out.println("error in transparent sprite plot routine");
|
|
}
|
|
}
|
|
|
|
private void transparentSpritePlot(int dest[], int src[], int i, int j, int k, int destPos, int i1,
|
|
int j1, int k1, int l1, int i2, int j2, int k2, int l2,
|
|
int i3, int j3) {
|
|
int j4 = j2 >> 16 & 0xff;
|
|
int k4 = j2 >> 8 & 0xff;
|
|
int l4 = j2 & 0xff;
|
|
int i5 = k2 >> 16 & 0xff;
|
|
int j5 = k2 >> 8 & 0xff;
|
|
int k5 = k2 & 0xff;
|
|
try {
|
|
int l5 = j;
|
|
for (int i6 = -j1; i6 < 0; i6++) {
|
|
int j6 = (k >> 16) * i2;
|
|
int k6 = l2 >> 16;
|
|
int l6 = i1;
|
|
if (k6 < boundsTopX) {
|
|
int i7 = boundsTopX - k6;
|
|
l6 -= i7;
|
|
k6 = boundsTopX;
|
|
j += k1 * i7;
|
|
}
|
|
if (k6 + l6 >= boundsBottomX) {
|
|
int j7 = (k6 + l6) - boundsBottomX;
|
|
l6 -= j7;
|
|
}
|
|
j3 = 1 - j3;
|
|
if (j3 != 0) {
|
|
for (int k7 = k6; k7 < k6 + l6; k7++) {
|
|
i = src[(j >> 16) + j6];
|
|
if (i != 0) {
|
|
int k3 = i >> 16 & 0xff;
|
|
int l3 = i >> 8 & 0xff;
|
|
int i4 = i & 0xff;
|
|
if (k3 == l3 && l3 == i4)
|
|
dest[k7 + destPos] = ((k3 * j4 >> 8) << 16) + ((l3 * k4 >> 8) << 8) + (i4 * l4 >> 8);
|
|
else if (k3 == 255 && l3 == i4)
|
|
dest[k7 + destPos] = ((k3 * i5 >> 8) << 16) + ((l3 * j5 >> 8) << 8) + (i4 * k5 >> 8);
|
|
else
|
|
dest[k7 + destPos] = i;
|
|
}
|
|
j += k1;
|
|
}
|
|
|
|
}
|
|
k += l1;
|
|
j = l5;
|
|
destPos += width2;
|
|
l2 += i3;
|
|
}
|
|
|
|
return;
|
|
} catch (Exception Ex) {
|
|
System.out.println("error in transparent sprite plot routine");
|
|
}
|
|
}
|
|
|
|
private void transparentSpritePlot(int dest[], byte colourIdx[], int colours[], int i, int j, int k, int l,
|
|
int i1, int j1, int k1, int l1, int i2, int j2, int k2,
|
|
int l2, int i3) {
|
|
int i4 = j2 >> 16 & 0xff;
|
|
int j4 = j2 >> 8 & 0xff;
|
|
int k4 = j2 & 0xff;
|
|
try {
|
|
int l4 = j;
|
|
for (int i5 = -j1; i5 < 0; i5++) {
|
|
int j5 = (k >> 16) * i2;
|
|
int k5 = k2 >> 16;
|
|
int l5 = i1;
|
|
if (k5 < boundsTopX) {
|
|
int i6 = boundsTopX - k5;
|
|
l5 -= i6;
|
|
k5 = boundsTopX;
|
|
j += k1 * i6;
|
|
}
|
|
if (k5 + l5 >= boundsBottomX) {
|
|
int j6 = (k5 + l5) - boundsBottomX;
|
|
l5 -= j6;
|
|
}
|
|
i3 = 1 - i3;
|
|
if (i3 != 0) {
|
|
for (int k6 = k5; k6 < k5 + l5; k6++) {
|
|
i = colourIdx[(j >> 16) + j5] & 0xff;
|
|
if (i != 0) {
|
|
i = colours[i];
|
|
int j3 = i >> 16 & 0xff;
|
|
int k3 = i >> 8 & 0xff;
|
|
int l3 = i & 0xff;
|
|
if (j3 == k3 && k3 == l3)
|
|
dest[k6 + l] = ((j3 * i4 >> 8) << 16) + ((k3 * j4 >> 8) << 8) + (l3 * k4 >> 8);
|
|
else
|
|
dest[k6 + l] = i;
|
|
}
|
|
j += k1;
|
|
}
|
|
|
|
}
|
|
k += l1;
|
|
j = l4;
|
|
l += width2;
|
|
k2 += l2;
|
|
}
|
|
|
|
return;
|
|
} catch (Exception Ex) {
|
|
System.out.println("error in transparent sprite plot routine");
|
|
}
|
|
}
|
|
|
|
private void transparentSpritePlot(int dest[], byte coloursUsed[], int colourList[], int i, int j, int k, int l,
|
|
int i1, int j1, int k1, int l1, int i2, int j2, int k2,
|
|
int l2, int i3, int j3) {
|
|
int j4 = j2 >> 16 & 0xff;
|
|
int k4 = j2 >> 8 & 0xff;
|
|
int l4 = j2 & 0xff;
|
|
int i5 = k2 >> 16 & 0xff;
|
|
int j5 = k2 >> 8 & 0xff;
|
|
int k5 = k2 & 0xff;
|
|
try {
|
|
int l5 = j;
|
|
for (int i6 = -j1; i6 < 0; i6++) {
|
|
int j6 = (k >> 16) * i2;
|
|
int k6 = l2 >> 16;
|
|
int l6 = i1;
|
|
if (k6 < boundsTopX) {
|
|
int i7 = boundsTopX - k6;
|
|
l6 -= i7;
|
|
k6 = boundsTopX;
|
|
j += k1 * i7;
|
|
}
|
|
if (k6 + l6 >= boundsBottomX) {
|
|
int j7 = (k6 + l6) - boundsBottomX;
|
|
l6 -= j7;
|
|
}
|
|
j3 = 1 - j3;
|
|
if (j3 != 0) {
|
|
for (int k7 = k6; k7 < k6 + l6; k7++) {
|
|
i = coloursUsed[(j >> 16) + j6] & 0xff;
|
|
if (i != 0) {
|
|
i = colourList[i];
|
|
int k3 = i >> 16 & 0xff;
|
|
int l3 = i >> 8 & 0xff;
|
|
int i4 = i & 0xff;
|
|
if (k3 == l3 && l3 == i4)
|
|
dest[k7 + l] = ((k3 * j4 >> 8) << 16) + ((l3 * k4 >> 8) << 8) + (i4 * l4 >> 8);
|
|
else if (k3 == 255 && l3 == i4)
|
|
dest[k7 + l] = ((k3 * i5 >> 8) << 16) + ((l3 * j5 >> 8) << 8) + (i4 * k5 >> 8);
|
|
else
|
|
dest[k7 + l] = i;
|
|
}
|
|
j += k1;
|
|
}
|
|
|
|
}
|
|
k += l1;
|
|
j = l5;
|
|
l += width2;
|
|
l2 += i3;
|
|
}
|
|
|
|
return;
|
|
} catch (Exception Ex) {
|
|
System.out.println("error in transparent sprite plot routine");
|
|
}
|
|
}
|
|
|
|
public void drawstringRight(String text, int x, int y, int font, int colour) {
|
|
drawstring(text, x - textWidth(text, font), y, font, colour);
|
|
}
|
|
|
|
public void drawStringCenter(String text, int x, int y, int font, int colour) {
|
|
drawstring(text, x - textWidth(text, font) / 2, y, font, colour);
|
|
}
|
|
|
|
public void centrepara(String text, int x, int y, int font, int colour, int max) {
|
|
try {
|
|
int width = 0;
|
|
byte fontdata[] = gameFonts[font];
|
|
int start = 0;
|
|
int end = 0;
|
|
for (int index = 0; index < text.length(); index++) {
|
|
if (text.charAt(index) == '@' && index + 4 < text.length() && text.charAt(index + 4) == '@')
|
|
index += 4;
|
|
else if (text.charAt(index) == '~' && index + 4 < text.length() && text.charAt(index + 4) == '~')
|
|
index += 4;
|
|
else
|
|
width += fontdata[characterWidth[text.charAt(index)] + 7];
|
|
if (text.charAt(index) == ' ')
|
|
end = index;
|
|
if (text.charAt(index) == '%') {
|
|
end = index;
|
|
width = 1000;
|
|
}
|
|
if (width > max) {
|
|
if (end <= start)
|
|
end = index;
|
|
drawStringCenter(text.substring(start, end), x, y, font, colour);
|
|
width = 0;
|
|
start = index = end + 1;
|
|
y += textHeight(font);
|
|
}
|
|
}
|
|
|
|
if (width > 0) {
|
|
drawStringCenter(text.substring(start), x, y, font, colour);
|
|
return;
|
|
}
|
|
} catch (Exception exception) {
|
|
System.out.println("centrepara: " + exception);
|
|
exception.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public void drawstring(String text, int x, int y, int font, int colour) {
|
|
try {
|
|
byte fontData[] = gameFonts[font];
|
|
for (int idx = 0; idx < text.length(); idx++)
|
|
if (text.charAt(idx) == '@' && idx + 4 < text.length() && text.charAt(idx + 4) == '@') {
|
|
if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("red"))
|
|
colour = 0xff0000;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("lre"))
|
|
colour = 0xff9040;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("yel"))
|
|
colour = 0xffff00;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("gre"))
|
|
colour = 65280;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("blu"))
|
|
colour = 255;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("cya"))
|
|
colour = 65535;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("mag"))
|
|
colour = 0xff00ff;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("whi"))
|
|
colour = 0xffffff;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("bla"))
|
|
colour = 0;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("dre"))
|
|
colour = 0xc00000;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("ora"))
|
|
colour = 0xff9040;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("ran"))
|
|
colour = (int) (Math.random() * 16777215D);
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("or1"))
|
|
colour = 0xffb000;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("or2"))
|
|
colour = 0xff7000;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("or3"))
|
|
colour = 0xff3000;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("gr1"))
|
|
colour = 0xc0ff00;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("gr2"))
|
|
colour = 0x80ff00;
|
|
else if (text.substring(idx + 1, idx + 4).equalsIgnoreCase("gr3"))
|
|
colour = 0x40ff00;
|
|
idx += 4;
|
|
} else if (text.charAt(idx) == '~' && idx + 4 < text.length() && text.charAt(idx + 4) == '~') {
|
|
char c = text.charAt(idx + 1);
|
|
char c1 = text.charAt(idx + 2);
|
|
char c2 = text.charAt(idx + 3);
|
|
if (c >= '0' && c <= '9' && c1 >= '0' && c1 <= '9' && c2 >= '0' && c2 <= '9')
|
|
x = Integer.parseInt(text.substring(idx + 1, idx + 4));
|
|
idx += 4;
|
|
} else {
|
|
int width = characterWidth[text.charAt(idx)];
|
|
if (loggedIn && colour != 0) {
|
|
drawCharacter(width, x + 1, y, 0, fontData);
|
|
drawCharacter(width, x, y + 1, 0, fontData);
|
|
}
|
|
drawCharacter(width, x, y, colour, fontData);
|
|
x += fontData[width + 7];
|
|
}
|
|
|
|
return;
|
|
} catch (Exception exception) {
|
|
System.out.println("drawstring: " + exception);
|
|
exception.printStackTrace();
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void drawCharacter(int width, int x, int y, int colour, byte font[]) {
|
|
int i1 = x + font[width + 5];
|
|
int j1 = y - font[width + 6];
|
|
int k1 = font[width + 3];
|
|
int l1 = font[width + 4];
|
|
int i2 = font[width] * 16384 + font[width + 1] * 128 + font[width + 2];
|
|
int j2 = i1 + j1 * width2;
|
|
int k2 = width2 - k1;
|
|
int l2 = 0;
|
|
if (j1 < boundsTopY) {
|
|
int i3 = boundsTopY - j1;
|
|
l1 -= i3;
|
|
j1 = boundsTopY;
|
|
i2 += i3 * k1;
|
|
j2 += i3 * width2;
|
|
}
|
|
if (j1 + l1 >= boundsBottomY)
|
|
l1 -= ((j1 + l1) - boundsBottomY) + 1;
|
|
if (i1 < boundsTopX) {
|
|
int j3 = boundsTopX - i1;
|
|
k1 -= j3;
|
|
i1 = boundsTopX;
|
|
i2 += j3;
|
|
j2 += j3;
|
|
l2 += j3;
|
|
k2 += j3;
|
|
}
|
|
if (i1 + k1 >= boundsBottomX) {
|
|
int k3 = ((i1 + k1) - boundsBottomX) + 1;
|
|
k1 -= k3;
|
|
l2 += k3;
|
|
k2 += k3;
|
|
}
|
|
if (k1 > 0 && l1 > 0) {
|
|
plotLetter(pixels, font, colour, i2, j2, k1, l1, k2, l2);
|
|
}
|
|
}
|
|
|
|
private void plotLetter(int ai[], byte abyte0[], int i, int j, int k, int l, int i1,
|
|
int j1, int k1) {
|
|
try {
|
|
int l1 = -(l >> 2);
|
|
l = -(l & 3);
|
|
for (int i2 = -i1; i2 < 0; i2++) {
|
|
for (int j2 = l1; j2 < 0; j2++) {
|
|
if (abyte0[j++] != 0)
|
|
ai[k++] = i;
|
|
else
|
|
k++;
|
|
if (abyte0[j++] != 0)
|
|
ai[k++] = i;
|
|
else
|
|
k++;
|
|
if (abyte0[j++] != 0)
|
|
ai[k++] = i;
|
|
else
|
|
k++;
|
|
if (abyte0[j++] != 0)
|
|
ai[k++] = i;
|
|
else
|
|
k++;
|
|
}
|
|
|
|
for (int k2 = l; k2 < 0; k2++)
|
|
if (abyte0[j++] != 0)
|
|
ai[k++] = i;
|
|
else
|
|
k++;
|
|
|
|
k += j1;
|
|
j += k1;
|
|
}
|
|
|
|
return;
|
|
} catch (Exception exception) {
|
|
System.out.println("plotletter: " + exception);
|
|
exception.printStackTrace();
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void method259(int ai[], byte abyte0[], int i, int j, int k, int l, int i1,
|
|
int j1, int k1) {// todo
|
|
for (int l1 = -i1; l1 < 0; l1++) {
|
|
for (int i2 = -l; i2 < 0; i2++) {
|
|
int j2 = abyte0[j++] & 0xff;
|
|
if (j2 > 30) {
|
|
if (j2 >= 230) {
|
|
ai[k++] = i;
|
|
} else {
|
|
int k2 = ai[k];
|
|
ai[k++] = ((i & 0xff00ff) * j2 + (k2 & 0xff00ff) * (256 - j2) & 0xff00ff00) + ((i & 0xff00) * j2 + (k2 & 0xff00) * (256 - j2) & 0xff0000) >> 8;
|
|
}
|
|
} else {
|
|
k++;
|
|
}
|
|
}
|
|
|
|
k += j1;
|
|
j += k1;
|
|
}
|
|
|
|
}
|
|
|
|
public int textHeight(int fontId) {
|
|
if (fontId == 0)
|
|
return 12;
|
|
if (fontId == 1)
|
|
return 14;
|
|
if (fontId == 2)
|
|
return 14;
|
|
if (fontId == 3)
|
|
return 15;
|
|
if (fontId == 4)
|
|
return 15;
|
|
if (fontId == 5)
|
|
return 19;
|
|
if (fontId == 6)
|
|
return 24;
|
|
if (fontId == 7)
|
|
return 29;
|
|
else
|
|
return textHeightFont(fontId);
|
|
}
|
|
|
|
public int textHeightFont(int fontId) {
|
|
if (fontId == 0)
|
|
return gameFonts[fontId][8] - 2;
|
|
else
|
|
return gameFonts[fontId][8] - 1;
|
|
}
|
|
|
|
public int textWidth(String text, int fontId) {
|
|
int total = 0;
|
|
byte font[] = gameFonts[fontId];
|
|
for (int idx = 0; idx < text.length(); idx++)
|
|
if (text.charAt(idx) == '@' && idx + 4 < text.length() && text.charAt(idx + 4) == '@')
|
|
idx += 4;
|
|
else if (text.charAt(idx) == '~' && idx + 4 < text.length() && text.charAt(idx + 4) == '~')
|
|
idx += 4;
|
|
else
|
|
total += font[characterWidth[text.charAt(idx)] + 7];
|
|
|
|
return total;
|
|
}
|
|
|
|
/*public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
|
|
return true;
|
|
}*/
|
|
}
|