I decided to give a session on XNA game development which turned out to have more people than I expected. I was also shocked to see so many hands go up when I asked how many people used XNA already, then see almost all those hands drop when I asked if anyone launched any games.

What is it that causes people to stop making their game? There must be some reason games are not being completed. My personal opinion… and thats all it is… is that many give up on development when they get stuck on something, bored of working alone, or see their dream of a game becoming a never ending processes of jumping through hoops.

This being said I think its time for us to start an XNA user group in the Boise, Idaho area. A few of us talked after the session and are putting out feelers to see who may be interested. I would like to have at least 15-20 dedicated folks that wouldn’t mind meeting once ever month or 2. I do not want to lead this alone and feel 2-3 leaders would be best. I am going to send out an email to BSDG (Boise Development Group) and see if we get a positive response.

If you are interested in joining an XNA user group please contact me directly or reply to this post.

Also… the demo game from code camp is available for download

River Rush (Code Camp)

For those of us who fly solo, It’s very time consuming and extremely painful to research, build a little, research more… erase what we have done, start again, build a little, research, build, erase, build, research, research, erase, erase all, Start over… you catch my drift.

Well I am in the start over phase, I had a game going (XNA Tanks) about a year ago that I finally have time to come back to. A year later… I am a much better programmer and a new version of XNA is out so I think its time to do this game correct.

What am I going to do other than build a game? I am going to post all the questions I have and every road block I run into. Then as I solve these riddles I will post how, and why when relevant, that way when the next developer going mano-a-mano with XNA doesn’t get blown away within the first couple days.

 /// <summary>
    /// Provides a set of methods for rendering BoundingSpheres.
    /// </summary>
    public static class BoundingSphereRenderer
    {
        static VertexBuffer vertBuffer;
        static VertexDeclaration vertDecl;
        static BasicEffect effect;
        static int sphereResolution;

        /// <summary>
        /// Initializes the graphics objects for rendering the spheres. If this method isn't
        /// run manually, it will be called the first time you render a sphere.
        /// </summary>
        /// <param name="graphicsDevice">The graphics device to use when rendering.</param>
        /// <param name="sphereResolution">The number of line segments
        ///     to use for each of the three circles.</param>
        public static void InitializeGraphics(GraphicsDevice graphicsDevice, int sphereResolution)
        {
            BoundingSphereRenderer.sphereResolution = sphereResolution;

            //vertDecl = new VertexDeclaration(
            effect = new BasicEffect(graphicsDevice);
            effect.LightingEnabled = false;
            effect.VertexColorEnabled = false;

            VertexPositionColor[] verts = new VertexPositionColor[(sphereResolution + 1) * 3];

            int index = 0;

            float step = MathHelper.TwoPi / (float)sphereResolution;

            //create the loop on the XY plane first
            for (float a = 0f; a <= MathHelper.TwoPi; a += step)
            {
                verts[index++] = new VertexPositionColor(
                    new Vector3((float)Math.Cos(a), (float)Math.Sin(a), 0f),
                    Color.White);
            }

            //next on the XZ plane
            for (float a = 0f; a <= MathHelper.TwoPi; a += step)
            {
                verts[index++] = new VertexPositionColor(
                    new Vector3((float)Math.Cos(a), 0f, (float)Math.Sin(a)),
                    Color.White);
            }

            //finally on the YZ plane
            for (float a = 0f; a <= MathHelper.TwoPi; a += step)
            {
                verts[index++] = new VertexPositionColor(
                    new Vector3(0f, (float)Math.Cos(a), (float)Math.Sin(a)),
                    Color.White);
            }

            vertBuffer = new VertexBuffer(graphicsDevice, typeof(VertexPositionColor), verts.Length, BufferUsage.None);
            vertBuffer.SetData(verts);
        }

        /// <summary>
        /// Renders a bounding sphere using different colors for each axis.
        /// </summary>
        /// <param name="sphere">The sphere to render.</param>
        /// <param name="graphicsDevice">The graphics device to use when rendering.</param>
        /// <param name="view">The current view matrix.</param>
        /// <param name="projection">The current projection matrix.</param>
        /// <param name="xyColor">The color for the XY circle.</param>
        /// <param name="xzColor">The color for the XZ circle.</param>
        /// <param name="yzColor">The color for the YZ circle.</param>
        public static void Render(
            BoundingSphere sphere,
            GraphicsDevice graphicsDevice,
            Matrix view,
            Matrix projection,
            Color xyColor,
            Color xzColor,
            Color yzColor)
        {
            if (vertBuffer == null)
                InitializeGraphics(graphicsDevice, 30);

            graphicsDevice.SetVertexBuffer(vertBuffer);

            effect.World =
                Matrix.CreateScale(sphere.Radius) *
                Matrix.CreateTranslation(sphere.Center);
            effect.View = view;
            effect.Projection = projection;
            effect.DiffuseColor = xyColor.ToVector3();

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();

                //render each circle individually
                graphicsDevice.DrawPrimitives(
                      PrimitiveType.LineStrip,
                      0,
                      sphereResolution);
                pass.Apply();
                effect.DiffuseColor = xzColor.ToVector3();
                graphicsDevice.DrawPrimitives(
                      PrimitiveType.LineStrip,
                      sphereResolution + 1,
                      sphereResolution);
                pass.Apply();
                effect.DiffuseColor = yzColor.ToVector3();
                graphicsDevice.DrawPrimitives(
                      PrimitiveType.LineStrip,
                      (sphereResolution + 1) * 2,
                      sphereResolution);
                pass.Apply();

            }

        }

        public static void Render(BoundingSphere[] spheres,
           GraphicsDevice graphicsDevice,
           Matrix view,
           Matrix projection,
           Color xyColor,
            Color xzColor,
            Color yzColor)
        {
            foreach (BoundingSphere sphere in spheres)
            {
                Render(sphere, graphicsDevice, view, projection, xyColor, xzColor, yzColor);
            }
        }

        public static void Render(BoundingSphere[] spheres,
            GraphicsDevice graphicsDevice,
            Matrix view,
            Matrix projection,
            Color color)
        {
            foreach (BoundingSphere sphere in spheres)
            {
                Render(sphere, graphicsDevice, view, projection, color);
            }
        }

        /// <summary>
        /// Renders a bounding sphere using a single color for all three axis.
        /// </summary>
        /// <param name="sphere">The sphere to render.</param>
        /// <param name="graphicsDevice">The graphics device to use when rendering.</param>
        /// <param name="view">The current view matrix.</param>
        /// <param name="projection">The current projection matrix.</param>
        /// <param name="color">The color to use for rendering the circles.</param>
        public static void Render(
            BoundingSphere sphere,
            GraphicsDevice graphicsDevice,
            Matrix view,
            Matrix projection,
            Color color)
        {
            if (vertBuffer == null)
                InitializeGraphics(graphicsDevice, 30);

            graphicsDevice.SetVertexBuffer(vertBuffer);

            effect.World =
                  Matrix.CreateScale(sphere.Radius) *
                  Matrix.CreateTranslation(sphere.Center);
            effect.View = view;
            effect.Projection = projection;
            effect.DiffuseColor = color.ToVector3();

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();

                //render each circle individually
                graphicsDevice.DrawPrimitives(
                      PrimitiveType.LineStrip,
                      0,
                      sphereResolution);
                graphicsDevice.DrawPrimitives(
                      PrimitiveType.LineStrip,
                      sphereResolution + 1,
                      sphereResolution);
                graphicsDevice.DrawPrimitives(
                      PrimitiveType.LineStrip,
                      (sphereResolution + 1) * 2,
                      sphereResolution);

            }

        }
    }

