public static Tileset FromArchive(string file, Archive archive)
{
if (!archive.Contains(file)) return null;
Tileset tileset = LoadTiles(new MemoryStream(archive.ExtractFile(file)));
tileset.name = Path.GetFileNameWithoutExtension(file).ToUpper();
tileset.filename = file;
return tileset;
}
public static HPF FromArchive(string file, bool ignoreCase, Archive archive)
{
if (!archive.Contains(file, ignoreCase)) return null;
return FromRawData(archive.ExtractFile(file, ignoreCase));
}
public int LoadPalettes(string pattern, Archive archive)
{
palettes.Clear();
foreach (ArchiveFile file in archive.Files)
{
if (file.Name.ToUpper().EndsWith(".PAL") && file.Name.ToUpper().StartsWith(pattern.ToUpper()))
{
int index = Convert.ToInt32(Path.GetFileNameWithoutExtension(file.Name).Remove(0, pattern.Length));
ColorPalette palette = ColorPalette.FromArchive(file.Name, archive);
palettes.Add(index, palette);
}
}
return palettes.Count;
}
public int LoadTables(string pattern, Archive archive)
{
entries.Clear();
foreach (ArchiveFile file in archive.Files)
{
// Check for Palette
if (file.Name.ToUpper().EndsWith(".TBL") && file.Name.ToUpper().StartsWith(pattern.ToUpper()))
{
string tableName = Path.GetFileNameWithoutExtension(file.Name).Remove(0, pattern.Length);
if (tableName != "ani")
{
MemoryStream stream = new MemoryStream(archive.ExtractFile(file));
StreamReader reader = new StreamReader(stream);
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
string[] lineSplit = line.Split(' ');
if (lineSplit.Length == 3)
{
int min = Convert.ToInt32(lineSplit[0]);
int max = Convert.ToInt32(lineSplit[1]);
int pal = Convert.ToInt32(lineSplit[2]);
int index = 0;
if (int.TryParse(tableName, out index))
overrides.Add(new Palette(min, max, pal));
else
entries.Add(new Palette(min, max, pal));
}
else if (lineSplit.Length == 2)
{
int min = Convert.ToInt32(lineSplit[0]);
int max = min;
int pal = Convert.ToInt32(lineSplit[1]);
int index = 0;
if (int.TryParse(tableName, out index))
overrides.Add(new Palette(min, max, pal));
else
entries.Add(new Palette(min, max, pal));
}
}
reader.Close();
}
}
}
return entries.Count;
}
public static ColorPalette FromArchive(string file, Archive archive)
{
if (!archive.Contains(file)) return null;
return FromRawData(archive.ExtractFile(file));
}
public Bitmap RenderMap(Map map, Tileset tiles, PaletteTable tileTable, PaletteTable wallTable, Archive wallSource)
{
int sxs = selectionXStart;
int sys = selectionYStart;
int sxe = selectionXEnd;
int sye = selectionYEnd;
int xMin = sxs < sxe ? sxs : sxe;
int yMin = sys < sye ? sys : sye;
int xMax = sxs > sxe ? sxs : sxe;
int yMax = sys > sye ? sys : sye;
Bitmap mapImage = new Bitmap(displaywidth, displayheight);
if (map == null) return mapImage;
Graphics g = Graphics.FromImage(mapImage);
int xOrigin = ((mapImage.Width / 2) - 1) - Tileset.TileWidth / 2 + 1 - hscroll;
int yOrigin = -vscroll;
bool[,] collision = null;
if (tabMap)
{
collision = new bool[map.Width, map.Height];
}
int xMul = Tileset.TileWidth / 2;
int yxMultiplier = (Tileset.TileHeight + 1) / 2;
if (bgShow)
{
for (int y = 0; y < map.Height; y++)
{
for (int x = 0; x < map.Width; x++)
{
int xd = xOrigin + x * xMul;
int yd = yOrigin + x * yxMultiplier;
if (xd >= -Tileset.TileWidth && yd >= -Tileset.TileHeight && xd < displaywidth && yd < displayheight)
{
int floor = map[x, y].FloorTile;
bool showSelection = false;
if (editMode == 0 || editMode == 3)
{
if (clickmode == 0 && selection != null && MouseHoverX != -1)
{
int selectionHeight = selection.Length / selectionWidth;
if (x >= MouseHoverX && x < MouseHoverX + selectionWidth && y >= MouseHoverY && y < MouseHoverY + selectionHeight)
{
int _x = x - MouseHoverX;
int _y = y - MouseHoverY;
floor = selection[_x + _y * selectionWidth].FloorTile;
showSelection = true;
}
}
}
if (floor > 0) floor -= 1;
if (!cachedFloor.ContainsKey(floor))
{
if (floor >= 0 && floor < tiles.TileCount)
{
Bitmap floorTile = RenderTile(tiles[floor], tileTable[floor + 2]);
cachedFloor.Add(floor, floorTile);
}
}
Bitmap thisTile = cachedFloor[floor];
if (editMode == 0 || editMode == 3)
{
if (showSelection || (selectionXStart != -1 && x >= xMin && x <= xMax && y >= yMin && y <= yMax))
{
if (!cachedFloorLight.ContainsKey(floor))
{
if (floor >= 0 && floor < tiles.TileCount)
{
thisTile = RenderTile(tiles[floor], tileTable[floor + 2]);
for (int yy = 0; yy < thisTile.Height; yy++)
{
for (int xx = 0; xx < thisTile.Width; xx++)
{
Color c = thisTile.GetPixel(xx, yy);
int colorR = c.R + 25;
if (colorR > 255)
colorR = 255;
int colorG = c.G + 25;
if (colorG > 255)
colorG = 255;
int colorB = c.B + 50;
if (colorB > 255)
colorB = 255;
if (c.R != 0 || c.G != 0 || c.B != 0)
thisTile.SetPixel(xx, yy, Color.FromArgb(colorR, colorG, colorB));
}
}
cachedFloorLight.Add(floor, thisTile);
}
}
else
{
thisTile = cachedFloorLight[floor];
}
}
}
g.DrawImageUnscaled(thisTile,
xd,
yd);
}
}
xOrigin -= xMul;
yOrigin += yxMultiplier;
}
}
xOrigin = ((mapImage.Width / 2) - 1) - Tileset.TileWidth / 2 + 1 - hscroll;
yOrigin = -vscroll;
int yAdd = -150 + (Tileset.TileHeight + 1) / 2;
for (int y = 0; y < map.Height; y++)
{
for (int x = 0; x < map.Width; x++)
{
int xd = xOrigin + x * xMul;
int yd = yOrigin + (x + 1) * yxMultiplier + yAdd;
if (xd >= -Tileset.TileWidth && yd >= -200 && xd < displaywidth && yd < displayheight + 200)
{
int leftWall = map[x, y].LeftWall;
if (fg1Show)
{
bool showSelection = false;
if (editMode == 1 || editMode == 3 || editMode == 4)
{
if (clickmode == 0 && selection != null && MouseHoverX != -1)
{
int selectionHeight = selection.Length / selectionWidth;
if (x >= MouseHoverX && x < MouseHoverX + selectionWidth && y >= MouseHoverY && y < MouseHoverY + selectionHeight)
{
int _x = x - MouseHoverX;
int _y = y - MouseHoverY;
int _leftWall = selection[_x + _y * selectionWidth].LeftWall;
if (_leftWall > 0 || drawEmptyWalls)
{
leftWall = _leftWall;
showSelection = true;
}
}
}
}
if (leftWall >= 13)
{
if (!cachedWalls.ContainsKey(leftWall))
{
HPF hpf = HPF.FromArchive("stc" + leftWall.ToString().PadLeft(5, '0') + ".hpf", true, wallSource);
Bitmap wall = RenderImage(hpf, wallTable[leftWall + 1]);
cachedWalls.Add(leftWall, wall);
}
Bitmap thisTile = cachedWalls[leftWall];
if (editMode == 1 || editMode == 3 || editMode == 4)
{
if (showSelection || (selectionXStart != -1 && x >= xMin && x <= xMax && y >= yMin && y <= yMax))
{
if (!cachedWallsLight.ContainsKey(leftWall))
{
HPF hpf = HPF.FromArchive("stc" + leftWall.ToString().PadLeft(5, '0') + ".hpf", true, wallSource);
thisTile = RenderImage(hpf, wallTable[leftWall + 1]);
for (int yy = 0; yy < thisTile.Height; yy++)
{
for (int xx = 0; xx < thisTile.Width; xx++)
{
Color c = thisTile.GetPixel(xx, yy);
int colorR = c.R + 25;
if (colorR > 255) colorR = 255;
int colorG = c.G + 25;
if (colorG > 255) colorG = 255;
int colorB = c.B + 50;
if (colorB > 255) colorB = 255;
if (c.R != 0 || c.G != 0 || c.B != 0) thisTile.SetPixel(xx, yy, Color.FromArgb(colorR, colorG, colorB));
}
}
cachedWallsLight.Add(leftWall, thisTile);
}
else
{
thisTile = cachedWallsLight[leftWall];
}
}
}
if ((leftWall % 10000) > 1)
{
int xleft = xOrigin + x * xMul;
int yleft = yOrigin + (x + 1) * yxMultiplier -
thisTile.Height +
(Tileset.TileHeight + 1) / 2;
if (transparency && leftWall > 0 && leftWall - 1 < sotp.Length && (sotp[leftWall - 1] & 0x80) == 0x80)
{
for (int yy = 0; yy < thisTile.Height; yy++)
{
for (int xx = 0; xx < thisTile.Width; xx++)
{
int origX = xleft + xx;
int origY = yleft + yy;
if (origX >= 0 && origX < mapImage.Width && origY >= 0 && origY < mapImage.Height)
{
Color newC = thisTile.GetPixel(xx, yy);
if (newC.R != 0 || newC.G != 0 || newC.B != 0)
{
Color origC = mapImage.GetPixel(origX, origY);
int _r = origC.R + newC.R;
if (_r > 255) _r = 255;
int _g = origC.G + newC.G;
if (_g > 255) _g = 255;
int _b = origC.B + newC.B;
if (_b > 255) _b = 255;
Color combined = Color.FromArgb(_r, _g, _b);
mapImage.SetPixel(xleft + xx, yleft + yy, combined);
}
}
}
}
}
else
{
g.DrawImageUnscaled(thisTile, xleft, yleft);
}
}
}
}
if (tabMap && leftWall > 0 && leftWall - 1 < sotp.Length && sotp[leftWall - 1] == 0x0F)
{
collision[x, y] = true;
}
int rightWall = map[x, y].RightWall;
if (fg2Show)
{
bool showSelection = false;
if (editMode == 2 || editMode == 3 || editMode == 4)
{
if (clickmode == 0 && selection != null && MouseHoverX != -1)
{
int selectionHeight = selection.Length / selectionWidth;
if (x >= MouseHoverX && x < MouseHoverX + selectionWidth && y >= MouseHoverY && y < MouseHoverY + selectionHeight)
{
int _x = x - MouseHoverX;
int _y = y - MouseHoverY;
int _rightWall = selection[_x + _y * selectionWidth].RightWall;
if (_rightWall > 0 || drawEmptyWalls)
{
rightWall = _rightWall;
showSelection = true;
}
}
}
}
if (rightWall >= 13)
{
if (!cachedWalls.ContainsKey(rightWall))
{
HPF hpf = HPF.FromArchive("stc" + rightWall.ToString().PadLeft(5, '0') + ".hpf", true, wallSource);
Bitmap wall = RenderImage(hpf, wallTable[rightWall + 1]);
cachedWalls.Add(rightWall, wall);
}
Bitmap thisTile = cachedWalls[rightWall];
if (editMode == 2 || editMode == 3 || editMode == 4)
{
if (showSelection || (selectionXStart != -1 && x >= xMin && x <= xMax && y >= yMin && y <= yMax))
{
if (!cachedWallsLight.ContainsKey(rightWall))
{
HPF hpf = HPF.FromArchive("stc" + rightWall.ToString().PadLeft(5, '0') + ".hpf", true, wallSource);
thisTile = RenderImage(hpf, wallTable[rightWall + 1]);
for (int yy = 0; yy < thisTile.Height; yy++)
{
for (int xx = 0; xx < thisTile.Width; xx++)
{
Color c = thisTile.GetPixel(xx, yy);
int colorR = c.R + 25;
if (colorR > 255) colorR = 255;
int colorG = c.G + 25;
if (colorG > 255) colorG = 255;
int colorB = c.B + 50;
if (colorB > 255) colorB = 255;
if (c.R != 0 || c.G != 0 || c.B != 0) thisTile.SetPixel(xx, yy, Color.FromArgb(colorR, colorG, colorB));
}
}
cachedWallsLight.Add(rightWall, thisTile);
}
else
{
thisTile = cachedWallsLight[rightWall];
}
}
}
if ((rightWall % 10000) > 1)
{
int xright = xOrigin + (x + 1) * xMul;
int yright = yOrigin + (x + 1) * yxMultiplier - thisTile.Height + (Tileset.TileHeight + 1) / 2;
if (transparency && rightWall > 0 && rightWall - 1 < sotp.Length && (sotp[rightWall - 1] & 0x80) == 0x80)
{
for (int yy = 0; yy < thisTile.Height; yy++)
{
for (int xx = 0; xx < thisTile.Width; xx++)
{
int origX = xright + xx;
int origY = yright + yy;
if (origX >= 0 && origX < mapImage.Width && origY >= 0 && origY < mapImage.Height)
{
Color origC = mapImage.GetPixel(origX, origY);
Color newC = thisTile.GetPixel(xx, yy);
int _r = origC.R + newC.R;
if (_r > 255) _r = 255;
int _g = origC.G + newC.G;
if (_g > 255) _g = 255;
int _b = origC.B + newC.B;
if (_b > 255) _b = 255;
Color combined = Color.FromArgb(_r, _g, _b);
mapImage.SetPixel(xright + xx, yright + yy, combined);
}
}
}
}
else
{
g.DrawImageUnscaled(thisTile, xright, yright);
}
}
}
}
if (tabMap && rightWall > 0 && rightWall - 1 < sotp.Length && sotp[rightWall - 1] == 0x0F)
{
collision[x, y] = true;
}
}
}
xOrigin -= xMul;
yOrigin += yxMultiplier;
}
if (tabMap)
{
xOrigin = ((mapImage.Width / 2) - 1) - Tileset.TileWidth / 2 + 1 - hscroll;
yOrigin = -vscroll;
for (int y = 0; y < map.Height; y++)
{
for (int x = 0; x < map.Width; x++)
{
if (tabMap && collision[x, y])
{
int xDraw = xOrigin + x * Tileset.TileWidth / 2 + Tileset.TileWidth / 2;
int yDraw = yOrigin + x * (Tileset.TileHeight + 1) / 2;
PointF[] ps = new PointF[4];
ps[0] = new PointF(xDraw, yDraw);
ps[1] = new PointF(xDraw + Tileset.TileWidth / 2, yDraw + Tileset.TileHeight / 2);
ps[2] = new PointF(xDraw, yDraw + Tileset.TileHeight);
ps[3] = new PointF(xDraw - Tileset.TileWidth / 2, yDraw + Tileset.TileHeight / 2);
g.FillPolygon((new SolidBrush(Color.FromArgb(128, 255, 255, 255))), ps);
}
}
xOrigin -= Tileset.TileWidth / 2;
yOrigin += (Tileset.TileHeight + 1) / 2;
}
}
if (drawGridLines)
{
xOrigin = ((mapImage.Width / 2) - 1) - hscroll;
yOrigin = -vscroll;
for (int y = 0; y < map.Height; y++)
{
int xPos = xOrigin - y * (Tileset.TileWidth) / 2;
int yPos = (int)(yOrigin + y * ((Tileset.TileHeight + 1) / 2)) - 1;
int xEnd = xPos + (map.Width - 1) * (Tileset.TileWidth + 1) / 2;
int yEnd = (int)(yPos + (map.Height - 1) * (Tileset.TileHeight + 1.5) / 2);
g.DrawLine(new Pen(new SolidBrush(Color.Green)), xPos, yPos, xEnd, yEnd);
}
for (int x = 0; x < map.Width; x++)
{
int xPos = xOrigin + x * (Tileset.TileWidth) / 2;
int yPos = (int)(yOrigin + x * ((Tileset.TileHeight + 1) / 2)) - 1;
int xEnd = xPos - (map.Width - 1) * (Tileset.TileWidth + 1) / 2;
int yEnd = (int)(yPos + (map.Height - 1) * (Tileset.TileHeight + 1.5) / 2);
g.DrawLine(new Pen(new SolidBrush(Color.Green)), xPos, yPos, xEnd, yEnd);
}
}
g.Dispose();
GC.Collect();
return mapImage;
}