public ObjectData GetThingData(ushort id, ThingCategory category, bool singleFrameGroup)
{
ThingType thing = this.Things.GetThing(id, category);
if (thing == null)
{
return(null);
}
if (singleFrameGroup)
{
thing = ThingType.ToSingleFrameGroup(thing);
}
SpriteGroup spriteGroups = new SpriteGroup();
Console.WriteLine(thing.FrameGroupCount);
for (byte i = 0; i < thing.FrameGroupCount; i++)
{
FrameGroupType groupType = (FrameGroupType)i;
FrameGroup frameGroup = thing.GetFrameGroup(groupType);
int length = frameGroup.SpriteIDs.Length;
Sprite[] sprites = new Sprite[length];
for (int s = 0; s < length; s++)
{
sprites[s] = this.Sprites.GetSprite(frameGroup.SpriteIDs[s]);
}
spriteGroups.Add(groupType, sprites);
}
return(new ObjectData(thing, spriteGroups));
}
public SpriteSheet GetSpriteSheet(ushort id, ThingCategory category, FrameGroupType groupType)
{
ThingType thing = this.Things.GetThing(id, category);
if (thing == null)
{
return(null);
}
FrameGroup group = thing.GetFrameGroup(groupType);
int totalX = group.PatternZ * group.PatternX * group.Layers;
int totalY = group.Frames * group.PatternY;
int bitmapWidth = (totalX * group.Width) * Sprite.DefaultSize;
int bitmapHeight = (totalY * group.Height) * Sprite.DefaultSize;
int pixelsWidth = group.Width * Sprite.DefaultSize;
int pixelsHeight = group.Height * Sprite.DefaultSize;
Bitmap bitmap = new Bitmap(bitmapWidth, bitmapHeight, PixelFormat.Format32bppArgb);
Dictionary <int, Rect> rectList = new Dictionary <int, Rect>();
BitmapLocker lockBitmap = new BitmapLocker(bitmap);
lockBitmap.LockBits();
for (int f = 0; f < group.Frames; f++)
{
for (int z = 0; z < group.PatternZ; z++)
{
for (int y = 0; y < group.PatternY; y++)
{
for (int x = 0; x < group.PatternX; x++)
{
for (int l = 0; l < group.Layers; l++)
{
int index = group.GetTextureIndex(l, x, y, z, f);
int fx = (index % totalX) * pixelsWidth;
int fy = (int)(Math.Floor((decimal)(index / totalX)) * pixelsHeight);
rectList.Add(index, new Rect(fx, fy, pixelsWidth, pixelsHeight));
for (int w = 0; w < group.Width; w++)
{
for (int h = 0; h < group.Height; h++)
{
index = group.GetSpriteIndex(w, h, l, x, y, z, f);
int px = ((group.Width - w - 1) * Sprite.DefaultSize);
int py = ((group.Height - h - 1) * Sprite.DefaultSize);
uint spriteId = group.SpriteIDs[index];
lockBitmap.CopyPixels(this.Sprites.GetSpriteBitmap(spriteId), px + fx, py + fy);
}
}
}
}
}
}
}
lockBitmap.UnlockBits();
return(new SpriteSheet(bitmap, rectList));
}
public SpriteSheet GetSpriteSheet(FrameGroupType groupType)
{
FrameGroup frameGroup = this.GetFrameGroup(groupType);
if (frameGroup == null)
{
return(null);
}
Sprite[] sprites = this.sprites[groupType];
int totalX = frameGroup.PatternZ * frameGroup.PatternX * frameGroup.Layers;
int totalY = frameGroup.Frames * frameGroup.PatternY;
int bitmapWidth = (totalX * frameGroup.Width) * Sprite.DefaultSize;
int bitmapHeight = (totalY * frameGroup.Height) * Sprite.DefaultSize;
int pixelsWidth = frameGroup.Width * Sprite.DefaultSize;
int pixelsHeight = frameGroup.Height * Sprite.DefaultSize;
Bitmap bitmap = new Bitmap(bitmapWidth, bitmapHeight, PixelFormat.Format32bppArgb);
Dictionary <int, Rect> rectList = new Dictionary <int, Rect>();
BitmapLocker lockBitmap = new BitmapLocker(bitmap);
lockBitmap.LockBits();
for (int f = 0; f < frameGroup.Frames; f++)
{
for (int z = 0; z < frameGroup.PatternZ; z++)
{
for (int y = 0; y < frameGroup.PatternY; y++)
{
for (int x = 0; x < frameGroup.PatternX; x++)
{
for (int l = 0; l < frameGroup.Layers; l++)
{
int index = frameGroup.GetTextureIndex(l, x, y, z, f);
int fx = (index % totalX) * pixelsWidth;
int fy = (int)(Math.Floor((decimal)(index / totalX)) * pixelsHeight);
rectList.Add(index, new Rect(fx, fy, pixelsWidth, pixelsHeight));
for (int w = 0; w < frameGroup.Width; w++)
{
for (int h = 0; h < frameGroup.Height; h++)
{
index = frameGroup.GetSpriteIndex(w, h, l, x, y, z, f);
int px = (frameGroup.Width - w - 1) * Sprite.DefaultSize;
int py = (frameGroup.Height - h - 1) * Sprite.DefaultSize;
lockBitmap.CopyPixels(sprites[index].GetBitmap(), px + fx, py + fy);
}
}
}
}
}
}
}
lockBitmap.UnlockBits();
lockBitmap.Dispose();
return(new SpriteSheet(bitmap, rectList));
}
public Bitmap GetObjectImage(ushort id, ThingCategory category, FrameGroupType groupType)
{
ThingType thing = this.Things.GetThing(id, category);
if (thing == null)
{
return(null);
}
Bitmap bitmap = this.spriteCache.GetPicture(id, category);
if (bitmap != null)
{
return(bitmap);
}
FrameGroup group = thing.GetFrameGroup(groupType);
int width = Sprite.DefaultSize * group.Width;
int height = Sprite.DefaultSize * group.Height;
bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
BitmapLocker lockBitmap = new BitmapLocker(bitmap);
lockBitmap.LockBits();
byte layers = group.Layers;
byte x = 0;
if (category == ThingCategory.Outfit)
{
layers = 1;
x = (byte)(2 % group.PatternX);
}
// draw sprite
for (byte l = 0; l < layers; l++)
{
for (byte w = 0; w < group.Width; w++)
{
for (byte h = 0; h < group.Height; h++)
{
int index = group.GetSpriteIndex(w, h, l, x, 0, 0, 0);
uint spriteId = group.SpriteIDs[index];
int px = (group.Width - w - 1) * Sprite.DefaultSize;
int py = (group.Height - h - 1) * Sprite.DefaultSize;
lockBitmap.CopyPixels(this.Sprites.GetSpriteBitmap(spriteId), px, py);
}
}
}
lockBitmap.UnlockBits();
lockBitmap.Dispose();
this.spriteCache.SetPicture(id, category, bitmap);
return(bitmap);
}
public Sprite[] GetSprites(FrameGroupType groupType)
{
if (this.sprites.ContainsKey(groupType))
{
return(this.sprites[groupType]);
}
return(null);
}
public FrameGroup GetFrameGroup(FrameGroupType groupType)
{
if (FrameGroups.ContainsKey(groupType))
{
return(FrameGroups[groupType]);
}
return(null);
}
public Bitmap GetObjectImage(ThingType thing, FrameGroupType groupType)
{
if (thing != null)
{
return(this.GetObjectImage(thing.ID, thing.Category, groupType));
}
return(null);
}
public FrameGroup GetFrameGroup(ushort id, ThingCategory category, FrameGroupType groupType)
{
ThingType type = this.Things.GetThing(id, category);
if (type != null)
{
return(type.GetFrameGroup(groupType));
}
return(null);
}
public FrameGroup SetFrameGroup(FrameGroupType groupType, FrameGroup group)
{
if (groupType == FrameGroupType.Walking && (!FrameGroups.ContainsKey(FrameGroupType.Default) || FrameGroups.Count == 0))
{
FrameGroups.Add(FrameGroupType.Default, group);
}
if (!FrameGroups.ContainsKey(groupType))
{
FrameGroups.Add(groupType, group);
}
return(group);
}
public Bitmap GetObjectImage(ushort id, ThingCategory category, FrameGroupType groupType)
{
ThingType thing = this.Things.GetThing(id, category);
if (thing == null)
{
return null;
}
Bitmap bitmap = this.spriteCache.GetPicture(id, category);
if (bitmap != null)
{
return bitmap;
}
FrameGroup group = thing.GetFrameGroup(groupType);
int width = Sprite.DefaultSize * group.Width;
int height = Sprite.DefaultSize * group.Height;
bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
BitmapLocker lockBitmap = new BitmapLocker(bitmap);
lockBitmap.LockBits();
byte layers = group.Layers;
byte x = 0;
if (category == ThingCategory.Outfit)
{
layers = 1;
x = (byte)(2 % group.PatternX);
}
// draw sprite
for (byte l = 0; l < layers; l++)
{
for (byte w = 0; w < group.Width; w++)
{
for (byte h = 0; h < group.Height; h++)
{
int index = group.GetSpriteIndex(w, h, l, x, 0, 0, 0);
uint spriteId = group.SpriteIDs[index];
int px = (group.Width - w - 1) * Sprite.DefaultSize;
int py = (group.Height - h - 1) * Sprite.DefaultSize;
lockBitmap.CopyPixels(this.Sprites.GetSpriteBitmap(spriteId), px, py);
}
}
}
lockBitmap.UnlockBits();
lockBitmap.Dispose();
this.spriteCache.SetPicture(id, category, bitmap);
return bitmap;
}
public bool HasFrameGroup(FrameGroupType type)
{
return this.type.frameGroups.ContainsKey(type);
}
public bool HasFrameGroup(FrameGroupType type)
{
return(this.type.FrameGroups.ContainsKey(type));
}
public SpriteSheet GetSpriteSheet(FrameGroupType groupType)
{
FrameGroup frameGroup = this.GetFrameGroup(groupType);
if (frameGroup == null)
{
return null;
}
Sprite[] sprites = this.sprites[groupType];
int totalX = frameGroup.PatternZ * frameGroup.PatternX * frameGroup.Layers;
int totalY = frameGroup.Frames * frameGroup.PatternY;
int bitmapWidth = (totalX * frameGroup.Width) * Sprite.DefaultSize;
int bitmapHeight = (totalY * frameGroup.Height) * Sprite.DefaultSize;
int pixelsWidth = frameGroup.Width * Sprite.DefaultSize;
int pixelsHeight = frameGroup.Height * Sprite.DefaultSize;
Bitmap bitmap = new Bitmap(bitmapWidth, bitmapHeight, PixelFormat.Format32bppArgb);
Dictionary<int, Rect> rectList = new Dictionary<int, Rect>();
BitmapLocker lockBitmap = new BitmapLocker(bitmap);
lockBitmap.LockBits();
for (int f = 0; f < frameGroup.Frames; f++)
{
for (int z = 0; z < frameGroup.PatternZ; z++)
{
for (int y = 0; y < frameGroup.PatternY; y++)
{
for (int x = 0; x < frameGroup.PatternX; x++)
{
for (int l = 0; l < frameGroup.Layers; l++)
{
int index = frameGroup.GetTextureIndex(l, x, y, z, f);
int fx = (index % totalX) * pixelsWidth;
int fy = (int)(Math.Floor((decimal)(index / totalX)) * pixelsHeight);
rectList.Add(index, new Rect(fx, fy, pixelsWidth, pixelsHeight));
for (int w = 0; w < frameGroup.Width; w++)
{
for (int h = 0; h < frameGroup.Height; h++)
{
index = frameGroup.GetSpriteIndex(w, h, l, x, y, z, f);
int px = (frameGroup.Width - w - 1) * Sprite.DefaultSize;
int py = (frameGroup.Height - h - 1) * Sprite.DefaultSize;
lockBitmap.CopyPixels(sprites[index].GetBitmap(), px + fx, py + fy);
}
}
}
}
}
}
}
lockBitmap.UnlockBits();
lockBitmap.Dispose();
return new SpriteSheet(bitmap, rectList);
}
public SpriteSheet GetSpriteSheet(FrameGroupType groupType, OutfitData outfitData)
{
SpriteSheet rawSpriteSheet = this.GetSpriteSheet(groupType);
FrameGroup group = this.ThingType.GetFrameGroup(groupType);
if (group.Layers < 2)
{
return rawSpriteSheet;
}
outfitData = outfitData == null ? OUTFIT_DATA : outfitData;
int totalX = group.PatternZ * group.PatternX * group.Layers;
int totalY = group.Frames * group.PatternY;
int bitmapWidth = (totalX * group.Width) * Sprite.DefaultSize;
int bitmapHeight = (totalY * group.Height) * Sprite.DefaultSize;
int pixelsWidth = group.Width * Sprite.DefaultSize;
int pixelsHeight = group.Height * Sprite.DefaultSize;
Bitmap grayBitmap = new Bitmap(bitmapWidth, bitmapHeight, PixelFormat.Format32bppArgb);
Bitmap blendBitmap = new Bitmap(bitmapWidth, bitmapHeight, PixelFormat.Format32bppArgb);
Bitmap bitmap = new Bitmap(bitmapWidth, bitmapHeight, PixelFormat.Format32bppArgb);
Dictionary<int, Rect> rectList = new Dictionary<int, Rect>();
for (int f = 0; f < group.Frames; f++)
{
for (int z = 0; z < group.PatternZ; z++)
{
for (int x = 0; x < group.PatternX; x++)
{
int index = (((f % group.Frames * group.PatternZ + z) * group.PatternY) * group.PatternX + x) * group.Layers;
rectList[index] = new Rect((z * group.PatternX + x) * pixelsWidth, f * pixelsHeight, pixelsWidth, pixelsHeight);
}
}
}
BitmapLocker grayLocker = new BitmapLocker(grayBitmap);
BitmapLocker blendLocker = new BitmapLocker(blendBitmap);
BitmapLocker bitmapLocker = new BitmapLocker(bitmap);
grayLocker.LockBits();
blendLocker.LockBits();
bitmapLocker.LockBits();
for (int y = 0; y < group.PatternY; y++)
{
if (y == 0 || (outfitData.Addons & 1 << (y - 1)) != 0)
{
for (int f = 0; f < group.Frames; f++)
{
for (int z = 0; z < group.PatternZ; z++)
{
for (int x = 0; x < group.PatternX; x++)
{
// gets gray bitmap
int i = (((f % group.Frames * group.PatternZ + z) * group.PatternY + y) * group.PatternX + x) * group.Layers;
Rect rect = rawSpriteSheet.RectList[i];
int rx = rect.X;
int ry = rect.Y;
int rw = rect.Width;
int rh = rect.Height;
int index = (((f * group.PatternZ + z) * group.PatternY) * group.PatternX + x) * group.Layers;
rect = rectList[index];
int px = rect.X;
int py = rect.Y;
grayLocker.CopyPixels(rawSpriteSheet.Bitmap, rx, ry, rw, rh, px, py);
// gets blend bitmap
i++;
rect = rawSpriteSheet.RectList[i];
rx = rect.X;
ry = rect.Y;
rw = rect.Width;
rh = rect.Height;
blendLocker.CopyPixels(rawSpriteSheet.Bitmap, rx, ry, rw, rh, px, py);
}
}
}
bitmapLocker.ColorizePixels(grayLocker.Pixels, blendLocker.Pixels, outfitData.Head, outfitData.Body, outfitData.Legs, outfitData.Feet);
}
}
grayLocker.UnlockBits();
grayLocker.Dispose();
blendLocker.UnlockBits();
blendLocker.Dispose();
bitmapLocker.UnlockBits();
bitmapLocker.Dispose();
grayBitmap.Dispose();
blendBitmap.Dispose();
return new SpriteSheet(bitmap, rectList);
}
public FrameGroup GetFrameGroup(FrameGroupType groupType)
{
return this.type.GetFrameGroup(groupType);
}
public Sprite[] GetSprites(FrameGroupType groupType)
{
if (this.sprites.ContainsKey(groupType))
{
return this.sprites[groupType];
}
return null;
}
public FrameGroup GetFrameGroup(FrameGroupType groupType)
{
if (this.frameGroups.ContainsKey(groupType))
{
return this.frameGroups[groupType];
}
return null;
}
public FrameGroup SetFrameGroup(FrameGroupType groupType, FrameGroup group)
{
if (groupType == FrameGroupType.Walking && (!this.frameGroups.ContainsKey(FrameGroupType.Default) || this.frameGroups.Count == 0))
{
this.frameGroups.Add(FrameGroupType.Default, group);
}
if (!this.frameGroups.ContainsKey(groupType))
{
this.frameGroups.Add(groupType, group);
}
return group;
}
public SpriteSheet GetSpriteSheet(ushort id, ThingCategory category, FrameGroupType groupType)
{
ThingType thing = this.Things.GetThing(id, category);
if (thing == null)
{
return null;
}
FrameGroup group = thing.GetFrameGroup(groupType);
int totalX = group.PatternZ * group.PatternX * group.Layers;
int totalY = group.Frames * group.PatternY;
int bitmapWidth = (totalX * group.Width) * Sprite.DefaultSize;
int bitmapHeight = (totalY * group.Height) * Sprite.DefaultSize;
int pixelsWidth = group.Width * Sprite.DefaultSize;
int pixelsHeight = group.Height * Sprite.DefaultSize;
Bitmap bitmap = new Bitmap(bitmapWidth, bitmapHeight, PixelFormat.Format32bppArgb);
Dictionary<int, Rect> rectList = new Dictionary<int, Rect>();
BitmapLocker lockBitmap = new BitmapLocker(bitmap);
lockBitmap.LockBits();
for (int f = 0; f < group.Frames; f++)
{
for (int z = 0; z < group.PatternZ; z++)
{
for (int y = 0; y < group.PatternY; y++)
{
for (int x = 0; x < group.PatternX; x++)
{
for (int l = 0; l < group.Layers; l++)
{
int index = group.GetTextureIndex(l, x, y, z, f);
int fx = (index % totalX) * pixelsWidth;
int fy = (int)(Math.Floor((decimal)(index / totalX)) * pixelsHeight);
rectList.Add(index, new Rect(fx, fy, pixelsWidth, pixelsHeight));
for (int w = 0; w < group.Width; w++)
{
for (int h = 0; h < group.Height; h++)
{
index = group.GetSpriteIndex(w, h, l, x, y, z, f);
int px = ((group.Width - w - 1) * Sprite.DefaultSize);
int py = ((group.Height - h - 1) * Sprite.DefaultSize);
uint spriteId = group.SpriteIDs[index];
lockBitmap.CopyPixels(this.Sprites.GetSpriteBitmap(spriteId), px + fx, py + fy);
}
}
}
}
}
}
}
lockBitmap.UnlockBits();
return new SpriteSheet(bitmap, rectList);
}
public FrameGroup GetFrameGroup(FrameGroupType groupType)
{
return(this.type.GetFrameGroup(groupType));
}
public static ThingType Serialize(ushort id, ThingCategory category, ref Net.InputMessage binaryReader)
{
ThingType type = new ThingType()
{
ID = id,
Category = category
};
int count = 0, attr = -1;
bool done = false;
for (int i = 0; i < DatAttributes.LastAttr; ++i)
{
count++;
attr = binaryReader.GetU8();
if (attr == DatAttributes.LastAttr)
{
done = true;
break;
}
switch (attr)
{
case DatAttributes.Ground:
case DatAttributes.Writable:
case DatAttributes.WritableOnce:
case DatAttributes.MinimapColor:
case DatAttributes.LensHelp:
case DatAttributes.Cloth:
case DatAttributes.DefaultAction:
type.Attributes[(byte)attr] = binaryReader.GetU16();
break;
case DatAttributes.GroundBorder:
case DatAttributes.OnBottom:
case DatAttributes.OnTop:
case DatAttributes.Container:
case DatAttributes.Stackable:
case DatAttributes.ForceUse:
case DatAttributes.MultiUse:
case DatAttributes.FluidContainer:
case DatAttributes.Splash:
case DatAttributes.NotWalkable:
case DatAttributes.NotMoveable:
case DatAttributes.BlockProjectile:
case DatAttributes.NotPathable:
case DatAttributes.NoMoveAnimation:
case DatAttributes.Pickupable:
case DatAttributes.Hangable:
case DatAttributes.HookSouth:
case DatAttributes.HookEast:
case DatAttributes.Rotateable:
case DatAttributes.DontHide:
case DatAttributes.Translucent:
case DatAttributes.LyingCorpse:
case DatAttributes.AnimateAlways:
case DatAttributes.FullGround:
case DatAttributes.Look:
case DatAttributes.Wrapable:
case DatAttributes.Unwrapable:
case DatAttributes.TopEffect:
case DatAttributes.Usable:
type.Attributes[(byte)attr] = true;
break;
case DatAttributes.Light:
type.Attributes[(byte)attr] = new LightInfo()
{
intensity = binaryReader.GetU16(),
color = binaryReader.GetU16()
};
break;
case DatAttributes.Displacement:
type.Attributes[(byte)attr] = new Vector2Int {
x = binaryReader.GetU16(),
y = binaryReader.GetU16()
};
break;
case DatAttributes.Elevation:
type.Elevation = binaryReader.GetU16();
type.Attributes[(byte)attr] = type.Elevation;
break;
case DatAttributes.Market:
type.Attributes[(byte)attr] = new MarketData()
{
category = binaryReader.GetU16(),
tradeAs = binaryReader.GetU16(),
showAs = binaryReader.GetU16(),
name = binaryReader.GetString(),
restrictVocation = binaryReader.GetU16(),
requiredLevel = binaryReader.GetU16(),
};
break;
default:
throw new System.Exception("Unhandled DatAttribute [" + attr + "].");
}
}
if (!done)
{
throw new System.Exception("Couldn't parse thing [category: " + category + ", ID: " + id + "].");
}
byte groupCount = (category == ThingCategory.Creature) ? binaryReader.GetU8() : (byte)1U;
for (int i = 0; i < groupCount; i++)
{
FrameGroupType groupType = FrameGroupType.Default;
if (category == ThingCategory.Creature)
{
groupType = (FrameGroupType)binaryReader.GetU8();
}
type.FrameGroups[groupType] = FrameGroup.Serialize(category, ref binaryReader);
}
return(type);
}
public FrameGroup GetFrameGroup(ushort id, ThingCategory category, FrameGroupType groupType)
{
ThingType type = this.Things.GetThing(id, category);
if (type != null)
{
return type.GetFrameGroup(groupType);
}
return null;
}
public SpriteSheet GetSpriteSheet(FrameGroupType groupType, OutfitData outfitData)
{
SpriteSheet rawSpriteSheet = this.GetSpriteSheet(groupType);
FrameGroup group = this.ThingType.GetFrameGroup(groupType);
if (group.Layers < 2)
{
return(rawSpriteSheet);
}
outfitData = outfitData == null ? OUTFIT_DATA : outfitData;
int totalX = group.PatternZ * group.PatternX * group.Layers;
int totalY = group.Frames * group.PatternY;
int bitmapWidth = (totalX * group.Width) * Sprite.DefaultSize;
int bitmapHeight = (totalY * group.Height) * Sprite.DefaultSize;
int pixelsWidth = group.Width * Sprite.DefaultSize;
int pixelsHeight = group.Height * Sprite.DefaultSize;
Bitmap grayBitmap = new Bitmap(bitmapWidth, bitmapHeight, PixelFormat.Format32bppArgb);
Bitmap blendBitmap = new Bitmap(bitmapWidth, bitmapHeight, PixelFormat.Format32bppArgb);
Bitmap bitmap = new Bitmap(bitmapWidth, bitmapHeight, PixelFormat.Format32bppArgb);
Dictionary <int, Rect> rectList = new Dictionary <int, Rect>();
for (int f = 0; f < group.Frames; f++)
{
for (int z = 0; z < group.PatternZ; z++)
{
for (int x = 0; x < group.PatternX; x++)
{
int index = (((f % group.Frames * group.PatternZ + z) * group.PatternY) * group.PatternX + x) * group.Layers;
rectList[index] = new Rect((z * group.PatternX + x) * pixelsWidth, f * pixelsHeight, pixelsWidth, pixelsHeight);
}
}
}
BitmapLocker grayLocker = new BitmapLocker(grayBitmap);
BitmapLocker blendLocker = new BitmapLocker(blendBitmap);
BitmapLocker bitmapLocker = new BitmapLocker(bitmap);
grayLocker.LockBits();
blendLocker.LockBits();
bitmapLocker.LockBits();
for (int y = 0; y < group.PatternY; y++)
{
if (y == 0 || (outfitData.Addons & 1 << (y - 1)) != 0)
{
for (int f = 0; f < group.Frames; f++)
{
for (int z = 0; z < group.PatternZ; z++)
{
for (int x = 0; x < group.PatternX; x++)
{
// gets gray bitmap
int i = (((f % group.Frames * group.PatternZ + z) * group.PatternY + y) * group.PatternX + x) * group.Layers;
Rect rect = rawSpriteSheet.RectList[i];
int rx = rect.X;
int ry = rect.Y;
int rw = rect.Width;
int rh = rect.Height;
int index = (((f * group.PatternZ + z) * group.PatternY) * group.PatternX + x) * group.Layers;
rect = rectList[index];
int px = rect.X;
int py = rect.Y;
grayLocker.CopyPixels(rawSpriteSheet.Bitmap, rx, ry, rw, rh, px, py);
// gets blend bitmap
i++;
rect = rawSpriteSheet.RectList[i];
rx = rect.X;
ry = rect.Y;
rw = rect.Width;
rh = rect.Height;
blendLocker.CopyPixels(rawSpriteSheet.Bitmap, rx, ry, rw, rh, px, py);
}
}
}
bitmapLocker.ColorizePixels(grayLocker.Pixels, blendLocker.Pixels, outfitData.Head, outfitData.Body, outfitData.Legs, outfitData.Feet);
}
}
grayLocker.UnlockBits();
grayLocker.Dispose();
blendLocker.UnlockBits();
blendLocker.Dispose();
bitmapLocker.UnlockBits();
bitmapLocker.Dispose();
grayBitmap.Dispose();
blendBitmap.Dispose();
return(new SpriteSheet(bitmap, rectList));
}
public static bool ReadTexturePatterns(ThingType thing, ClientFeatures features, BinaryReader reader)
{
bool patternZEnabled = (features & ClientFeatures.PatternZ) == ClientFeatures.PatternZ;
bool extendedEnabled = (features & ClientFeatures.Extended) == ClientFeatures.Extended;
bool frameDurationsEnabled = (features & ClientFeatures.FrameDurations) == ClientFeatures.FrameDurations;
bool frameGroupsEnabled = (features & ClientFeatures.FrameGroups) == ClientFeatures.FrameGroups;
byte groupCount = 1;
if (frameGroupsEnabled && thing.Category == ThingCategory.Outfit)
{
groupCount = reader.ReadByte();
}
for (byte k = 0; k < groupCount; k++)
{
FrameGroupType groupType = FrameGroupType.Default;
if (frameGroupsEnabled && thing.Category == ThingCategory.Outfit)
{
groupType = (FrameGroupType)reader.ReadByte();
}
FrameGroup group = new FrameGroup();
group.Width = reader.ReadByte();
group.Height = reader.ReadByte();
if (group.Width > 1 || group.Height > 1)
{
group.ExactSize = reader.ReadByte();
}
else
{
group.ExactSize = Sprite.DefaultSize;
}
group.Layers = reader.ReadByte();
group.PatternX = reader.ReadByte();
group.PatternY = reader.ReadByte();
group.PatternZ = patternZEnabled ? reader.ReadByte() : (byte)1;
group.Frames = reader.ReadByte();
if (frameDurationsEnabled && group.Frames > 1)
{
group.IsAnimation = true;
group.AnimationMode = (AnimationMode)reader.ReadByte();
group.LoopCount = reader.ReadInt32();
group.StartFrame = reader.ReadSByte();
group.FrameDurations = new FrameDuration[group.Frames];
for (int i = 0; i < group.Frames; i++)
{
uint minimum = reader.ReadUInt32();
uint maximum = reader.ReadUInt32();
group.FrameDurations[i] = new FrameDuration(minimum, maximum);
}
}
int totalSprites = group.GetTotalSprites();
if (totalSprites > 4096)
{
throw new Exception("A thing type has more than 4096 sprites.");
}
group.SpriteIDs = new uint[totalSprites];
if (extendedEnabled)
{
for (int i = 0; i < totalSprites; i++)
{
group.SpriteIDs[i] = reader.ReadUInt32();
}
}
else
{
for (int i = 0; i < totalSprites; i++)
{
group.SpriteIDs[i] = reader.ReadUInt16();
}
}
thing.SetFrameGroup(groupType, group);
}
return(true);
}
public Bitmap GetObjectImage(ThingType thing, FrameGroupType groupType)
{
if (thing != null)
{
return this.GetObjectImage(thing.ID, thing.Category, groupType);
}
return null;
}
