public FloppyDisc(Game game, SpriteBatch spriteBatch, Texture2D texture, Texture2D overlayTexture, Color color, Color overlayColor,
			Vector2 position, float rotation , float scale, float layerDepth, int points)
            : base(game, spriteBatch, texture, color, position, rotation, scale, layerDepth, points)
        {
            this.overlayTexture = overlayTexture;
            this.overlayColor = overlayColor;
        }

 public void Set(float x, float y, float w, float h, Color color, Vector2 texCoordTL, Vector2 texCoordBR)
 {
   this.vertexTL.Position.X = x;
   this.vertexTL.Position.Y = y;
   this.vertexTL.Position.Z = this.Depth;
   this.vertexTL.Color = color;
   this.vertexTL.TextureCoordinate.X = texCoordTL.X;
   this.vertexTL.TextureCoordinate.Y = texCoordTL.Y;
   this.vertexTR.Position.X = x + w;
   this.vertexTR.Position.Y = y;
   this.vertexTR.Position.Z = this.Depth;
   this.vertexTR.Color = color;
   this.vertexTR.TextureCoordinate.X = texCoordBR.X;
   this.vertexTR.TextureCoordinate.Y = texCoordTL.Y;
   this.vertexBL.Position.X = x;
   this.vertexBL.Position.Y = y + h;
   this.vertexBL.Position.Z = this.Depth;
   this.vertexBL.Color = color;
   this.vertexBL.TextureCoordinate.X = texCoordTL.X;
   this.vertexBL.TextureCoordinate.Y = texCoordBR.Y;
   this.vertexBR.Position.X = x + w;
   this.vertexBR.Position.Y = y + h;
   this.vertexBR.Position.Z = this.Depth;
   this.vertexBR.Color = color;
   this.vertexBR.TextureCoordinate.X = texCoordBR.X;
   this.vertexBR.TextureCoordinate.Y = texCoordBR.Y;
 }

		public static void DrawRoundedBlurPanel(IBatchRenderer sbatch, FRectangle bounds, Color color, float scale = 1f)
		{
			StaticTextures.ThrowIfNotInitialized();

			DrawRoundedBlurPanelBackgroundPart(sbatch, bounds, scale);
			DrawRoundedBlurPanelSolidPart(sbatch, bounds, color, scale);
		}

 public DrawStyle(Color fillColor, float fillAlpha, Color lineColor, float lineAlpha)
 {
     FillColor = fillColor;
     LineColor = lineColor;
     FillAlpha = fillAlpha;
     LineAlpha = lineAlpha;
 }

 private Texture2D CreateTexture(GraphicsDevice graphicsDevice, Rectangle bounds, Color color)
 {
     var texture = new Texture2D(graphicsDevice, bounds.Width, bounds.Height);
     texture.FillWithColor(color);
     texture.AddBorder(Color.Black, 1);
     return texture;
 }

 public Score(int positionX,int positionY,Color color)
 {
     this.positionX = positionX;
     this.positionY = positionY;
     this.color = color;
     score = 0;
 }

 public Button(Vector2 position, Vector2 size, TextureE textureE)
     : base(position, size, Vector2.Zero, 0f, Color.White, getTexture(textureE), Animation.getAnimation(getTexture(textureE)))
 {
     disp = new Vector2(10f, 10f);
     selectedColor = new Color(230, 230, 230);
     LayerDepth = 0.5f;
 }

 public virtual void DrawMenu(SpriteBatch spriteBatch)
 {
     // Fade the popup alpha during transitions.
     _color = Color.White * _transitionAlpha;
     // Draw the background rectangle.
     spriteBatch.Draw(ImageManager.GradientTexture, backgroundRectangle, _color);
 }

 /// <summary>
 /// Crea un objeto tipo GameObject.
 /// </summary>
 /// <param name="effect">Effecto usado para dibujar.</param>
 /// <param name="engine">Clase principal del juego.</param>
 /// <param name="position">Posición del objeto.</param>
 /// <param name="size">Tamaño del objeto.</param>
 public GameObject(Engine engine, Vector3 position, float size)
     : base(engine)
 {
     this.size = size;
     color = Color.LightGray;
     this.position = position;
 }

        public override void Initialize()
        {
            Texture2D texture = GameInstance.Content.Load<Texture2D>("Terrain");
            Color[] colorData = new Color[texture.Width * texture.Height];

            texture.GetData(colorData);

            sbyte[,] data = new sbyte[texture.Width, texture.Height];

            for (int y = 0; y < texture.Height; y++)
            {
                for (int x = 0; x < texture.Width; x++)
                {
                    //If the color on the coordinate is black, we include it in the terrain.
                    bool inside = colorData[(y * texture.Width) + x] == Color.Black;

                    if (!inside)
                        data[x, y] = 1;
                    else
                        data[x, y] = -1;
                }
            }

            _terrain.ApplyData(data, new Vector2(250, 250));

            base.Initialize();
        }

 public FontDescription(string assetName, string text, Color color, Vector2 position)
 {
     AssetName = assetName;
     Text = text;
     Color = color;
     Position = position;
 }

        public TransitionScreen(ScreenManager sceneManager, Texture2D texture)
        {
            SetBasicParams(sceneManager);

            this.texture = texture;
            color = Color.White;
        }

        private Texture2D CreateTexture(Shape shape, object[] textureData)
        {
            // ignore any texture data.

            var bounds = shape.Bounds;
            Color[] colorArr = new Color[bounds.Width * bounds.Height];
            int index = 0;

            for (int x = 0; x < bounds.Width; x++)
            {
                for (int y = 0; y < bounds.Height; y++)
                {
                    index = y * bounds.Width + x;

                    if (shape.Contains(x + bounds.X, y + bounds.Y))
                        colorArr[index] = Color.White;
                    else
                        colorArr[index] = Color.Transparent;
                }
            }

            Texture2D texture = new Texture2D(_renderer.GraphicsDevice, bounds.Width, bounds.Height);
            texture.SetData(colorArr);
            return texture;
        }

 public TextControl(string text, SpriteFont font, Color color, Vector2 position)
 {
     this.text = text;
     this.font = font;
     this.Position = position;
     this.Color = color;
 }

        public StorePurchaseDialog(Scene.ObjectRegistrationHandler registrationHandler, Scene.ObjectUnregistrationHandler unregistrationHandler)
            : base(registrationHandler, unregistrationHandler)
        {
            Height = Purchase_Dialog_Height;
            TopYWhenActive = Definitions.Back_Buffer_Height - (Purchase_Dialog_Height + Bopscotch.Scenes.NonGame.StoreScene.Dialog_Margin);
            CarouselCenter = new Vector2(Definitions.Back_Buffer_Center.X, Carousel_Center_Y);
            CarouselRadii = new Vector2(Carousel_Horizontal_Radius, Carousel_Vertical_Radius);
            _itemRenderDepths = new Range(Minimum_Item_Render_Depth, Maximum_Item_Render_Depth);
            _itemScales = new Range(Minimum_Item_Scale, Maximum_Item_Scale);

            AddIconButton("previous", new Vector2(Definitions.Back_Buffer_Center.X - 450, 175), Button.ButtonIcon.Previous, Color.DodgerBlue);
            AddIconButton("next", new Vector2(Definitions.Back_Buffer_Center.X + 450, 175), Button.ButtonIcon.Next, Color.DodgerBlue);

            AddButton("Back", new Vector2(Definitions.Left_Button_Column_X, 400), Button.ButtonIcon.Back, Color.DodgerBlue, 0.7f);
            AddButton("Buy", new Vector2(Definitions.Right_Button_Column_X, 400), Button.ButtonIcon.Tick, Color.Orange, 0.7f);

            _nonSpinButtonCaptions.Add("Buy");

            ActionButtonPressHandler = HandleActionButtonPress;
            TopYWhenInactive = Definitions.Back_Buffer_Height;

            SetupButtonLinkagesAndDefaultValues();

            registrationHandler(this);

            _textTransitionTimer = new Timer("");
            GlobalTimerController.GlobalTimer.RegisterUpdateCallback(_textTransitionTimer.Tick);
            _textTransitionTimer.NextActionDuration = 1;
            _textTint = Color.White;

            _font = Game1.Instance.Content.Load<SpriteFont>("Fonts\\arial");
        }

        public LevelPortal(World nWorld, Level nLevel, ContentManager nContentManager, Color nColor, Vector2 nPos, OnLevelPortalCollision nDelegate, Hashtable nConfig)
        {
            string nTextureName = "SpriteMaps/Portal";

            base.Init(nWorld, nLevel, nContentManager, nTextureName, nColor, nPos);

            //Populate the Hashtable SpriteMap with the values for the player spritemap
            AddFrame(SpriteState.Portal, 0, 0, 100, 100);
            AddFrame(SpriteState.Portal, 100, 0, 100, 100);
            AddFrame(SpriteState.Portal, 200, 0, 100, 100);

            //Default SpriteState
            SetState(SpriteState.Portal);

            //Manually step the animation to update the sprite Source rectangle
            StepAnimation();

            //Set callback for collisions
            Body.OnCollision += OnCollision;
            Body.OnSeparation += OnSeparation;

            //Other physical properties
            Body.BodyType = BodyType.Static;
            Body.IsSensor = true;
            Body.CollidesWith = Category.All;
            Body.CollisionCategories = Category.Cat30;
            Body.CollisionGroup = 30;
            Body.SleepingAllowed = false;
            Body.Position = nPos;

            OnPortalCollision = nDelegate;

            mLevelId = (int)nConfig["LevelId"];
        }

        public static void DrawString(this SpriteBatch spriteBatch, SpriteBitmapFont font, string text, Vector2 position, Color color, Color outlineColor)
        {
            var previousCharacter = ' ';
            var normalizedText = text.Replace("\r\n", "\n").Replace("\r", "\n");

            var x = 0;
            var y = 0;

            foreach (var character in normalizedText)
            {
                if (character == '\n')
                {
                    x = 0;
                    y += font.LineHeight;
                    continue;
                }

                var data = font[character];
                var kerning = font.GetKerning(previousCharacter, character);

                DrawSymbol(spriteBatch, font, data, (int)position.X + (x + data.Offset.X + kerning), (int)position.Y + (y + data.Offset.Y), color, outlineColor);
                x += data.XAdvance + kerning;

                previousCharacter = character;
            }
        }

 public DnaBar(float valueMax)
     : base(valueMax)
 {
     TwentyProcentColor = new Color(255, 0, 127, 200);
     FiftyProcentColor = new Color(255, 0, 127, 200);
     HundredProcentColor = new Color(255, 0, 127, 200);
 }

 public Tile(Texture2D texture, Color color, int x, int y, bool isWall)
 {
     this.texture = texture;
     this.color = color;
     this.isWall = isWall;
     rect = new Rectangle(x, y, SIZE, SIZE);
 }

        public Net(Vector3 position, int numBlocksX, int numBlocksY, float blockWidth, float blockHeight, Color color)
        {
            this.primitivesCount = numBlocksX + numBlocksY + 2;
            this.primitives = new IPrimitive[this.primitivesCount];

            GenerateNet(numBlocksX, numBlocksY, blockWidth, blockHeight, position, color);
        }