Páginas

iAd patch for ExEn

ExEn is a high-performance implementation of a subset of the XNA API that runs on Silverlight, iOS and Android. (http://exen.codeplex.com/)

From ExEn codeplex site "ON THE FUTURE OF EXEN: I no longer have time to properly maintain and support ExEn (see this blog post for details). On the one hand: ExEn is still an excellent choice for iOS and Android development, due to its stability and performance. On the other hand: I'm not adding new features or fixing bugs (which occasionally crop up when Apple changes something)."

My game for iOs, A comic of zombies (http://itunes.apple.com/us/app/a-comic-of-zombies/id530916013?mt=8), use ExEn. You can visit its website http://acoz.mylittlebets.com/ if you want to download Pc Version or get the lastest news.

Well, the thing is that today I upload a patch for iAd suppot. This and other patchs can be downloaded from http://exen.codeplex.com/SourceControl/list/patches

Enjoy it!

XNA Bezier Curve

A Bézier curve is a type of curve that is easy to use, and can describe many shapes. Bézier curves are famously used for representing characters in fonts, and shapes in vehicle design. Bézier curves are also used in vector art packages for curve drawing, and in 3D animation tools to represent animation paths.

In games, Bézier curves are sometimes useful to describe paths: the racing line in a racing game, or the line in line-drawing games such as Flight Control, or the looping butterfly that enlivens an RPG.

Bézier curves are popular because their mathematical descriptions are compact, intuitive, and elegant. They are easy to compute, easy to use in higher dimensions (3D and up), and can be stitched together to represent any shape you can imagine.


Thanks to http://blog.icode.com/ I can implement a XNA Bezier Curve, here's what it look like.



BezierCurve.cs

using Microsoft.Xna.Framework;

    public class BezierCurve
    {
        public static Vector2 GetPoint(float t, Vector2 p0, Vector2 p1, Vector2 p2, Vector2 p3)
        {
            float cx = 3 * (p1.X - p0.X);
            float cy = 3 * (p1.Y - p0.Y);

            float bx = 3 * (p2.X - p1.X) - cx;
            float by = 3 * (p2.Y - p1.Y) - cy;

            float ax = p3.X - p0.X - cx - bx;
            float ay = p3.Y - p0.Y - cy - by;

            float Cube = t * t * t;
            float Square = t * t;

            float resX = (ax * Cube) + (bx * Square) + (cx * t) + p0.X;
            float resY = (ay * Cube) + (by * Square) + (cy * t) + p0.Y;

            return new Vector2(resX, resY);
        }
    }

Game.cs (main game loop class)
public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Vector2 PlotPoint, p0, p1,p2, p3;

        private Texture2D dummyTexture;

        private float t;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

        ///
        /// Permite que el juego realice la inicialización que necesite para empezar a ejecutarse.
        /// Aquí es donde puede solicitar cualquier servicio que se requiera y cargar todo tipo de contenido
        /// no relacionado con los gráficos. Si se llama a base.Initialize, todos los componentes se enumerarán
        /// e inicializarán.
        ///
        protected override void Initialize()
        {
            // TODO: agregue aquí su lógica de inicialización
            p0 = new Vector2(75, 250);
            p1 = new Vector2(100, 150); 
            p2 = new Vector2(500, 100);
            p3 = new Vector2(550, 200);

            base.Initialize();
        }

        ///
        /// LoadContent se llama una vez por juego y permite cargar
        /// todo el contenido.
        ///
        protected override void LoadContent()
        {
            // Crea un SpriteBatch nuevo para dibujar texturas.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            // TODO: use this.Content para cargar aquí el contenido del juego
            this.dummyTexture = new Texture2D(GraphicsDevice, 1, 1);
            this.dummyTexture.SetData(new[] { Color.White });
        }

        ///
        /// UnloadContent se llama una vez por juego y permite descargar
        /// todo el contenido.
        ///
        protected override void UnloadContent()
        {
            // TODO: descargue aquí todo el contenido que no pertenezca a ContentManager
        }

        ///
        /// Permite al juego ejecutar lógica para, por ejemplo, actualizar el mundo,
        /// buscar colisiones, recopilar entradas y reproducir audio.
        ///
        /// Proporciona una instantánea de los valores de tiempo.
        protected override void Update(GameTime gameTime)
        {
            // Permite salir del juego
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();
            
            var keyboardState = Keyboard.GetState();

            if (keyboardState.IsKeyDown(Keys.R))
            {
                t = 0.0f;
            }
            
            t += (float)gameTime.ElapsedGameTime.Milliseconds / 1000;

            if (t > 1.0f)
            {
                return;
            }

            // TODO: agregue aquí su lógica de actualización
            //for (float t = 0; t <= 1.0f; t += 0.01f)
            //{
                PlotPoint = BezierCurve.GetPoint(t, p0, p1, p2, p3);

                // now call some function to plot the PlotPoint
            //    YourDrawFunction(PlotPoint);
            //}

            base.Update(gameTime);
        }

        ///
        /// Se llama cuando el juego debe realizar dibujos por sí mismo.
        ///
        /// Proporciona una instantánea de los valores de tiempo.
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: agregue aquí el código de dibujo
            spriteBatch.Begin();

            this.spriteBatch.Draw(
                    this.dummyTexture,
                    PlotPoint,
                    new Rectangle(0, 0, 20, 20),
                    Color.Red);

            this.spriteBatch.Draw(
                    this.dummyTexture,
                    p0,
                    new Rectangle(0, 0, 20, 20),
                    Color.Green);

            this.spriteBatch.Draw(
                    this.dummyTexture,
                    p1,
                    new Rectangle(0, 0, 20, 20),
                    Color.Blue);

            this.spriteBatch.Draw(
                    this.dummyTexture,
                    p2,
                    new Rectangle(0, 0, 20, 20),
                    Color.Yellow);

            this.spriteBatch.Draw(
                    this.dummyTexture,
                    p3,
                    new Rectangle(0, 0, 20, 20),
                    Color.Black);

            spriteBatch.End();

            base.Draw(gameTime);
        }
    }



If you want the project source code, just tweet me https://twitter.com/vackup