AutoLoL can be found at http://autolol.codeplex.com/
Feel free to download and enjoy the greatness of AutoLoL

A new page regarding all the features will be up shortly…. for now look at Mastery Clicker Page

I have seen many people using a JSON serializer in their code. This is not normally necessary since WebServices should have the cabapility to serialize your object directly. Now lets get started… Your Web Service should look something like this.

[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[System.ComponentModel.ToolboxItem(false)]
// To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.
[System.Web.Script.Services.ScriptService] //Make sure this is uncommented
public class MyWebService: System.Web.Services.WebService
{
        [WebMethod]
        [ScriptMethod(ResponseFormat = ResponseFormat.Json)] //This line is optional!
        public string MyJSONString()
        {
            return "MyJSONString!";
        }

        [WebMethod]
        public List<KeyValuePair<int, string>> MyJSONList(string sample)
        {
            return new List<KeyValuePair<int,string>>(){
                new KeyValuePair<int,string>(0,"MyValue1"),
                new KeyValuePair<int,string>(1,"MyValue2"),
                new KeyValuePair<int,string>(2,"MyValue3"),
                new KeyValuePair<int,string>(3,"MyValue4"),
                new KeyValuePair<int,string>(4,"MyValue5"),
            };

        }
}

Once you have that ready to go, and it looks like this you should be able to make an AJax call to return it as JSON. This is were a lot of people get caught up. You can’t use Jquery’s built in getJSON for reasons unknown to me webservices can only return JSON with a POST not a GET so here is a sample call that works for me. First the string, then the more advanced list.

 $.ajax({
    type: "POST",
    url: "http://localhost/WebServices/MyWebService.asmx/MyJSONString",
    data: "{}", //This is the KEY, Send in an empty object as the data
    contentType: "application/json; charset=utf-8", //this must be added in order to request json
    dataType: "json", //as well as this.
    success: function (data) {
        alert(data.d); //Should = "MyJSONString!"
    }
 });

Now the List, sometimes things get tricky here because as you can see the method requires a string as a parameter. This string needs to be sent in the Data… but remember we have to have a json object in the Data field. so we must send our parameters as a certain way… ‘{sample:value}’ just like that, if there are more you just add a comma ‘{sample:value, arg2:value}’.

 $.ajax({
    type: "POST",
    url: "http://localhost/WebServices/MyWebService.asmx/MyJSONList",
    data: '{sample:"' + myVar +'"}', //This is the KEY if you require arguments
    contentType: "application/json; charset=utf-8", //this must be added in order to request json
    dataType: "json", //as well as this.
    success: function (data) {
        alert(data.d); //Should = "[object],[object],etc"
    }
 });

using FireBug you can see the results of the query

As you can see web services adds a d to the json object… not sure why, but it does. Therefore you might not be able to implement this directly into a plugin that isn’t expecting the d you will have to modify it and then pass it back into the plugin.
But if you are having issues let me know… I’m more than happy to help.