private static bool GetMapVR(WzImage mapImage, ref System.Drawing.Rectangle?VR)
{
WzSubProperty fhParent = (WzSubProperty)mapImage["foothold"];
if (fhParent == null)
{
VR = null; return(false);
}
int mostRight = int.MinValue, mostLeft = int.MaxValue, mostTop = int.MaxValue, mostBottom = int.MinValue;
foreach (WzSubProperty fhLayer in fhParent.WzProperties)
{
foreach (WzSubProperty fhCat in fhLayer.WzProperties)
{
foreach (WzSubProperty fh in fhCat.WzProperties)
{
int x1 = InfoTool.GetInt(fh["x1"]);
int x2 = InfoTool.GetInt(fh["x2"]);
int y1 = InfoTool.GetInt(fh["y1"]);
int y2 = InfoTool.GetInt(fh["y2"]);
if (x1 > mostRight)
{
mostRight = x1;
}
if (x1 < mostLeft)
{
mostLeft = x1;
}
if (x2 > mostRight)
{
mostRight = x2;
}
if (x2 < mostLeft)
{
mostLeft = x2;
}
if (y1 > mostBottom)
{
mostBottom = y1;
}
if (y1 < mostTop)
{
mostTop = y1;
}
if (y2 > mostBottom)
{
mostBottom = y2;
}
if (y2 < mostTop)
{
mostTop = y2;
}
}
}
}
if (mostRight == int.MinValue || mostLeft == int.MaxValue || mostTop == int.MaxValue || mostBottom == int.MinValue)
{
VR = null; return(false);
}
int VRLeft = mostLeft - 10;
int VRRight = mostRight + 10;
int VRBottom = mostBottom + 110;
int VRTop = Math.Min(mostBottom - 600, mostTop - 360);
VR = new System.Drawing.Rectangle(VRLeft, VRTop, VRRight - VRLeft, VRBottom - VRTop);
return(true);
}
public void LoadLayers(WzImage mapImage, Board mapBoard)
{
for (int layer = 0; layer <= 7; layer++)
{
WzSubProperty layerProp = (WzSubProperty)mapImage[layer.ToString()];
WzImageProperty tSprop = layerProp["info"]["tS"];
string tS = null;
if (tSprop != null)
{
tS = InfoTool.GetString(tSprop);
}
foreach (WzImageProperty obj in layerProp["obj"].WzProperties)
{
int x = InfoTool.GetInt(obj["x"]);
int y = InfoTool.GetInt(obj["y"]);
int z = InfoTool.GetInt(obj["z"]);
int zM = InfoTool.GetInt(obj["zM"]);
string oS = InfoTool.GetString(obj["oS"]);
string l0 = InfoTool.GetString(obj["l0"]);
string l1 = InfoTool.GetString(obj["l1"]);
string l2 = InfoTool.GetString(obj["l2"]);
string name = InfoTool.GetOptionalString(obj["name"]);
MapleBool r = InfoTool.GetOptionalBool(obj["r"]);
MapleBool hide = InfoTool.GetOptionalBool(obj["hide"]);
MapleBool reactor = InfoTool.GetOptionalBool(obj["reactor"]);
MapleBool flow = InfoTool.GetOptionalBool(obj["flow"]);
int? rx = InfoTool.GetOptionalTranslatedInt(obj["rx"]);
int? ry = InfoTool.GetOptionalTranslatedInt(obj["ry"]);
int? cx = InfoTool.GetOptionalTranslatedInt(obj["cx"]);
int? cy = InfoTool.GetOptionalTranslatedInt(obj["cy"]);
string tags = InfoTool.GetOptionalString(obj["tags"]);
WzImageProperty questParent = obj["quest"];
List <ObjectInstanceQuest> questInfo = null;
if (questParent != null)
{
questInfo = new List <ObjectInstanceQuest>();
foreach (WzIntProperty info in questParent.WzProperties)
{
questInfo.Add(new ObjectInstanceQuest(int.Parse(info.Name), (QuestState)info.Value));
}
}
bool flip = InfoTool.GetBool(obj["f"]);
ObjectInfo objInfo = ObjectInfo.Get(oS, l0, l1, l2);
Layer l = mapBoard.Layers[layer];
mapBoard.BoardItems.TileObjs.Add((LayeredItem)objInfo.CreateInstance(l, mapBoard, x, y, z, zM, r, hide, reactor, flow, rx, ry, cx, cy, name, tags, questInfo, flip, false));
l.zMList.Add(zM);
}
WzImageProperty tileParent = layerProp["tile"];
foreach (WzImageProperty tile in tileParent.WzProperties)
{
int x = InfoTool.GetInt(tile["x"]);
int y = InfoTool.GetInt(tile["y"]);
int zM = InfoTool.GetInt(tile["zM"]);
string u = InfoTool.GetString(tile["u"]);
int no = InfoTool.GetInt(tile["no"]);
Layer l = mapBoard.Layers[layer];
TileInfo tileInfo = TileInfo.Get(tS, u, no.ToString());
mapBoard.BoardItems.TileObjs.Add((LayeredItem)tileInfo.CreateInstance(l, mapBoard, x, y, int.Parse(tile.Name), zM, false, false));
l.zMList.Add(zM);
}
}
}
private void ExtractSettingsImage(WzImage settingsImage, Type settingsHolderType)
{
if (!settingsImage.Parsed)
{
settingsImage.ParseImage();
}
foreach (FieldInfo fieldInfo in settingsHolderType.GetFields(BindingFlags.Public | BindingFlags.Static))
{
string settingName = fieldInfo.Name;
WzImageProperty settingProp = settingsImage[settingName];
byte[] argb;
if (settingProp == null)
{
SaveField(settingsImage, fieldInfo);
}
else if (fieldInfo.FieldType.BaseType != null && fieldInfo.FieldType.BaseType.FullName == "System.Enum")
{
fieldInfo.SetValue(null, InfoTool.GetInt(settingProp));
}
else
{
switch (fieldInfo.FieldType.FullName)
{
//case "Microsoft.Xna.Framework.Graphics.Color":
case "Microsoft.Xna.Framework.Color":
if (xnaColorType == null)
{
throw new InvalidDataException("XNA color detected, but XNA type activator is null");
}
argb = BitConverter.GetBytes((uint)((WzDoubleProperty)settingProp).Value);
fieldInfo.SetValue(null, Activator.CreateInstance(xnaColorType, argb[0], argb[1], argb[2], argb[3]));
break;
case "System.Drawing.Color":
argb = BitConverter.GetBytes((uint)((WzDoubleProperty)settingProp).Value);
fieldInfo.SetValue(null, System.Drawing.Color.FromArgb(argb[3], argb[2], argb[1], argb[0]));
break;
case "System.Int32":
fieldInfo.SetValue(null, InfoTool.GetInt(settingProp));
break;
case "System.Double":
fieldInfo.SetValue(null, ((WzDoubleProperty)settingProp).Value);
break;
case "System.Boolean":
fieldInfo.SetValue(null, InfoTool.GetBool(settingProp));
//bool a = (bool)fieldInfo.GetValue(null);
break;
case "System.Single":
fieldInfo.SetValue(null, ((WzFloatProperty)settingProp).Value);
break;
/*case "WzMapleVersion":
* fieldInfo.SetValue(null, (WzMapleVersion)InfoTool.GetInt(settingProp));
* break;
* case "ItemTypes":
* fieldInfo.SetValue(null, (ItemTypes)InfoTool.GetInt(settingProp));
* break;*/
case "System.Drawing.Size":
fieldInfo.SetValue(null, new System.Drawing.Size(((WzVectorProperty)settingProp).X.Value, ((WzVectorProperty)settingProp).Y.Value));
break;
case "System.String":
fieldInfo.SetValue(null, InfoTool.GetString(settingProp));
break;
case "System.Drawing.Bitmap":
fieldInfo.SetValue(null, ((WzCanvasProperty)settingProp).PngProperty.GetPNG(false));
break;
default:
throw new Exception("unrecognized setting type");
}
}
}
}
/// <summary>
/// Load frames from WzSubProperty or WzCanvasProperty
/// </summary>
/// <param name="texturePool"></param>
/// <param name="source"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="device"></param>
/// <param name="usedProps"></param>
/// <param name="spineAni">Spine animation path</param>
/// <returns></returns>
private static List <IDXObject> LoadFrames(TexturePool texturePool, WzImageProperty source, int x, int y, GraphicsDevice device, ref List <WzObject> usedProps, string spineAni = null)
{
List <IDXObject> frames = new List <IDXObject>();
source = WzInfoTools.GetRealProperty(source);
if (source is WzSubProperty property1 && property1.WzProperties.Count == 1)
{
source = property1.WzProperties[0];
}
if (source is WzCanvasProperty property) //one-frame
{
bool bLoadedSpine = LoadSpineMapObjectItem(source, source, device, spineAni);
if (!bLoadedSpine)
{
string canvasBitmapPath = property.FullPath;
Texture2D textureFromCache = texturePool.GetTexture(canvasBitmapPath);
if (textureFromCache != null)
{
source.MSTag = textureFromCache;
}
else
{
source.MSTag = property.GetLinkedWzCanvasBitmap().ToTexture2D(device);
// add to cache
texturePool.AddTextureToPool(canvasBitmapPath, (Texture2D)source.MSTag);
}
}
usedProps.Add(source);
if (source.MSTagSpine != null)
{
WzSpineObject spineObject = (WzSpineObject)source.MSTagSpine;
System.Drawing.PointF origin = property.GetCanvasOriginPosition();
frames.Add(new DXSpineObject(spineObject, x, y, origin));
}
else if (source.MSTag != null)
{
Texture2D texture = (Texture2D)source.MSTag;
System.Drawing.PointF origin = property.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X, y - (int)origin.Y, texture));
}
else // fallback
{
Texture2D texture = Properties.Resources.placeholder.ToTexture2D(device);
System.Drawing.PointF origin = property.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X, y - (int)origin.Y, texture));
}
}
else if (source is WzSubProperty) // animated
{
WzImageProperty _frameProp;
int i = 0;
while ((_frameProp = WzInfoTools.GetRealProperty(source[(i++).ToString()])) != null)
{
if (_frameProp is WzSubProperty) // issue with 867119250
{
frames.AddRange(LoadFrames(texturePool, _frameProp, x, y, device, ref usedProps, null));
}
else
{
WzCanvasProperty frameProp;
if (_frameProp is WzUOLProperty) // some could be UOL. Ex: 321100000 Mirror world: [Mirror World] Leafre
{
WzObject linkVal = ((WzUOLProperty)_frameProp).LinkValue;
if (linkVal is WzCanvasProperty linkCanvas)
{
frameProp = linkCanvas;
}
else
{
continue;
}
}
else
{
frameProp = (WzCanvasProperty)_frameProp;
}
int delay = (int)InfoTool.GetOptionalInt(frameProp["delay"], 100);
bool bLoadedSpine = LoadSpineMapObjectItem((WzImageProperty)frameProp.Parent, frameProp, device, spineAni);
if (!bLoadedSpine)
{
if (frameProp.MSTag == null)
{
string canvasBitmapPath = frameProp.FullPath;
Texture2D textureFromCache = texturePool.GetTexture(canvasBitmapPath);
if (textureFromCache != null)
{
frameProp.MSTag = textureFromCache;
}
else
{
frameProp.MSTag = frameProp.GetLinkedWzCanvasBitmap().ToTexture2D(device);
// add to cache
texturePool.AddTextureToPool(canvasBitmapPath, (Texture2D)frameProp.MSTag);
}
}
}
usedProps.Add(frameProp);
if (frameProp.MSTagSpine != null)
{
WzSpineObject spineObject = (WzSpineObject)frameProp.MSTagSpine;
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
frames.Add(new DXSpineObject(spineObject, x, y, origin, delay));
}
else if (frameProp.MSTag != null)
{
Texture2D texture = (Texture2D)frameProp.MSTag;
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X, y - (int)origin.Y, texture, delay));
}
else
{
Texture2D texture = Properties.Resources.placeholder.ToTexture2D(device);
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X, y - (int)origin.Y, texture, delay));
}
}
}
}
return(frames);
}
public void NormalizeOutputPathsTest(string outputDirectory, string outputFilename, string expectedOutputDirectory, string expectedOutputFilename)
{
(string actualOutputDirectory, string actualOutputFilename) = InfoTool.NormalizeOutputPaths(outputDirectory, outputFilename);
Assert.Equal(expectedOutputDirectory, actualOutputDirectory);
Assert.Equal(expectedOutputFilename, actualOutputFilename);
}
/// <summary>
/// Load frames from WzSubProperty or WzCanvasProperty
/// </summary>
/// <param name="texturePool"></param>
/// <param name="source"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="device"></param>
/// <param name="usedProps"></param>
/// <param name="spineAni">Spine animation path</param>
/// <returns></returns>
private static List <IDXObject> LoadFrames(TexturePool texturePool, WzImageProperty source, int x, int y, GraphicsDevice device, ref List <WzObject> usedProps, string spineAni = null)
{
List <IDXObject> frames = new List <IDXObject>();
source = WzInfoTools.GetRealProperty(source);
if (source is WzSubProperty property1 && property1.WzProperties.Count == 1)
{
source = property1.WzProperties[0];
}
if (source is WzCanvasProperty property) //one-frame
{
bool bLoadedSpine = LoadSpineMapObjectItem(source, source, device, spineAni);
if (!bLoadedSpine)
{
string canvasBitmapPath = property.FullPath;
Texture2D textureFromCache = texturePool.GetTexture(canvasBitmapPath);
if (textureFromCache != null)
{
source.MSTag = textureFromCache;
}
else
{
source.MSTag = BoardItem.TextureFromBitmap(device, property.GetLinkedWzCanvasBitmap());
// add to cache
texturePool.AddTextureToPool(canvasBitmapPath, (Texture2D)source.MSTag);
}
}
usedProps.Add(source);
if (source.MSTagSpine != null)
{
WzSpineObject spineObject = (WzSpineObject)source.MSTagSpine;
System.Drawing.PointF origin = property.GetCanvasOriginPosition();
frames.Add(new DXSpineObject(spineObject, x, y, origin));
}
else if (source.MSTag != null)
{
Texture2D texture = (Texture2D)source.MSTag;
System.Drawing.PointF origin = property.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X, y - (int)origin.Y, texture));
}
else // fallback
{
Texture2D texture = BoardItem.TextureFromBitmap(device, Properties.Resources.placeholder);
System.Drawing.PointF origin = property.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X, y - (int)origin.Y, texture));
}
}
else if (source is WzSubProperty) // animated
{
WzCanvasProperty frameProp;
int i = 0;
while ((frameProp = (WzCanvasProperty)WzInfoTools.GetRealProperty(source[(i++).ToString()])) != null)
{
int delay = (int)InfoTool.GetOptionalInt(frameProp["delay"], 100);
bool bLoadedSpine = LoadSpineMapObjectItem((WzImageProperty)frameProp.Parent, frameProp, device, spineAni);
if (!bLoadedSpine)
{
if (frameProp.MSTag == null)
{
string canvasBitmapPath = frameProp.FullPath;
Texture2D textureFromCache = texturePool.GetTexture(canvasBitmapPath);
if (textureFromCache != null)
{
frameProp.MSTag = textureFromCache;
}
else
{
frameProp.MSTag = BoardItem.TextureFromBitmap(device, frameProp.GetLinkedWzCanvasBitmap());
// add to cache
texturePool.AddTextureToPool(canvasBitmapPath, (Texture2D)frameProp.MSTag);
}
}
}
usedProps.Add(frameProp);
if (frameProp.MSTagSpine != null)
{
WzSpineObject spineObject = (WzSpineObject)frameProp.MSTagSpine;
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
frames.Add(new DXSpineObject(spineObject, x, y, origin, delay));
}
else if (frameProp.MSTag != null)
{
Texture2D texture = (Texture2D)frameProp.MSTag;
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X, y - (int)origin.Y, texture, delay));
}
else
{
Texture2D texture = BoardItem.TextureFromBitmap(device, Properties.Resources.placeholder);
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X, y - (int)origin.Y, texture, delay));
}
}
}
return(frames);
}
/// <summary>
/// Map item
/// </summary>
/// <param name="source"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="mapCenterX"></param>
/// <param name="mapCenterY"></param>
/// <param name="device"></param>
/// <param name="usedProps"></param>
/// <param name="flip"></param>
/// <returns></returns>
public static MapItem CreateMapItemFromProperty(WzImageProperty source, int x, int y, Point mapCenter, GraphicsDevice device, ref List <WzObject> usedProps, bool flip)
{
source = WzInfoTools.GetRealProperty(source);
if (source is WzSubProperty && ((WzSubProperty)source).WzProperties.Count == 1)
{
source = ((WzSubProperty)source).WzProperties[0];
}
if (source is WzCanvasProperty) //one-frame
{
bool bLoadedSpine = LoadSpineMapObjectItem(source, source, device, null);
if (!bLoadedSpine)
{
if (source.MSTag == null)
{
source.MSTag = BoardItem.TextureFromBitmap(device, ((WzCanvasProperty)source).GetLinkedWzCanvasBitmap());
}
}
usedProps.Add(source);
if (source.MSTagSpine != null)
{
WzSpineObject spineObject = (WzSpineObject)source.MSTagSpine;
System.Drawing.PointF origin = ((WzCanvasProperty)source).GetCanvasOriginPosition();
return(new MapItem(new DXSpineObject(spineObject, x + mapCenter.X, y + mapCenter.Y, origin), flip));
}
else if (source.MSTag != null)
{
Texture2D texture = (Texture2D)source.MSTag;
System.Drawing.PointF origin = ((WzCanvasProperty)source).GetCanvasOriginPosition();
return(new MapItem(new DXObject(x - (int)origin.X + mapCenter.X, y - (int)origin.Y + mapCenter.Y, texture), flip));
}
else // fallback
{
Texture2D texture = BoardItem.TextureFromBitmap(device, Properties.Resources.placeholder);
System.Drawing.PointF origin = ((WzCanvasProperty)source).GetCanvasOriginPosition();
return(new MapItem(new DXObject(x - (int)origin.X + mapCenter.X, y - (int)origin.Y + mapCenter.Y, texture), flip));
}
}
else if (source is WzSubProperty) // animated
{
WzCanvasProperty frameProp;
int i = 0;
List <IDXObject> frames = new List <IDXObject>();
while ((frameProp = (WzCanvasProperty)WzInfoTools.GetRealProperty(source[(i++).ToString()])) != null)
{
int delay = (int)InfoTool.GetOptionalInt(frameProp["delay"], 100);
bool bLoadedSpine = LoadSpineMapObjectItem((WzImageProperty)frameProp.Parent, frameProp, device, null);
if (!bLoadedSpine)
{
if (frameProp.MSTag == null)
{
frameProp.MSTag = BoardItem.TextureFromBitmap(device, frameProp.GetLinkedWzCanvasBitmap());
}
}
usedProps.Add(frameProp);
if (frameProp.MSTagSpine != null)
{
WzSpineObject spineObject = (WzSpineObject)frameProp.MSTagSpine;
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
frames.Add(new DXSpineObject(spineObject, x + mapCenter.X, y + mapCenter.Y, origin, delay));
}
else if (frameProp.MSTag != null)
{
Texture2D texture = (Texture2D)frameProp.MSTag;
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X + mapCenter.X, y - (int)origin.Y + mapCenter.Y, texture, delay));
}
else
{
Texture2D texture = BoardItem.TextureFromBitmap(device, Properties.Resources.placeholder);
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X + mapCenter.X, y - (int)origin.Y + mapCenter.Y, texture, delay));
}
}
return(new MapItem(frames, flip));
}
else
{
throw new Exception("unsupported property type in map simulator");
}
}
private static MapItem CreateMapItemFromProperty(WzImageProperty source, int x, int y, int mapCenterX, int mapCenterY, GraphicsDevice device, ref List <WzObject> usedProps, bool flip)
{
source = WzInfoTools.GetRealProperty(source);
if (source is WzSubProperty && ((WzSubProperty)source).WzProperties.Count == 1)
{
source = ((WzSubProperty)source).WzProperties[0];
}
if (source is WzCanvasProperty) //one-frame
{
WzVectorProperty origin = (WzVectorProperty)source["origin"];
if (source.MSTag == null)
{
source.MSTag = BoardItem.TextureFromBitmap(device, ((WzCanvasProperty)source).PngProperty.GetPNG(false));
usedProps.Add(source);
}
return(new MapItem(new DXObject(x - origin.X.Value + mapCenterX, y - origin.Y.Value + mapCenterY, (Texture2D)source.MSTag), flip));
}
else if (source is WzSubProperty) //animooted
{
WzCanvasProperty frameProp;
int i = 0;
List <DXObject> frames = new List <DXObject>();
while ((frameProp = (WzCanvasProperty)WzInfoTools.GetRealProperty(source[(i++).ToString()])) != null)
{
int?delay = null;
try
{
delay = InfoTool.GetOptionalInt(frameProp["delay"]);
}
catch (Exception e)
{
int ij = 0;
ij++;
}
if (delay == null)
{
delay = 100;
}
if (frameProp.MSTag == null)
{
frameProp.MSTag = BoardItem.TextureFromBitmap(device, frameProp.PngProperty.GetPNG(false));
usedProps.Add(frameProp);
}
WzVectorProperty origin = (WzVectorProperty)frameProp["origin"];
frames.Add(new DXObject(x - origin.X.Value + mapCenterX, y - origin.Y.Value + mapCenterY, (int)delay, (Texture2D)frameProp.MSTag));
}
return(new MapItem(frames, flip));
}
else
{
throw new Exception("unsupported property type in map simulator");
}
}
private static bool GetMapVR(WzImage mapImage, ref System.Drawing.Rectangle?VR)
{
WzSubProperty fhParent = (WzSubProperty)mapImage["foothold"];
if (fhParent == null)
{
VR = null; return(false);
}
int mostRight = int.MinValue, mostLeft = int.MaxValue, mostTop = int.MaxValue, mostBottom = int.MinValue;
foreach (WzSubProperty fhLayer in fhParent.WzProperties)
{
foreach (WzSubProperty fhCat in fhLayer.WzProperties)
{
foreach (WzSubProperty fh in fhCat.WzProperties)
{
int x1 = InfoTool.GetInt(fh["x1"]);
int x2 = InfoTool.GetInt(fh["x2"]);
int y1 = InfoTool.GetInt(fh["y1"]);
int y2 = InfoTool.GetInt(fh["y2"]);
if (x1 > mostRight)
{
mostRight = x1;
}
if (x1 < mostLeft)
{
mostLeft = x1;
}
if (x2 > mostRight)
{
mostRight = x2;
}
if (x2 < mostLeft)
{
mostLeft = x2;
}
if (y1 > mostBottom)
{
mostBottom = y1;
}
if (y1 < mostTop)
{
mostTop = y1;
}
if (y2 > mostBottom)
{
mostBottom = y2;
}
if (y2 < mostTop)
{
mostTop = y2;
}
}
}
}
if (mostRight == int.MinValue || mostLeft == int.MaxValue || mostTop == int.MaxValue || mostBottom == int.MinValue)
{
VR = null; return(false);
}
int VRLeft = mostLeft - 10;
int VRRight = mostRight + 10;
int VRBottom = mostBottom + 110;
int VRTop = Math.Min(mostBottom - 600, mostTop - 360);
VR = new System.Drawing.Rectangle(VRLeft, VRTop, VRRight - VRLeft, VRBottom - VRTop);
return(true);
/*
* int left = int.MaxValue, top = int.MaxValue, right = int.MinValue, bottom = int.MinValue;
* for (int layer = 0; layer <= 7; layer++)
* {
* WzSubProperty layerProp = (WzSubProperty)mapImage[layer.ToString()];
* foreach (IWzImageProperty obj in layerProp["obj"].WzProperties)
* {
* int x = InfoTool.GetInt(obj["x"]);
* int y = InfoTool.GetInt(obj["y"]);
* if (x < left) left = x;
* if (x > right) right = x;
* if (y < top) top = y;
* if (y > bottom) bottom = y;
* }
* foreach (IWzImageProperty tile in layerProp["tile"].WzProperties)
* {
* int x = InfoTool.GetInt(tile["x"]);
* int y = InfoTool.GetInt(tile["y"]);
* if (x < left) left = x;
* if (x > right) right = x;
* if (y < top) top = y;
* if (y > bottom) bottom = y;
* }
* }
* size = new XNA.Point(right - left + 200, bottom - top + 200);
* center = new XNA.Point(100 - left, 100 - top);*/
}
/// <summary>
/// Background
/// </summary>
/// <param name="source"></param>
/// <param name="bgInstance"></param>
/// <param name="mapCenterX"></param>
/// <param name="mapCenterY"></param>
/// <param name="device"></param>
/// <param name="usedProps"></param>
/// <param name="flip"></param>
/// <returns></returns>
public static BackgroundItem CreateBackgroundFromProperty(WzImageProperty source, BackgroundInstance bgInstance, int mapCenterX, int mapCenterY, GraphicsDevice device, ref List <WzObject> usedProps, bool flip)
{
source = WzInfoTools.GetRealProperty(source);
if (source is WzSubProperty && ((WzSubProperty)source).WzProperties.Count == 1)
{
source = ((WzSubProperty)source).WzProperties[0];
}
if (source is WzCanvasProperty) //one-frame
{
bool bLoadedSpine = LoadSpineMapObjectItem(source, source, device, bgInstance.SpineAni);
if (!bLoadedSpine)
{
if (source.MSTag == null)
{
source.MSTag = BoardItem.TextureFromBitmap(device, ((WzCanvasProperty)source).GetLinkedWzCanvasBitmap());
}
}
usedProps.Add(source);
if (source.MSTagSpine != null)
{
WzSpineObject spineObject = (WzSpineObject)source.MSTagSpine;
System.Drawing.PointF origin = ((WzCanvasProperty)source).GetCanvasOriginPosition();
DXSpineObject dxobj = new DXSpineObject(spineObject, bgInstance.BaseX - (int)origin.X /* - mapCenterX*/, bgInstance.BaseY - (int)origin.Y /* - mapCenterY*/, origin);
return(new BackgroundItem(bgInstance.cx, bgInstance.cy, bgInstance.rx, bgInstance.ry, bgInstance.type, bgInstance.a, bgInstance.front, dxobj, flip, bgInstance.screenMode));
}
else if (source.MSTag != null)
{
Texture2D texture = (Texture2D)source.MSTag;
System.Drawing.PointF origin = ((WzCanvasProperty)source).GetCanvasOriginPosition();
DXObject dxobj = new DXObject(bgInstance.BaseX - (int)origin.X /* - mapCenterX*/, bgInstance.BaseY - (int)origin.Y /* - mapCenterY*/, texture);
return(new BackgroundItem(bgInstance.cx, bgInstance.cy, bgInstance.rx, bgInstance.ry, bgInstance.type, bgInstance.a, bgInstance.front, dxobj, flip, bgInstance.screenMode));
}
else // default fallback if all things fail
{
Texture2D texture = BoardItem.TextureFromBitmap(device, Properties.Resources.placeholder);
System.Drawing.PointF origin = ((WzCanvasProperty)source).GetCanvasOriginPosition();
DXObject dxobj = new DXObject(bgInstance.BaseX - (int)origin.X /* - mapCenterX*/, bgInstance.BaseY - (int)origin.Y /* - mapCenterY*/, texture);
return(new BackgroundItem(bgInstance.cx, bgInstance.cy, bgInstance.rx, bgInstance.ry, bgInstance.type, bgInstance.a, bgInstance.front, dxobj, flip, bgInstance.screenMode));
}
}
else if (source is WzSubProperty) // animated
{
WzCanvasProperty frameProp;
int i = 0;
List <IDXObject> frames = new List <IDXObject>();
while ((frameProp = (WzCanvasProperty)WzInfoTools.GetRealProperty(source[(i++).ToString()])) != null)
{
int delay = (int)InfoTool.GetOptionalInt(frameProp["delay"], 100);
bool bLoadedSpine = LoadSpineMapObjectItem((WzImageProperty)frameProp.Parent, frameProp, device, bgInstance.SpineAni);
if (!bLoadedSpine)
{
if (frameProp.MSTag == null)
{
frameProp.MSTag = BoardItem.TextureFromBitmap(device, frameProp.GetLinkedWzCanvasBitmap());
}
}
usedProps.Add(source);
if (frameProp.MSTagSpine != null)
{
WzSpineObject spineObject = (WzSpineObject)frameProp.MSTagSpine;
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
DXSpineObject dxobj = new DXSpineObject(spineObject, bgInstance.BaseX - (int)origin.X /* - mapCenterX*/, bgInstance.BaseY - (int)origin.Y /* - mapCenterY*/, origin, delay);
frames.Add(dxobj);
}
else if (frameProp.MSTag != null)
{
Texture2D texture = (Texture2D)frameProp.MSTag;
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
DXObject dxObj = new DXObject(bgInstance.BaseX - (int)origin.X /* - mapCenterX*/, bgInstance.BaseY - (int)origin.Y /* - mapCenterY*/, texture, delay);
frames.Add(dxObj);
}
else // default fallback if all things fail
{
Texture2D texture = BoardItem.TextureFromBitmap(device, Properties.Resources.placeholder);
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
DXObject dxObj = new DXObject(bgInstance.BaseX - (int)origin.X /* - mapCenterX*/, bgInstance.BaseY - (int)origin.Y /* - mapCenterY*/, texture, delay);
frames.Add(dxObj);
}
}
return(new BackgroundItem(bgInstance.cx, bgInstance.cy, bgInstance.rx, bgInstance.ry, bgInstance.type, bgInstance.a, bgInstance.front, frames, flip, bgInstance.screenMode));
}
else
{
throw new Exception("Unsupported property type in map simulator");
}
}
private static void LoadFootholds(WzImage mapImage, Board mapBoard)
{
List <FootholdAnchor> anchors = new List <FootholdAnchor>();
WzSubProperty footholdParent = (WzSubProperty)mapImage["foothold"];
int layer;
FootholdAnchor a;
FootholdAnchor b;
FootholdAnchor c;
FootholdAnchor d;
foreach (WzSubProperty layerProp in footholdParent.WzProperties)
{
layer = int.Parse(layerProp.Name);
foreach (WzSubProperty platProp in layerProp.WzProperties)
{
foreach (WzSubProperty fhProp in platProp.WzProperties)
{
a = new FootholdAnchor(mapBoard, InfoTool.GetInt(fhProp["x1"]), InfoTool.GetInt(fhProp["y1"]), layer, false);
b = new FootholdAnchor(mapBoard, InfoTool.GetInt(fhProp["x2"]), InfoTool.GetInt(fhProp["y2"]), layer, false);
int num = int.Parse(fhProp.Name);
int next = InfoTool.GetInt(fhProp["next"]);
int prev = InfoTool.GetInt(fhProp["prev"]);
if (a.X != b.X || a.Y != b.Y)
{
FootholdLine fh = new FootholdLine(mapBoard, a, b);
fh.num = num;
fh.prev = prev;
fh.next = next;
mapBoard.BoardItems.FootholdLines.Add(fh);
anchors.Add(a);
anchors.Add(b);
}
}
}
anchors.Sort(new Comparison <FootholdAnchor>(FootholdAnchor.FHAnchorSorter));
int groupStart = 0; //inclusive
int groupEnd = 0; //inclusive
for (int i = 0; i < anchors.Count - 1; i++)
{
a = anchors[i];
b = anchors[i + 1];
if (a.Y != b.Y && a.X != b.X && a.LayerNumber == b.LayerNumber)
{
groupEnd = i;
if (groupEnd - groupStart == 1) //there are 2 objects in the group, since groupEnd and groupStart are inclusive
{
c = anchors[groupStart];
d = anchors[groupEnd];
CheckAnchorPairMerge(c, d);
}
else if (groupEnd - groupStart != 0)
{
for (int j = groupStart; j <= groupEnd; j++)
{
c = anchors[j];
for (int k = groupStart; k <= groupEnd; k++)
{
if (c.removed)
{
break;
}
d = anchors[k];
if (d.removed)
{
continue;
}
CheckAnchorPairMerge(c, d);
}
}
}
groupStart = groupEnd + 1;
}
}
groupEnd = anchors.Count - 1;
if (groupEnd - groupStart == 1) //there are 2 objects in the group, since groupEnd and groupStart are inclusive
{
c = anchors[groupStart];
d = anchors[groupEnd];
CheckAnchorPairMerge(c, d);
}
else if (groupEnd - groupStart != 0)
{
for (int j = groupStart; j <= groupEnd; j++)
{
c = anchors[j];
for (int k = groupStart; k <= groupEnd; k++)
{
if (c.removed)
{
break;
}
d = anchors[k];
if (d.removed)
{
continue;
}
CheckAnchorPairMerge(c, d);
}
}
}
//FootholdAnchor.MergeAnchors(ref anchors);
/*if (mapBoard.BoardItems.FHAnchors.Count + anchors.Count > mapBoard.BoardItems.FHAnchors.Capacity)
* mapBoard.BoardItems.FHAnchors.Capacity = mapBoard.BoardItems.FHAnchors.Count + anchors.Count;
* anchors.ForEach(X => if mapBoard.BoardItems.FHAnchors.Add(X));
* anchors.Clear();*/
mapBoard.BoardItems.FHAnchors.Capacity = mapBoard.BoardItems.FHAnchors.Count + anchors.Count * 2;
foreach (FootholdAnchor anchor in anchors)
{
if (!anchor.removed)
{
mapBoard.BoardItems.FHAnchors.Add(anchor);
}
}
anchors.Clear();
}
}
private static void LoadLife(WzImage mapImage, Board mapBoard)
{
IWzImageProperty lifeParent = mapImage["life"];
if (lifeParent == null)
{
return;
}
foreach (WzSubProperty life in lifeParent.WzProperties)
{
string id = InfoTool.GetString(life["id"]);
int x = InfoTool.GetInt(life["x"]);
//int y = InfoTool.GetInt(life["y"]);
int cy = InfoTool.GetInt(life["cy"]);
int? mobTime = InfoTool.GetOptionalInt(life["mobTime"]);
int? info = InfoTool.GetOptionalInt(life["info"]);
int? team = InfoTool.GetOptionalInt(life["team"]);
int rx0 = InfoTool.GetInt(life["rx0"]);
int rx1 = InfoTool.GetInt(life["rx1"]);
MapleBool flip = InfoTool.GetOptionalBool(life["f"]);
MapleBool hide = InfoTool.GetOptionalBool(life["hide"]);
string type = InfoTool.GetString(life["type"]);
string limitedname = InfoTool.GetOptionalString(life["limitedname"]);
switch (type)
{
case "m":
WzImage mobImage = (WzImage)Program.WzManager["mob"][id + ".img"];
if (!mobImage.Parsed)
{
mobImage.ParseImage();
}
if (mobImage.HCTag == null)
{
mobImage.HCTag = MobInfo.Load(mobImage);
}
MobInfo mobInfo = (MobInfo)mobImage.HCTag;
//mapBoard.BoardItems.Mobs.Add((MobInstance)mobInfo.CreateInstance(mapBoard, x, cy, rx0, rx1, mobTime, flip, hide, false));
mapBoard.BoardItems.Mobs.Add((LifeInstance)mobInfo.CreateInstance(mapBoard, x, cy, rx0, rx1, limitedname, mobTime, flip, hide, info, team, false));
break;
case "n":
WzImage npcImage = (WzImage)Program.WzManager["npc"][id + ".img"];
if (!npcImage.Parsed)
{
npcImage.ParseImage();
}
if (npcImage.HCTag == null)
{
npcImage.HCTag = NpcInfo.Load(npcImage);
}
NpcInfo npcInfo = (NpcInfo)npcImage.HCTag;
//mapBoard.BoardItems.NPCs.Add((NpcInstance)npcInfo.CreateInstance(mapBoard, x, cy, rx0, rx1, mobTime, flip, hide, false));
mapBoard.BoardItems.NPCs.Add((LifeInstance)npcInfo.CreateInstance(mapBoard, x, cy, rx0, rx1, limitedname, mobTime, flip, hide, info, team, false));
break;
default:
throw new Exception("invalid life type " + type);
}
}
}
private static void LoadLayers(WzImage mapImage, Board mapBoard)
{
for (int layer = 0; layer <= 7; layer++)
{
WzSubProperty layerProp = (WzSubProperty)mapImage[layer.ToString()];
IWzImageProperty tSprop = layerProp["info"]["tS"];
string tS = null;
if (tSprop != null)
{
tS = InfoTool.GetString(tSprop);
}
foreach (IWzImageProperty obj in layerProp["obj"].WzProperties)
{
int x = InfoTool.GetInt(obj["x"]);
int y = InfoTool.GetInt(obj["y"]);
int z = InfoTool.GetInt(obj["z"]);
//int zM = InfoTool.GetInt(obj["zM"]);
string oS = InfoTool.GetString(obj["oS"]);
string l0 = InfoTool.GetString(obj["l0"]);
string l1 = InfoTool.GetString(obj["l1"]);
string l2 = InfoTool.GetString(obj["l2"]);
string name = InfoTool.GetOptionalString(obj["name"]);
MapleBool r = InfoTool.GetOptionalBool(obj["r"]);
MapleBool hide = InfoTool.GetOptionalBool(obj["hide"]);
MapleBool reactor = InfoTool.GetOptionalBool(obj["reactor"]);
MapleBool flow = InfoTool.GetOptionalBool(obj["flow"]);
int? rx = InfoTool.GetOptionalTranslatedInt(obj["rx"]);
int? ry = InfoTool.GetOptionalTranslatedInt(obj["ry"]);
int? cx = InfoTool.GetOptionalTranslatedInt(obj["cx"]);
int? cy = InfoTool.GetOptionalTranslatedInt(obj["cy"]);
string tags = InfoTool.GetOptionalString(obj["tags"]);
IWzImageProperty questParent = obj["quest"];
List <ObjectInstanceQuest> questInfo = null;
if (questParent != null)
{
foreach (WzCompressedIntProperty info in questParent.WzProperties)
{
questInfo.Add(new ObjectInstanceQuest(int.Parse(info.Name), (QuestState)info.Value));
}
}
bool flip = InfoTool.GetBool(obj["f"]);
IWzImageProperty objInfoProp = Program.InfoManager.ObjectSets[oS][l0][l1][l2];
if (objInfoProp.HCTag == null)
{
objInfoProp.HCTag = ObjectInfo.Load((WzSubProperty)objInfoProp, oS, l0, l1, l2);
}
ObjectInfo objInfo = (ObjectInfo)objInfoProp.HCTag;
mapBoard.BoardItems.TileObjs.Add((LayeredItem)objInfo.CreateInstance(mapBoard.Layers[layer], mapBoard, x, y, z, r, hide, reactor, flow, rx, ry, cx, cy, name, tags, questInfo, flip, false, false));
}
IWzImageProperty tileParent = layerProp["tile"];
for (int i = 0; i < tileParent.WzProperties.Count; i++)
//foreach (IWzImageProperty tile in layerProp["tile"].WzProperties)
{
IWzImageProperty tile = tileParent.WzProperties[i];
int x = InfoTool.GetInt(tile["x"]);
int y = InfoTool.GetInt(tile["y"]);
//int zM = InfoTool.GetInt(tile["zM"]);
string u = InfoTool.GetString(tile["u"]);
int no = InfoTool.GetInt(tile["no"]);
IWzImageProperty tileInfoProp = Program.InfoManager.TileSets[tS][u][no.ToString()];
if (tileInfoProp.HCTag == null)
{
tileInfoProp.HCTag = TileInfo.Load((WzCanvasProperty)tileInfoProp, tS, u, no.ToString());
}
TileInfo tileInfo = (TileInfo)tileInfoProp.HCTag;
mapBoard.BoardItems.TileObjs.Add((LayeredItem)tileInfo.CreateInstance(mapBoard.Layers[layer], mapBoard, x, y, i /*zM*/, false, false, false));
}
}
}
public void LoadFootholds(WzImage mapImage, Board mapBoard)
{
List <FootholdAnchor> anchors = new List <FootholdAnchor>();
WzSubProperty footholdParent = (WzSubProperty)mapImage["foothold"];
int layer;
FootholdAnchor a;
FootholdAnchor b;
Dictionary <int, FootholdLine> fhs = new Dictionary <int, FootholdLine>();
foreach (WzSubProperty layerProp in footholdParent.WzProperties)
{
layer = int.Parse(layerProp.Name);
Layer l = mapBoard.Layers[layer];
foreach (WzSubProperty platProp in layerProp.WzProperties)
{
int zM = int.Parse(platProp.Name);
l.zMList.Add(zM);
foreach (WzSubProperty fhProp in platProp.WzProperties)
{
a = new FootholdAnchor(mapBoard, InfoTool.GetInt(fhProp["x1"]), InfoTool.GetInt(fhProp["y1"]), layer, zM, false);
b = new FootholdAnchor(mapBoard, InfoTool.GetInt(fhProp["x2"]), InfoTool.GetInt(fhProp["y2"]), layer, zM, false);
int num = int.Parse(fhProp.Name);
int next = InfoTool.GetInt(fhProp["next"]);
int prev = InfoTool.GetInt(fhProp["prev"]);
MapleBool cantThrough = InfoTool.GetOptionalBool(fhProp["cantThrough"]);
MapleBool forbidFallDown = InfoTool.GetOptionalBool(fhProp["forbidFallDown"]);
int? piece = InfoTool.GetOptionalInt(fhProp["piece"]);
int? force = InfoTool.GetOptionalInt(fhProp["force"]);
if (a.X != b.X || a.Y != b.Y)
{
FootholdLine fh = new FootholdLine(mapBoard, a, b, forbidFallDown, cantThrough, piece, force);
fh.num = num;
fh.prev = prev;
fh.next = next;
mapBoard.BoardItems.FootholdLines.Add(fh);
fhs[num] = fh;
anchors.Add(a);
anchors.Add(b);
}
}
}
anchors.Sort(new Comparison <FootholdAnchor>(FootholdAnchor.FHAnchorSorter));
for (int i = 0; i < anchors.Count - 1; i++)
{
a = anchors[i];
b = anchors[i + 1];
if (a.X == b.X && a.Y == b.Y)
{
FootholdAnchor.MergeAnchors(a, b); // Transfer lines from b to a
anchors.RemoveAt(i + 1); // Remove b
i--; // Fix index after we removed b
}
}
foreach (FootholdAnchor anchor in anchors)
{
if (anchor.connectedLines.Count > 2)
{
foreach (FootholdLine line in anchor.connectedLines)
{
if (IsAnchorPrevOfFoothold(anchor, line))
{
if (fhs.ContainsKey(line.prev))
{
line.prevOverride = fhs[line.prev];
}
}
else
{
if (fhs.ContainsKey(line.next))
{
line.nextOverride = fhs[line.next];
}
}
}
}
mapBoard.BoardItems.FHAnchors.Add(anchor);
}
anchors.Clear();
}
}
public static TileInfo Get(string tS, string u, string no)
{
int?mag = InfoTool.GetOptionalInt(Program.InfoManager.TileSets[tS]["info"]["mag"]);
return(Get(tS, u, no, mag));
}
public void LoadMisc(WzImage mapImage, Board mapBoard)
{
// All of the following properties are extremely esoteric features that only appear in a handful of maps.
// They are implemented here for the sake of completeness, and being able to repack their maps without corruption.
WzImageProperty clock = mapImage["clock"];
WzImageProperty ship = mapImage["shipObj"];
WzImageProperty area = mapImage["area"];
WzImageProperty healer = mapImage["healer"];
WzImageProperty pulley = mapImage["pulley"];
WzImageProperty BuffZone = mapImage["BuffZone"];
WzImageProperty swimArea = mapImage["swimArea"];
if (clock != null)
{
Clock clockInstance = new Clock(mapBoard, new Rectangle(InfoTool.GetInt(clock["x"]), InfoTool.GetInt(clock["y"]), InfoTool.GetInt(clock["width"]), InfoTool.GetInt(clock["height"])));
mapBoard.BoardItems.Add(clockInstance, false);
}
if (ship != null)
{
string objPath = InfoTool.GetString(ship["shipObj"]);
string[] objPathParts = objPath.Split("/".ToCharArray());
string oS = WzInfoTools.RemoveExtension(objPathParts[objPathParts.Length - 4]);
string l0 = objPathParts[objPathParts.Length - 3];
string l1 = objPathParts[objPathParts.Length - 2];
string l2 = objPathParts[objPathParts.Length - 1];
ObjectInfo objInfo = ObjectInfo.Get(oS, l0, l1, l2);
ShipObject shipInstance = new ShipObject(objInfo, mapBoard,
InfoTool.GetInt(ship["x"]),
InfoTool.GetInt(ship["y"]),
InfoTool.GetOptionalInt(ship["z"]),
InfoTool.GetOptionalInt(ship["x0"]),
InfoTool.GetInt(ship["tMove"]),
InfoTool.GetInt(ship["shipKind"]),
InfoTool.GetBool(ship["f"]));
mapBoard.BoardItems.Add(shipInstance, false);
}
if (area != null)
{
foreach (WzImageProperty prop in area.WzProperties)
{
int x1 = InfoTool.GetInt(prop["x1"]);
int x2 = InfoTool.GetInt(prop["x2"]);
int y1 = InfoTool.GetInt(prop["y1"]);
int y2 = InfoTool.GetInt(prop["y2"]);
Area currArea = new Area(mapBoard, new Rectangle(Math.Min(x1, x2), Math.Min(y1, y2), Math.Abs(x2 - x1), Math.Abs(y2 - y1)), prop.Name);
mapBoard.BoardItems.Add(currArea, false);
}
}
if (healer != null)
{
string objPath = InfoTool.GetString(healer["healer"]);
string[] objPathParts = objPath.Split("/".ToCharArray());
string oS = WzInfoTools.RemoveExtension(objPathParts[objPathParts.Length - 4]);
string l0 = objPathParts[objPathParts.Length - 3];
string l1 = objPathParts[objPathParts.Length - 2];
string l2 = objPathParts[objPathParts.Length - 1];
ObjectInfo objInfo = ObjectInfo.Get(oS, l0, l1, l2);
Healer healerInstance = new Healer(objInfo, mapBoard,
InfoTool.GetInt(healer["x"]),
InfoTool.GetInt(healer["yMin"]),
InfoTool.GetInt(healer["yMax"]),
InfoTool.GetInt(healer["healMin"]),
InfoTool.GetInt(healer["healMax"]),
InfoTool.GetInt(healer["fall"]),
InfoTool.GetInt(healer["rise"]));
mapBoard.BoardItems.Add(healerInstance, false);
}
if (pulley != null)
{
string objPath = InfoTool.GetString(pulley["pulley"]);
string[] objPathParts = objPath.Split("/".ToCharArray());
string oS = WzInfoTools.RemoveExtension(objPathParts[objPathParts.Length - 4]);
string l0 = objPathParts[objPathParts.Length - 3];
string l1 = objPathParts[objPathParts.Length - 2];
string l2 = objPathParts[objPathParts.Length - 1];
ObjectInfo objInfo = ObjectInfo.Get(oS, l0, l1, l2);
Pulley pulleyInstance = new Pulley(objInfo, mapBoard,
InfoTool.GetInt(pulley["x"]),
InfoTool.GetInt(pulley["y"]));
mapBoard.BoardItems.Add(pulleyInstance, false);
}
if (BuffZone != null)
{
foreach (WzImageProperty zone in BuffZone.WzProperties)
{
int x1 = InfoTool.GetInt(zone["x1"]);
int x2 = InfoTool.GetInt(zone["x2"]);
int y1 = InfoTool.GetInt(zone["y1"]);
int y2 = InfoTool.GetInt(zone["y2"]);
int id = InfoTool.GetInt(zone["ItemID"]);
int interval = InfoTool.GetInt(zone["Interval"]);
int duration = InfoTool.GetInt(zone["Duration"]);
BuffZone currZone = new BuffZone(mapBoard, new Rectangle(Math.Min(x1, x2), Math.Min(y1, y2), Math.Abs(x2 - x1), Math.Abs(y2 - y1)), id, interval, duration, zone.Name);
mapBoard.BoardItems.Add(currZone, false);
}
}
if (swimArea != null)
{
foreach (WzImageProperty prop in swimArea.WzProperties)
{
int x1 = InfoTool.GetInt(prop["x1"]);
int x2 = InfoTool.GetInt(prop["x2"]);
int y1 = InfoTool.GetInt(prop["y1"]);
int y2 = InfoTool.GetInt(prop["y2"]);
SwimArea currArea = new SwimArea(mapBoard, new Rectangle(Math.Min(x1, x2), Math.Min(y1, y2), Math.Abs(x2 - x1), Math.Abs(y2 - y1)), prop.Name);
mapBoard.BoardItems.Add(currArea, false);
}
}
// Some misc items are not implemented here; these are copied byte-to-byte from the original. See VerifyMapPropsKnown for details.
}
/// <summary>
/// Background
/// </summary>
/// <param name="source"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="rx"></param>
/// <param name="ry"></param>
/// <param name="cx"></param>
/// <param name="cy"></param>
/// <param name="a"></param>
/// <param name="type"></param>
/// <param name="front"></param>
/// <param name="mapCenterX"></param>
/// <param name="mapCenterY"></param>
/// <param name="device"></param>
/// <param name="usedProps"></param>
/// <param name="flip"></param>
/// <returns></returns>
public static BackgroundItem CreateBackgroundFromProperty(WzImageProperty source, int x, int y, int rx, int ry, int cx, int cy, int a, BackgroundType type, bool front, int mapCenterX, int mapCenterY, GraphicsDevice device, ref List <WzObject> usedProps, bool flip)
{
source = WzInfoTools.GetRealProperty(source);
if (source is WzSubProperty && ((WzSubProperty)source).WzProperties.Count == 1)
{
source = ((WzSubProperty)source).WzProperties[0];
}
if (source is WzCanvasProperty) //one-frame
{
if (source.MSTag == null)
{
source.MSTag = BoardItem.TextureFromBitmap(device, ((WzCanvasProperty)source).GetLinkedWzCanvasBitmap());
usedProps.Add(source);
}
Texture2D texture = (Texture2D)source.MSTag;
if (texture != null)
{
System.Drawing.PointF origin = ((WzCanvasProperty)source).GetCanvasOriginPosition();
DXObject dxobj = new DXObject(x - (int)origin.X /* - mapCenterX*/, y - (int)origin.Y /* - mapCenterY*/, texture);
return(new BackgroundItem(cx, cy, rx, ry, type, a, front, dxobj, flip));
}
else
{
throw new Exception("Texture is null for the background property.");
}
}
else if (source is WzSubProperty) //animooted
{
WzCanvasProperty frameProp;
int i = 0;
List <DXObject> frames = new List <DXObject>();
while ((frameProp = (WzCanvasProperty)WzInfoTools.GetRealProperty(source[(i++).ToString()])) != null)
{
int?delay = InfoTool.GetOptionalInt(frameProp["delay"]);
if (delay == null)
{
delay = 100;
}
if (frameProp.MSTag == null)
{
frameProp.MSTag = BoardItem.TextureFromBitmap(device, frameProp.GetLinkedWzCanvasBitmap());
usedProps.Add(frameProp);
}
Texture2D texture = (Texture2D)frameProp.MSTag;
if (texture != null)
{
System.Drawing.PointF origin = frameProp.GetCanvasOriginPosition();
frames.Add(new DXObject(x - (int)origin.X /* - mapCenterX*/, y - (int)origin.Y /* - mapCenterY*/, texture, (int)delay));
}
else
{
throw new Exception("Texture is null for the animation");
}
}
return(new BackgroundItem(cx, cy, rx, ry, type, a, front, frames, flip));
}
else
{
throw new Exception("Unsupported property type in map simulator");
}
}