public void BuyGachapon()
    {
        // Check if there is not enough cash
        if (!PlayerSetting.TakeCoins(GachaponMachine.Cost))
        {
            // Do not allow buying
            return;
        }

        // Generate the skin
        rewardSkin = GachaponMachine.GetRandomSkin();

        if (rewardSkin != null)
        {
            // Set the reward image
            rewardImage.sprite = rewardSkin.PreviewSprite;

            // Set the reward name
            RewardText.text = rewardSkin.SkinName;

            // Play the animation
            startAnimation();

            // Store the skin
            PlayerSetting.AddToSkinStorage(rewardSkin);
        }
    }

        /// <summary>
        /// Lays out the control's interior according to alignment, padding, dock etc.
        /// </summary>
        /// <param name="skin">Skin to use.</param>
        protected override void Layout(Skin.Base skin)
        {
            base.Layout(skin);

            m_ScrollButton[0].Width = Height;
            m_ScrollButton[0].Dock = Pos.Left;

            m_ScrollButton[1].Width = Height;
            m_ScrollButton[1].Dock = Pos.Right;

            m_Bar.Height = ButtonSize;
            m_Bar.Padding = new Padding(ButtonSize, 0, ButtonSize, 0);

            float barWidth = (m_ViewableContentSize / m_ContentSize) * (Width - (ButtonSize * 2));

            if (barWidth < ButtonSize * 0.5f)
                barWidth = (int)(ButtonSize * 0.5f);

            m_Bar.Width = (int)(barWidth);
            m_Bar.IsHidden = Width - (ButtonSize * 2) <= barWidth;

            //Based on our last scroll amount, produce a position for the bar
            if (!m_Bar.IsHeld)
            {
                SetScrollAmount(ScrollAmount, true);
            }
        }

        partial void Merge(Skin entity, SkinDTO dto, object state)
        {
            if (state == null)
            {
                throw new ArgumentNullException("state", "Precondition: state is IResponse");
            }

            var response = state as IResponse;
            if (response == null)
            {
                throw new ArgumentException("Precondition: state is IResponse", "state");
            }

            entity.Culture = response.Culture;
            entity.SkinId = dto.Id;
            entity.Name = dto.Name;

            if (dto.Flags != null)
            {
                entity.Flags = this.skinFlagsConverter.Convert(dto.Flags, state);
            }

            if (dto.Restrictions != null)
            {
                entity.Restrictions = this.itemRestrictionsConverter.Convert(dto.Restrictions, state);
            }

            // Process the URI. Note since the V2 api the URI doesn't have to be built by hand anymore.
            // It is stored as a a string in the response.
            // Question: Shouled we split the URI for user convenience or not??
            // TODO: yes we should split the URI. Not for convencience, but because 'Skin' implements 'IRenderable'
            entity.IconFileUrl = new Uri(dto.IconUrl, UriKind.Absolute);
        }

    // this is the attachment loader which will hook into Futile's AtlasManager for the attachment/element data
    public Attachment NewAttachment(Skin skin, AttachmentType type, String name)
    {
        switch(type){
            case AttachmentType.region:

                FAtlasElement element = Futile.atlasManager.GetElementWithName(name);
                RegionAttachment attachment = new RegionAttachment(name);

                if(element != null){
                    attachment.Texture = element;
                    attachment.SetUVs(element.uvBottomLeft.x, element.uvBottomLeft.y, element.uvTopRight.x, element.uvTopRight.y, false);
                    attachment.RegionOffsetX = 0.0f;
                    attachment.RegionOffsetY = 0.0f;
                    attachment.RegionWidth = element.sourceSize.x;
                    attachment.RegionHeight = element.sourceSize.y;
                    attachment.RegionOriginalWidth = element.sourceSize.x;
                    attachment.RegionOriginalHeight = element.sourceSize.y;

                }else{
                    attachment.Texture = null;
                    attachment.SetUVs(0.0f, 0.0f, 0.0f, 0.0f, false);
                    attachment.RegionOffsetX = 0.0f;
                    attachment.RegionOffsetY = 0.0f;
                    attachment.RegionWidth = 0.0f;
                    attachment.RegionHeight = 0.0f;
                    attachment.RegionOriginalWidth = 0.0f;
                    attachment.RegionOriginalHeight = 0.0f;

                    Debug.Log("Element [" + name + "] not found in Futile.AtlasManager");
                }
                return attachment;
        }
        throw new Exception("Unknown attachment type: " + type);
    }

 public static void DrawNumbers(SpriteBatch batch, Skin skin, int amount, int x, int y)
 {
     batch.Draw(skin.numBox, new Vector2(x - 8, y - 8), Color.White);
     int[] amountNums = new int[3];
     if (amount >= 0)
     {
         if (amount > 999) amount = 999;
         amountNums[0] = (amount - (amount % 100)) / 100;
         amountNums[1] = ((amount - amountNums[0] * 100) - ((amount - amountNums[0] * 100) % 10)) / 10;
         amountNums[2] = amount - (amountNums[0] * 100) - (amountNums[1] * 10);
         batch.Draw(skin.numbers[amountNums[0]], new Rectangle(x, y, 13, 23), Color.White);
         batch.Draw(skin.numbers[amountNums[1]], new Rectangle(x + 13, y, 13, 23), Color.White);
         batch.Draw(skin.numbers[amountNums[2]], new Rectangle(x + 26, y, 13, 23), Color.White);
     }
     else
     {
         char[] amountParts = new char[10];
         amountParts = amount.ToString().ToCharArray();
         if (amount < 0 & amount > -10) amountNums[1] = 0;
         else amountNums[1] = int.Parse(amountParts[amountParts.GetUpperBound(0) - 1].ToString());
         amountNums[2] = int.Parse(amountParts[amountParts.GetUpperBound(0)].ToString());
         if (amount < 0 & amount > -10) amountNums[1] = 0;
         batch.Draw(skin.numbers[10], new Rectangle(x, y, 13, 23), Color.White);
         batch.Draw(skin.numbers[amountNums[1]], new Rectangle(x + 13, y, 13, 23), Color.White);
         batch.Draw(skin.numbers[amountNums[2]], new Rectangle(x + 26, y, 13, 23), Color.White);
     }
 }

 /// <summary>
 /// Gets corresponding widget builder based on input type
 /// </summary>
 /// <param name="field">holds information about input type</param>
 /// <param name="skin">passed to builders to define look of widgets</param>
 /// <returns>corresponding widget builder</returns>
 public AbstractWidgetBuilder getFieldBuilder(AFField field, Skin skin)
 {
     if (Utils.IsFieldWritable(field.getFieldInfo().getWidgetType()))
     {
         return new TextWidgetBuilder(skin, field);
     }
     if (field.getFieldInfo().getWidgetType().Equals(SupportedWidgets.CALENDAR))
     {
         return new DateWidgetBuilder(skin, field);
     }
     if (field.getFieldInfo().getWidgetType().Equals(SupportedWidgets.OPTION))
     {
         return new OptionWidgetBuilder(skin, field);
     }
     if (field.getFieldInfo().getWidgetType().Equals(SupportedWidgets.DROPDOWNMENU))
     {
         return new DropDownWidgetBuilder(skin, field);
     }
     if (field.getFieldInfo().getWidgetType().Equals(SupportedWidgets.CHECKBOX))
     {
         return new CheckboxWidgetBuilder(skin, field);
     }
     if (field.getFieldInfo().getWidgetType().Equals(SupportedWidgets.PASSWORD))
     {
         return new PasswordWidgetBuilder(skin, field);
     }
     Debug.WriteLine("BUILDER FOR " + field.getFieldInfo().getWidgetType() + " NOT FOUND");
     return null;
 }

        /// <summary>
        /// Renders the focus overlay.
        /// </summary>
        /// <param name="skin">Skin to use.</param>
        protected override void RenderFocus(Skin.Base skin)
        {
            if (InputHandler.KeyboardFocus != this) return;
            if (!IsTabable) return;

            skin.DrawKeyboardHighlight(this, RenderBounds, 0);
        }

        /// <summary>
        /// Extension of the Panel which has Button to close itself and Label with title.
        /// Position is calculate from given width and height (1/4 of the width and 1/5 of the height).
        /// Also panel width and height is calculate as 1/2 of the width and 4/7 of the hight.
        /// </summary>
        /// <param name="screenWidth">The width od screen.</param>
        /// <param name="screenHeight">The height od screen.</param>
        /// <param name="text">The title text.</param>
        /// <param name="name">The name of the panel.</param>
        /// <param name="rowHeight">The height of the title label.</param>
        /// <param name="panelSkin">The skin of the creating panel.</param>
        /// <param name="buttonSkin">The skin of the the closing button.</param>
        public PopUpPanel(int screenWidth, int screenHeight, string text, string name, int rowHeight, Skin panelSkin, Skin buttonSkin)
        {
            Width = screenWidth / 2;
            Height = screenHeight * 4 / 7;
            Location = new Point(screenWidth / 4, screenHeight / 5);
            Skin = panelSkin;
            ResizeMode = ResizeModes.None;
            Padding = new Thickness(5, 10, 0, 0);
            Name = name;

            // Title label
            var label = new Label() {
                Size = new Size(Width / 2, rowHeight),
                Text = text,
                Location = new Point(Width / 4, 0),
                TextStyle = {
                    Alignment = Miyagi.Common.Alignment.TopCenter
                }
            };

            Controls.Add(label);
            Button closeButton = new CloseButton(name) {
                Size = new Size(Width / 3, Height / 12),
                Location = new Point(Width * 5 / 8, Height * 7 / 8),
                Skin = buttonSkin,
                Text = "Cancel",
                TextStyle = new TextStyle {
                    Alignment = Alignment.MiddleCenter
                }
            };

            Controls.Add(closeButton);
        }

 public MotionlessKiller(Point top, Skin skin)
     : base(top, new Size(0, 0))
 {
     switch (skin)
     {
         case Skin.EringiUp:
             eringiHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/eringi_S.png");
             Size = new Size(32, 32);
             break;
         case Skin.EringiDown:
             eringiHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/eringiDownS.png");
             Size = new Size(32, 32);
             break;
         case Skin.BambooSpear:
             eringiHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/bambooSpear.png");
             Size = new Size(32, 32);
             break;
         case Skin.LongEringiTrap01:
             eringiHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/eringi_L_left01.png");
             Size=new Size(32,32);
             break;
         default:
             throw new ArgumentOutOfRangeException("skin", skin, null);
     }
 }

        /// <summary>
        /// Lays out the control's interior according to alignment, padding, dock etc.
        /// </summary>
        /// <param name="skin">Skin to use.</param>
        protected override void Layout(Skin.Base skin)
        {
            base.Layout(skin);

            m_ScrollButton[0].Height = Width;
            m_ScrollButton[0].Dock = Pos.Top;

            m_ScrollButton[1].Height = Width;
            m_ScrollButton[1].Dock = Pos.Bottom;

            m_Bar.Width = ButtonSize;
            m_Bar.Padding = new Padding(0, ButtonSize, 0, ButtonSize);

            float barHeight = 0.0f;
            if (m_ContentSize > 0.0f) barHeight = (m_ViewableContentSize/m_ContentSize)*(Height - (ButtonSize*2));

            if (barHeight < ButtonSize*0.5f)
                barHeight = (int) (ButtonSize*0.5f);

            m_Bar.Height = (int) (barHeight);
            m_Bar.IsHidden = Height - (ButtonSize*2) <= barHeight;

            //Based on our last scroll amount, produce a position for the bar
            if (!m_Bar.IsHeld)
            {
                SetScrollAmount(ScrollAmount, true);
            }
        }

        public MotionKiller(Point top, Point ereatop, Size ereasize,int moveX,int moveY,Skin skin)
            : base(top, new Size(32, 32))
        {
            Erea = new MotionlessObject(ereatop, ereasize);
            Erea.IsSolid = false;
            Erea.BeHitEvent += () =>
            {
                _isTrigered = true;
            };
            x = moveX;
            y = moveY;

            switch (skin)
            {
                case Skin.EringiUp:
                    eringiHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/eringi_S.png");
                    Size = new Size(32, 32);
                    break;
                case Skin.EringiDown:
                    eringiHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/eringiDownS.png");
                    Size = new Size(32, 32);
                    break;
                case Skin.LongEringiTrap02:
                    eringiHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/eringi_L_left02.png");
                    Size = new Size(32, 32);
                    break;
                default:
                    throw new ArgumentOutOfRangeException("skin", skin, null);
            }
        }

        public VanishKiller(Point top,Point triggerTop,Size triggerSize,Skin skin)
            : base(top, new Size(32,32))
        {
            skinHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/eringi_S.png");
            Trigger = new MotionlessObject(triggerTop, triggerSize);
            Trigger.IsSolid = false;
            Trigger.BeHitEvent += () =>
            {
                _isTriggered = true;
            };

            switch (skin)
            {
                case Skin.EringiUp:
                    skinHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/eringi_S.png");
                    Size = new Size(32, 32);
                    break;
                case Skin.EringiDown:
                    skinHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/eringiDownS.png");
                    Size = new Size(32, 32);
                    break;
                case Skin.LongEringiUp:
                    skinHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/longEringiUp.png");
                    Size = new Size(32, 64);
                    break;
                case Skin.LongEringiDown:
                    skinHandle = DX.LoadGraph(@"../../IWBT素材/ブロック/longEringiDown.png");
                     Size = new Size(32, 64);
                    break;
            }
        }

    public RegionAttachment NewRegionAttachment(Skin skin, String name, String path)
    {
        FAtlasElement element = Futile.atlasManager.GetElementWithName(name);
        RegionAttachment attachment = new RegionAttachment(name);

        if(element != null){
            attachment.RendererObject = element;
            attachment.SetUVs(element.uvBottomLeft.x, element.uvBottomLeft.y, element.uvTopRight.x, element.uvTopRight.y, false);
            attachment.RegionOffsetX = 0.0f;
            attachment.RegionOffsetY = 0.0f;
            attachment.RegionWidth = element.sourceSize.x;
            attachment.RegionHeight = element.sourceSize.y;
            attachment.RegionOriginalWidth = element.sourceSize.x;
            attachment.RegionOriginalHeight = element.sourceSize.y;

        }else{
            attachment.RendererObject = null;
            attachment.SetUVs(0.0f, 0.0f, 0.0f, 0.0f, false);
            attachment.RegionOffsetX = 0.0f;
            attachment.RegionOffsetY = 0.0f;
            attachment.RegionWidth = 0.0f;
            attachment.RegionHeight = 0.0f;
            attachment.RegionOriginalWidth = 0.0f;
            attachment.RegionOriginalHeight = 0.0f;

            Debug.Log("Element [" + name + "] not found in Futile.AtlasManager");
        }
        return attachment;
    }

        /// <summary>
        ///  Prepares field with all needed information including UI representation.
        /// </summary>
        /// <param name="properties">information about a field, needed for e.g setting id of field</param>
        /// <param name="road">if not empty, field belongs to some inner class. This fact must be set into fields id.</param>
        /// <param name="skin">defines the look of field</param>
        /// <returns>prepared field with all needed information</returns>
        public AFField prepareField(AFFieldInfo properties, StringBuilder road, Skin skin)
        {

            AFField field = new AFField(properties);
            field.setId(road.ToString() + properties.getId());

            //LABEL
            TextBlock label = buildLabel(properties, skin);
            field.setLabel(label);

            //ERROR TEXT
            TextBlock errorView = buildErrorView(skin);
            field.setErrorView(errorView);

            //Input view
            FrameworkElement widget = null;
            AbstractWidgetBuilder widgetBuilder = WidgetBuilderFactory.getInstance().getFieldBuilder(field, skin);
            if (widgetBuilder != null && (widget = widgetBuilder.buildFieldView()) != null)
            {
                field.setWidgetBuilder(widgetBuilder);
                field.setFieldView(widget);
            }

            //put it all together
            //when field is not visible don't even add it to form;
            FrameworkElement completeView = buildCompleteView(field, skin);
            if (!properties.isVisible())
            {
                completeView.Visibility = Visibility.Collapsed;
            }
            field.setCompleteView(completeView);
            return field;
        }

    public Attachment NewAttachment(Skin skin, AttachmentType type, String name)
    {
        if (type != AttachmentType.region)
            throw new Exception("Unknown attachment type: " + type);

        // Strip folder names.
        int index = name.LastIndexOfAny(new char[] {'/', '\\'});
        if (index != -1)
            name = name.Substring(index + 1);

        tk2dSpriteDefinition def = sprites.GetSpriteDefinition(name);

        if (def == null)
            throw new Exception("Sprite not found in atlas: " + name + " (" + type + ")");
        if (def.complexGeometry)
            throw new NotImplementedException("Complex geometry is not supported: " + name + " (" + type + ")");
        if (def.flipped == tk2dSpriteDefinition.FlipMode.TPackerCW)
            throw new NotImplementedException("Only 2D Toolkit atlases are supported: " + name + " (" + type + ")");

        RegionAttachment attachment = new RegionAttachment(name);

        Vector2 minTexCoords = Vector2.one;
        Vector2 maxTexCoords = Vector2.zero;
        for (int i = 0; i < def.uvs.Length; ++i) {
            Vector2 uv = def.uvs[i];
            minTexCoords = Vector2.Min(minTexCoords, uv);
            maxTexCoords = Vector2.Max(maxTexCoords, uv);
        }
        bool rotated = def.flipped == tk2dSpriteDefinition.FlipMode.Tk2d;
        if (rotated) {
            float temp = minTexCoords.x;
            minTexCoords.x = maxTexCoords.x;
            maxTexCoords.x = temp;
        }
        attachment.SetUVs(
            minTexCoords.x,
            maxTexCoords.y,
            maxTexCoords.x,
            minTexCoords.y,
            rotated
        );

        attachment.RegionOriginalWidth = (int)(def.untrimmedBoundsData[1].x / def.texelSize.x);
        attachment.RegionOriginalHeight = (int)(def.untrimmedBoundsData[1].y / def.texelSize.y);

        attachment.RegionWidth = (int)(def.boundsData[1].x / def.texelSize.x);
        attachment.RegionHeight = (int)(def.boundsData[1].y / def.texelSize.y);

        float x0 = def.untrimmedBoundsData[0].x - def.untrimmedBoundsData[1].x / 2;
        float x1 = def.boundsData[0].x - def.boundsData[1].x / 2;
        attachment.RegionOffsetX = (int)((x1 - x0) / def.texelSize.x);

        float y0 = def.untrimmedBoundsData[0].y - def.untrimmedBoundsData[1].y / 2;
        float y1 = def.boundsData[0].y - def.boundsData[1].y / 2;
        attachment.RegionOffsetY = (int)((y1 - y0) / def.texelSize.y);

        attachment.RendererObject = def.material;

        return attachment;
    }

 /// <summary>
 /// Function invoked after layout.
 /// </summary>
 /// <param name="skin">Skin to use.</param>
 protected override void PostLayout(Skin.Base skin)
 {
     foreach (Base child in Children) // ok?
     {
         child.Position(m_Pos);
     }
 }

        public static void On_Skin_Init(Skin self)
        {
            if ((graphicsTex == null) || (graphicsTex.GraphicsDevice != GnomanEmpire.Instance.GraphicsDevice) || graphicsTex.IsDisposed)
            {
                graphicsTex = CustomTextureManager.GetFromAssemblyResource(Assembly.GetExecutingAssembly(), "Faark.Gnomoria.Mods.Resources.maxButtons.png");
                //Texture2D.FromStream(GnomanEmpire.Instance.GraphicsDevice, Assembly.GetExecutingAssembly().GetManifestResourceStream( "Faark.Gnomoria.Mods.Resources.maxButtons.png"));
            }
            var maxImg = new SkinImage();
            maxImg.Resource = graphicsTex; // warning have to load it here!
            maxImg.Name = "Window.MaximizeButton";
            self.Images.Add(maxImg);

            var mySkinLayer = new SkinLayer();
            mySkinLayer.Name = "Control";
            mySkinLayer.Alignment = Alignment.MiddleLeft;
            mySkinLayer.ContentMargins = new Margins(6);
            mySkinLayer.SizingMargins = new Margins(6);
            mySkinLayer.Image = maxImg;
            mySkinLayer.Height = 28;
            mySkinLayer.Width = 28;
            mySkinLayer.States.Disabled.Index = 2;
            mySkinLayer.States.Enabled.Index = 2;
            mySkinLayer.States.Focused.Index = 0;
            mySkinLayer.States.Hovered.Index = 0;
            mySkinLayer.States.Pressed.Index = 2;
            mySkinLayer.Text = new SkinText(self.Controls["Window.CloseButton"].Layers[0].Text);

            var mySkinControl = new SkinControl();
            mySkinControl.Inherits = "Button";
            mySkinControl.ResizerSize = 4;
            mySkinControl.DefaultSize = new Size(28, 28);
            mySkinControl.Name = "Window.MaximizeButton";
            mySkinControl.Layers.Add(mySkinLayer);
            self.Controls.Add(mySkinControl);
        }

        public SkinManager(string filePath, PictureBox pictureBox)
        {
            _pictureBox = pictureBox;

            // Brushes
            _brushPerType = new Dictionary<ComponentType, Brush>
            {
                {ComponentType.Key, new SolidBrush(Color.FromArgb(Alpha, Color.Blue))},
                {ComponentType.Screen, new SolidBrush(Color.FromArgb(Alpha, Color.Red))},
                {ComponentType.Maximized, new SolidBrush(Color.FromArgb(Alpha, Color.Green))}
            };

            // Path
            SkinPath = filePath;

            _undo = new UndoRedoManager<Skin>(10);
            _skin = new Skin(SkinPath);
            _undo.SaveState(_skin);
            _undo.UndoRedoStateChanged += (o, args) => OnComponentsChanged();

            _pictureBox.Size = new Size(_skin.SkinSize.Width * 3, _skin.SkinSize.Height * 3);

            // PictureBox events
            pictureBox.Paint += (o, args) => Paint(args.Graphics);
            pictureBox.MouseDown += pictureBox_MouseDown;
            pictureBox.MouseUp += pictureBox_MouseUp;
            pictureBox.MouseLeave += pictureBox_MouseLeave;
            pictureBox.MouseMove += pictureBox_MouseMove;
        }

 /// <summary>
 /// Function invoked after layout.
 /// </summary>
 /// <param name="skin">Skin to use.</param>
 protected override void PostLayout(Skin.Base skin)
 {
     foreach (GUIControl child in Children) // ok?
     {
         child.SetPosition(m_Pos, 0, 0);
     }
 }

        protected override void InitializeCore()
        {
            ShowDebug = true;

            Skin skin = new Skin(new TextureAtlas(Context.GraphicsDevice, "Data/uiskin.atlas"));
            skin.Add("white", Color.White);
            skin.Add("red", Color.Red);
            skin.Add("default-font", new BitmapFont(Context.GraphicsDevice, "Data/default.fnt", false));
            skin.Add("default", new TextButtonStyle() {
                Down = skin.GetDrawable("default-round-down"),
                Up = skin.GetDrawable("default-round"),
                Font = skin.GetFont("default-font"),
                FontColor = skin.GetColor("white"),
            });
            _stage = new Stage(Context.Window.ClientBounds.Width, Context.Window.ClientBounds.Height, false, Context.GraphicsDevice);

            Context.Input.Processor = _stage;

            TextButton button = new TextButton("Button " + 0, skin) {
                X = 200, Y = 200, Width = 150, Height = 100,
                /*X = _rand.Next(0, Context.GraphicsDevice.Viewport.Width - 200),
                Y = _rand.Next(0, Context.GraphicsDevice.Viewport.Height - 100),
                Width = _rand.Next(50, 200),
                Height = _rand.Next(0, 100),*/
            };
            _stage.AddActor(button);

            Context.Window.ClientSizeChanged += (s, e) => {
                _stage.SetViewport(Context.Window.ClientBounds.Width, Context.Window.ClientBounds.Height, false);
            };
        }