public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var bitmap = new BitmapBits(225, 289);
bitmap.DrawSine(LevelData.ColorWhite, 112, -32, 112, 128, 320);
return(new Sprite(bitmap, -112, -144));
}
private void DrawPreview()
{
if (!showPreview || suppressDraw)
{
return;
}
List <ObjectInfo> selected = objectList;
if (showOnlySelectedObjectsToolStripMenuItem.Checked)
{
selected = objectListView.CheckedIndices.OfType <int>().Select(a => objectList[a]).ToList();
if (objectListView.SelectedIndices.Count > 0 && !selected.Contains(objectList[objectListView.SelectedIndices[0]]))
{
selected.Add(objectList[objectListView.SelectedIndices[0]]);
}
LevelData.Objects = new List <ObjectEntry>(selected.Where(a => a.Entry is ObjectEntry).Select(a => (ObjectEntry)a.Entry));
LevelData.Rings = new List <RingEntry>(selected.Where(a => a.Entry is RingEntry).Select(a => (RingEntry)a.Entry));
}
Point camera = new Point(previewPanel.HScrollValue, previewPanel.VScrollValue);
Rectangle dispRect = new Rectangle(camera.X, camera.Y, previewPanel.PanelWidth, previewPanel.PanelHeight);
BitmapBits img8 = LevelData.DrawForeground(dispRect, true, true, true, true, true, false, false, false);
Bitmap bmp = img8.ToBitmap(LevelData.BmpPal).To32bpp();
Graphics gfx = Graphics.FromImage(bmp);
gfx.SetOptions();
if (showOverlaysToolStripMenuItem.Checked)
{
foreach (ObjectInfo obj in selected)
{
Rectangle bnd = obj.Entry.Bounds;
if (!dispRect.IntersectsWith(bnd))
{
continue;
}
bnd.Offset(-camera.X, -camera.Y);
SolidBrush brush = null;
switch (obj.Source)
{
case Source.A:
brush = brushA;
break;
case Source.B:
brush = brushB;
break;
}
if (brush != null)
{
gfx.FillRectangle(brush, bnd);
}
if (objectListView.SelectedIndices.Count > 0 && obj == objectList[objectListView.SelectedIndices[0]])
{
gfx.FillRectangle(selectionBrush, bnd);
bnd.Width--; bnd.Height--;
gfx.DrawRectangle(selectionPen, bnd);
}
}
}
previewPanel.PanelGraphics.DrawImage(bmp, 0, 0, previewPanel.PanelWidth, previewPanel.PanelHeight);
}
public static Sprite LoadChaotixSprite(byte[] file, int addr)
{
short left = ByteConverter.ToInt16(file, addr);
addr += 2;
short right = ByteConverter.ToInt16(file, addr);
addr += 2;
sbyte top = (sbyte)file[addr];
addr += 2;
sbyte bottom = (sbyte)file[addr];
addr += 2;
BitmapBits bmp = new BitmapBits(right - left + 1, bottom - top + 1);
sbyte y;
while (true)
{
sbyte xl = (sbyte)file[addr++];
sbyte xr = (sbyte)file[addr++];
if (xl == 0 && xr == 0)
{
break;
}
y = (sbyte)file[addr];
addr += 2;
Array.Copy(file, addr, bmp.Bits, bmp.GetPixelIndex(xl - left, y - top), xr - xl);
addr += xr - xl;
}
return(new Sprite(bmp, new Point(left, top)));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var bitmap = new BitmapBits(64, 288);
bitmap.DrawRectangle(LevelData.ColorWhite, 0, 0, 63, 287);
return(new Sprite(bitmap, -32, -32));
}
public override void Init(ObjectData data)
{
img = ObjectHelper.UnknownObject;
List <Sprite> sprs = new List <Sprite>();
int left = -208;
int right = 208;
int top = 0;
int bottom = 0;
for (int i = 0; i < Obj06_CosineTable.Length; i++)
{
top = Math.Min(Obj06_CosineTable[i], top);
bottom = Math.Max(Obj06_CosineTable[i], bottom);
}
Point offset = new Point(left, top);
BitmapBits bmp = new BitmapBits(right - left, bottom - top);
for (int x = 0; x < 0x1A0; x++)
{
int y = Obj06_CosineTable[x] - top;
if (x < bmp.Width & y >= 0 & y < bmp.Height)
{
bmp[x, y] = 0x1C;
}
}
sprs.Add(new Sprite(bmp, offset));
offset = new Point(-192, 0);
bmp = new BitmapBits(0x180, 53);
bmp.DrawLine(0x1C, 192, 0, 192, 52);
bmp.DrawLine(0x1C, 0, 52, 0x180, 52);
sprs.Add(new Sprite(bmp, offset));
sprs.Add(img);
sprite = new Sprite(sprs.ToArray());
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var count = (obj.SubType >> 4) & 7;
var range = ((obj.SubType & 0x0F) + 4) << 4;
var bitmap = new BitmapBits(17, range);
bitmap.DrawLine(LevelData.ColorWhite, 0, 0, 16, 0);
bitmap.DrawLine(LevelData.ColorWhite, 8, 0, 8, range);
var overlay = new Sprite(bitmap, -8 - count * 16, -range);
for (var index = 0; index < count; index++)
{
overlay = new Sprite(new Sprite(overlay, 32, 0), overlay);
}
if (obj.XFlip && obj.SubType >= 0x80)
{
bitmap = new BitmapBits(97, 1);
bitmap.DrawLine(LevelData.ColorWhite, 0, 0, 96, 0);
overlay = new Sprite(new Sprite(bitmap, -48, 0), overlay);
}
return(overlay);
}
public static void Init()
{
using (Bitmap tmp = new Bitmap(1, 1, PixelFormat.Format8bppIndexed))
Palette = tmp.Palette;
Bitmap[] bmplist = { Properties.Resources.red, Properties.Resources.blue, Properties.Resources.bumper, Properties.Resources.ring, Properties.Resources.yellow };
int palind = 1;
for (int i = 0; i < bmplist.Length; i++)
{
bmplist[i].Palette.Entries.CopyTo(Palette.Entries, palind);
BitmapBits bmp = new BitmapBits(bmplist[i]);
bmp.IncrementIndexes(palind);
SphereBmps[(SphereType)(i + 1)] = bmp;
palind += 16;
}
Palette.Entries[0] = Palette.Entries[1] = Color.Transparent;
bmplist = new[] { Properties.Resources.north, Properties.Resources.west, Properties.Resources.south, Properties.Resources.east };
bmplist[0].Palette.Entries.CopyTo(Palette.Entries, palind);
for (int i = 0; i < bmplist.Length; i++)
{
BitmapBits bmp = new BitmapBits(bmplist[i]);
bmp.IncrementIndexes(palind);
StartBmps[i] = bmp;
}
}
public static BitmapBits DrawLayout(SphereType?[,] layout, int gridsize)
{
int width = layout.GetLength(0);
int height = layout.GetLength(1);
int off = (gridsize - 24) / 2;
BitmapBits layoutbmp = new BitmapBits(width * gridsize, height * gridsize);
for (int y = -gridsize / 2; y < layoutbmp.Height; y += gridsize * 2)
{
for (int x = -gridsize / 2; x < layoutbmp.Width; x += gridsize * 2)
{
layoutbmp.FillRectangle(1, x, y, gridsize, gridsize);
}
}
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
SphereType?sp = layout[x, y];
if (sp.HasValue && sp.Value != SphereType.Empty)
{
layoutbmp.DrawBitmapComposited(SphereBmps[sp.Value], x * gridsize + off, y * gridsize + off);
}
}
}
return(layoutbmp);
}
public override void Init(ObjectData data)
{
properties = new PropertySpec[1];
subtypes = new ReadOnlyCollection <byte>(new byte[0]);
unknownSprite = BuildFlippedSprites(ObjectHelper.UnknownObject);
properties[0] = new PropertySpec("Path ID", typeof(int), "Extended",
"The path information associated with this object.", null,
(obj) => obj.SubType >> 1,
(obj, value) => obj.SubType = (byte)((int)value << 1));
startCoords = new Point[4];
paths = new Sprite[4];
BuildPathsCoords(0, 0x1390, 0x2D0, 0x1230, 0x2D0, 0x1230, 0x300);
BuildPathsCoords(1, 0x13F0, 0x2D0, 0x1560, 0x2D0, 0x1560, 0x280);
BuildPathsCoords(2, 0x2090, 0x650, 0x2030, 0x650, 0x2030, 0x680);
BuildPathsCoords(3, 0x20F0, 0x650, 0x21E0, 0x650, 0x21E0, 0x600);
var bitmap = new BitmapBits(129, 401);
bitmap.DrawRectangle(LevelData.ColorWhite, 0, 0, 128, 32);
bitmap.DrawLine(LevelData.ColorWhite, 64, 32, 64, 400);
bitmap.DrawLine(LevelData.ColorBlack, 65, 32, 65, 400);
overlay = new Sprite(bitmap, -64, -16);
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var routine = obj.SubType & 0x0F;
if (routine == 0 || routine > numRoutines)
{
return(null);
}
if (routine == 3)
{
var bitmap = new BitmapBits(33, 1);
bitmap.DrawRectangle(LevelData.ColorWhite, 0, 0, 32, 0);
return(new Sprite(bitmap));
}
else
{
var bounds = GetBounds(obj);
var bitmap = new BitmapBits(bounds.Width, bounds.Height);
bitmap.DrawRectangle(LevelData.ColorWhite, 0, 0, bounds.Width - 1, bounds.Height - 1);
var xoffset = routine == 2 && !obj.XFlip ? blockSize : 0;
var yoffset = routine == 1 && !obj.YFlip ? blockSize : 0;
return(new Sprite(bitmap, xoffset - (bounds.Width / 2), yoffset - (bounds.Height / 2)));
}
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var routine = obj.SubType & 0x0F;
var frame = obj.SubType >> 4;
if (routine == 0 || routine > 6 || frame >= sprites.Length)
{
return(null);
}
var length = 64 << ((routine - 1) % 3);
var adjust = frame == 0 ? 0 : frame == 1 ^ obj.YFlip ? 16 : -16;
if (routine > 3)
{
var offset = (obj.XFlip ? length : -length) / 2;
var bitmap = new BitmapBits(64, 128);
bitmap.DrawRectangle(LevelData.ColorWhite, 0, 0, 63, 127);
return(new Sprite(bitmap, -32, offset + adjust - 64));
}
else
{
var bitmap = new BitmapBits(length, 1);
bitmap.DrawLine(LevelData.ColorWhite, 0, 0, length, 0);
return(new Sprite(bitmap, -length / 2, adjust));
}
}
public override void Init(ObjectData data)
{
properties = new PropertySpec[1];
subtypes = new ReadOnlyCollection <byte>(new byte[0]);
sprite = BuildFlippedSprites(ObjectHelper.UnknownObject);
overlay = new Sprite[2];
var bitmap = new BitmapBits(161, 161);
bitmap.DrawLine(LevelData.ColorWhite, 0, 32, 32, 0);
bitmap.DrawLine(LevelData.ColorWhite, 32, 0, 160, 128);
bitmap.DrawLine(LevelData.ColorWhite, 0, 32, 128, 160);
bitmap.DrawLine(LevelData.ColorWhite, 128, 160, 160, 128);
overlay[0] = new Sprite(bitmap, -80, -80);
overlay[1] = new Sprite(overlay[0], true, false);
properties[0] = new PropertySpec("Direction", typeof(int), "Extended",
"The object's orientation.", null, new Dictionary <string, int>
{
{ "Left", 0 },
{ "Right", 1 }
},
(obj) => obj.SubType == 0 ? 1 : 0,
(obj, value) => obj.SubType = (byte)((int)value == 0 ? 1 : 0));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var height = (obj.SubType & 0x70) == 0 ? 0x80 : 0x100;
var overlay = new BitmapBits(16, height);
overlay.DrawRectangle(LevelData.ColorWhite, 0, 0, 15, height - 1);
return(new Sprite(overlay, -8, -height / 2));
}
public override Sprite GetSprite(ObjectEntry obj)
{
byte subtype = obj.SubType;
BitmapBits bits = new BitmapBits(imgs[imgindex(subtype)].Image);
bits.Flip(obj.XFlip, obj.YFlip);
return(new Sprite(bits, new Point(obj.X + imgs[imgindex(subtype)].Offset.X, obj.Y + imgs[imgindex(subtype)].Offset.Y)));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var length = (obj.SubType << 3) + 16;
var bitmap = new BitmapBits(16, length);
bitmap.DrawRectangle(LevelData.ColorWhite, 0, 0, 15, length - 1);
return(new Sprite(bitmap, -8, 8 - length));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var width = obj.SubType << 4;
var overlay = new BitmapBits(width, height);
overlay.DrawRectangle(LevelData.ColorWhite, 0, 0, width - 1, height - 1);
return(new Sprite(overlay, -width / 2, -height / 2));
}
public override Sprite GetSprite(ObjectEntry obj)
{
byte subtype = obj.SubType;
if (obj.SubType > labels.Length) subtype = 0;
BitmapBits bits = new BitmapBits(imgs[subtype].Image);
bits.Flip(obj.XFlip, obj.YFlip);
return new Sprite(bits, new Point(obj.X + imgs[subtype].Offset.X, obj.Y + imgs[subtype].Offset.Y));
}
private Sprite Square(int radius)
{
var length = radius * 2;
var overlay = new BitmapBits(length + 1, length + 1);
overlay.DrawRectangle(LevelData.ColorWhite, 0, 0, length, length);
return(new Sprite(overlay, -radius, -radius));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
if (obj.SubType == 0) return null;
var bitmap = new BitmapBits(obj.SubType, 1);
bitmap.DrawLine(LevelData.ColorWhite, 0, 0, obj.SubType, 0);
return new Sprite(bitmap, -obj.SubType / 2, obj.YFlip ? -9 : 8);
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var bounds = GetBounds(obj);
var bitmap = new BitmapBits(bounds.Width, bounds.Height);
bitmap.DrawRectangle(LevelData.ColorWhite, 0, 0, bounds.Width - 1, bounds.Height - 1);
return(new Sprite(bitmap, -bounds.Width / 2, -bounds.Height / 2));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var height = obj.SubType << 4;
var bitmap = new BitmapBits(128, height);
bitmap.DrawRectangle(LevelData.ColorWhite, 0, 0, 127, height - 1);
return(new Sprite(bitmap, -64, -height / 2));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var width = obj.SubType << 1;
var bitmap = new BitmapBits(width, 128);
bitmap.DrawRectangle(LevelData.ColorWhite, 0, 0, width - 1, 127);
return(new Sprite(bitmap, -width / 2, -64));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
int w = ((obj.SubType >> 4) + 1) * 16;
int h = ((obj.SubType & 0xF) + 1) * 16;
BitmapBits bmp = new BitmapBits(w, h);
bmp.DrawRectangle(LevelData.ColorWhite, 0, 0, w - 1, h - 1);
return(new Sprite(bmp, -(w / 2), -(h / 2)));
}
public override Sprite GetSprite(ObjectEntry obj)
{
int w = ((obj.SubType >> 4) + 1) * 16;
int h = ((obj.SubType & 0xF) + 1) * 16;
BitmapBits bmp = new BitmapBits(w, h);
bmp.DrawRectangle(0x1C, 0, 0, w - 1, h - 1);
return(new Sprite(new Sprite(bmp, new Point(-(w / 2), -(h / 2))), img));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var distance = (obj.SubType << 3) + 8;
var overlay = new BitmapBits(distance, 1);
overlay.DrawLine(LevelData.ColorWhite, 0, 0, distance, 0);
return(new Sprite(overlay));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var bounds = GetSprite(obj).Bounds;
var overlay = new BitmapBits(bounds.Size);
overlay.DrawRectangle(LevelData.ColorWhite, 0, 0, bounds.Width - 1, bounds.Height - 1);
return(new Sprite(overlay, bounds.X, bounds.Y));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var range = ((obj.SubType & 0x0F) + 8) << 4;
var overlay = new BitmapBits(17, range);
overlay.DrawLine(LevelData.ColorWhite, 0, 0, 16, 0);
overlay.DrawLine(LevelData.ColorWhite, 8, 0, 8, range);
return(new Sprite(overlay, -8, -range - 4));
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var width = 192 + ((obj.SubType & 1) << 7);
var bitmap = new BitmapBits(width, 40);
bitmap.DrawRectangle(LevelData.ColorWhite, 0, 0, width - 1, 39);
return(new Sprite(bitmap, -width / 2, 32));
}
public Sprite(IEnumerable <Sprite> sprites)
{
List <Sprite> sprlst = new List <Sprite>(sprites);
int left = 0;
int right = 0;
int top = 0;
int bottom = 0;
bool first = true;
foreach (Sprite spr in sprlst)
{
if (spr.Image != null)
{
if (first)
{
left = spr.Left;
right = spr.Right;
top = spr.Top;
bottom = spr.Bottom;
first = false;
}
else
{
left = Math.Min(spr.Left, left);
right = Math.Max(spr.Right, right);
top = Math.Min(spr.Top, top);
bottom = Math.Max(spr.Bottom, bottom);
}
}
}
Offset = new Point(left, top);
Image = new BitmapBits(right - left, bottom - top);
for (int i = 0; i < sprlst.Count; i++)
{
if (sprlst[i].Image != null)
{
bool comp = false;
for (int j = 0; j < i; j++)
{
if (sprlst[j].Image != null && sprlst[i].Bounds.IntersectsWith(sprlst[j].Bounds))
{
comp = true;
break;
}
}
if (comp)
{
Image.DrawBitmapComposited(sprlst[i].Image, new Point(sprlst[i].X - left, sprlst[i].Y - top));
}
else
{
Image.DrawBitmap(sprlst[i].Image, new Point(sprlst[i].X - left, sprlst[i].Y - top));
}
}
}
}
public override Sprite GetSprite(ObjectEntry obj)
{
int w = ((obj.SubType >> 4) + 1) * 16;
int h = ((obj.SubType & 0xF) + 1) * 16;
BitmapBits bmp = new BitmapBits(w, h);
bmp.DrawRectangle(0x1C, 0, 0, w - 1, h - 1);
Sprite spr = new Sprite(new Sprite(bmp, new Point(-(w / 2), -(h / 2))), img);
spr.Offset = new Point(spr.X + obj.X, spr.Y + obj.Y);
return spr;
}
public override Sprite GetDebugOverlay(ObjectEntry obj)
{
var height = obj.SubType << 4;
var bitmap = new BitmapBits(97, height + 1);
bitmap.DrawSine(LevelData.ColorWhite, 48, -48, 48, 192, height + 48);
bitmap.DrawSine(LevelData.ColorWhite, 48, -144, 48, 192, height + 144);
return(new Sprite(bitmap, -48, 0));
}
public static BitmapBits DrawLayout(LayoutData layout, bool shownum)
{
BitmapBits layoutbmp = DrawLayout(layout.Layout, shownum);
if (layout.StartPosition != null)
{
layoutbmp.DrawBitmapComposited(StartPosBmp, layout.StartPosition.X - 736 - (StartPosBmp.Width / 2), layout.StartPosition.Y - 688 - (StartPosBmp.Height / 2));
}
return(layoutbmp);
}
public override void Init(ObjectData data)
{
if (data.Art != null)
{
MultiFileIndexer<byte> art = new MultiFileIndexer<byte>();
foreach (FileInfo file in data.Art)
art.AddFile(new List<byte>(ObjectHelper.OpenArtFile(file.Filename, data.ArtCompression)), file.Offset);
byte[] artfile = art.ToArray();
if (data.MapFile != null)
{
if (data.DPLCFile != null)
spr = ObjectHelper.MapDPLCToBmp(artfile, ObjectHelper.OpenArtFile(data.MapFile, data.MapCompression), data.MapVersion, ObjectHelper.OpenArtFile(data.DPLCFile, data.DPLCCompression), data.MapVersion, data.Frame, data.Palette);
else
spr = ObjectHelper.MapToBmp(artfile, ObjectHelper.OpenArtFile(data.MapFile, data.MapCompression), data.Frame, data.Palette, data.MapVersion);
}
else if (data.MapFileAsm != null)
{
if (data.MapAsmLabel != null)
{
if (data.DPLCFileAsm != null)
spr = ObjectHelper.MapASMDPLCToBmp(artfile, data.MapFileAsm, data.MapAsmLabel, data.MapVersion, data.DPLCFileAsm, data.DPLCAsmLabel, data.MapVersion, data.Palette);
else
spr = ObjectHelper.MapASMToBmp(artfile, data.MapFileAsm, data.MapAsmLabel, data.Palette, data.MapVersion);
}
else
{
if (data.DPLCFileAsm != null)
spr = ObjectHelper.MapASMDPLCToBmp(artfile, data.MapFileAsm, data.MapVersion, data.DPLCFileAsm, data.MapVersion, data.Frame, data.Palette);
else
spr = ObjectHelper.MapASMToBmp(artfile, data.MapFileAsm, data.Frame, data.Palette, data.MapVersion);
}
}
else
spr = ObjectHelper.UnknownObject;
if (data.Offset != Size.Empty)
spr.Offset = spr.Offset + data.Offset;
}
else if (data.Image != null)
{
BitmapBits img = new BitmapBits(new Bitmap(data.Image));
spr = new Sprite(img, new Point(data.Offset));
}
else if (data.Sprite > -1)
spr = ObjectHelper.GetSprite(data.Sprite);
else
spr = ObjectHelper.UnknownObject;
spacing = int.Parse(data.CustomProperties.GetValueOrDefault("spacing", "24"), System.Globalization.NumberStyles.Integer, System.Globalization.NumberFormatInfo.InvariantInfo);
}
public override Sprite GetSprite(ObjectEntry obj)
{
BitmapBits bits = new BitmapBits(SubtypeImage(obj.SubType).Image);
bits.Flip(obj.XFlip, obj.YFlip);
return new Sprite(bits, new Point(obj.X + SubtypeImage(obj.SubType).X, obj.Y + SubtypeImage(obj.SubType).Y));
}
public override Sprite GetSprite(ObjectEntry obj)
{
BitmapBits bits = new BitmapBits(imgs[(obj.SubType & 0xE) << 1].Image);
bits.Flip(obj.XFlip, obj.YFlip);
return new Sprite(bits, new Point(obj.X + imgs[(obj.SubType & 0xE) << 1].X, obj.Y + imgs[(obj.SubType & 0xE) << 1].Y));
}
public override Sprite GetSprite(ObjectEntry obj)
{
int frame = obj.SubType >> 4;
if (frame > 5) frame = 0;
BitmapBits bits = new BitmapBits(imgs[frame].Image);
bits.Flip(obj.XFlip, obj.YFlip);
return new Sprite(bits, new Point(obj.X + imgs[frame].X, obj.Y + imgs[frame].Y));
}
public override void Init(ObjectData data)
{
List<byte> tmpartfile = new List<byte>();
tmpartfile.AddRange(ObjectHelper.OpenArtFile("Common/pathswapper-art.bin", CompressionType.Nemesis));
byte[] mapfile = System.IO.File.ReadAllBytes("../mappings/sprite/obj03.bin");
byte[] artfile1 = tmpartfile.ToArray();
img = ObjectHelper.MapToBmp(artfile1, mapfile, 0, 0);
Point off;
BitmapBits im;
Point pos;
Size delta;
for (int i = 0; i < 32; i++)
{
byte[] artfile = tmpartfile.GetRange(((i & 0x1C) << 5), 128).ToArray();
BitmapBits tempim = ObjectHelper.MapToBmp(artfile, mapfile, (i & 4), 0).Image;
if ((i & 4) != 0)
{
im = new BitmapBits(tempim.Width * (1 << (i & 3)), tempim.Height);
delta = new Size(tempim.Width, 0);
}
else
{
im = new BitmapBits(tempim.Width, tempim.Height * (1 << (i & 3)));
delta = new Size(0, tempim.Height);
}
pos = new Point(0, 0);
off = new Point(-(im.Width / 2), -(im.Height / 2));
for (int j = 0; j < (1 << (i & 3)); j++)
{
im.DrawBitmap(tempim, pos);
pos = pos + delta;
}
imgs.Add(new Sprite(im, off));
}
}
public override Sprite GetSprite(ObjectEntry obj)
{
BitmapBits bits = new BitmapBits(imgs[imgindex(obj.SubType)].Image);
bits.Flip(obj.XFlip, obj.YFlip);
return new Sprite(bits, new Point(obj.X + imgs[imgindex(obj.SubType)].Offset.X, obj.Y + imgs[imgindex(obj.SubType)].Offset.Y));
}
public override void Init(ObjectData data)
{
img = ObjectHelper.UnknownObject;
List<Sprite> sprs = new List<Sprite>();
int left = -208;
int right = 208;
int top = 0;
int bottom = 0;
for (int i = 0; i < Obj06_CosineTable.Length; i++)
{
top = Math.Min(Obj06_CosineTable[i], top);
bottom = Math.Max(Obj06_CosineTable[i], bottom);
}
Point offset = new Point(left, top);
BitmapBits bmp = new BitmapBits(right - left, bottom - top);
for (int x = 0; x < 0x1A0; x++)
{
int y = Obj06_CosineTable[x] - top;
if (x < bmp.Width & y >= 0 & y < bmp.Height)
bmp[x, y] = 0x1C;
}
sprs.Add(new Sprite(bmp, offset));
offset = new Point(-192, 0);
bmp = new BitmapBits(0x180, 53);
bmp.DrawLine(0x1C, 192, 0, 192, 52);
bmp.DrawLine(0x1C, 0, 52, 0x180, 52);
sprs.Add(new Sprite(bmp, offset));
sprs.Add(img);
sprite = new Sprite(sprs.ToArray());
}
