コード例 #1
0
ファイル: MapLoader.cs プロジェクト: Aeopp/Github
        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);
        }
コード例 #2
0
ファイル: MapLoader.cs プロジェクト: Aeopp/Github
 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);
         }
     }
 }
コード例 #3
0
        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");
                    }
                }
            }
        }
コード例 #4
0
        /// <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);
        }
コード例 #5
0
ファイル: InfoToolTests.cs プロジェクト: SabreTools/MPF
 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);
 }
コード例 #6
0
        /// <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);
        }
コード例 #7
0
        /// <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");
            }
        }
コード例 #8
0
ファイル: MapSimulator.cs プロジェクト: s911415/HaSuite
        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");
            }
        }
コード例 #9
0
ファイル: MapLoader.cs プロジェクト: xnum/hasuite
        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);*/
        }
コード例 #10
0
        /// <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");
            }
        }
コード例 #11
0
ファイル: MapLoader.cs プロジェクト: xnum/hasuite
        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();
            }
        }
コード例 #12
0
ファイル: MapLoader.cs プロジェクト: xnum/hasuite
        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);
                }
            }
        }
コード例 #13
0
ファイル: MapLoader.cs プロジェクト: xnum/hasuite
 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));
         }
     }
 }
コード例 #14
0
ファイル: MapLoader.cs プロジェクト: Aeopp/Github
        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();
            }
        }
コード例 #15
0
        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));
        }
コード例 #16
0
ファイル: MapLoader.cs プロジェクト: Aeopp/Github
        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.
        }
コード例 #17
0
        /// <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");
            }
        }