Just to round up the overview part of this series where I’ve covered frameworks doing their level best to take the dream of XNA onward and available to more platforms, plus looking further into the future to extend and build upon XNA’s humble beginnings, it’s worth looking over some of the other frameworks which use XNA as a baseline and give you more bang for your buck (time wise).
All of these frameworks depend on XNA so will need one of the aforementioned engine / frameworks to sit on (in fact some are even actively targeting those frameworks already) in order to get going, you can of course still just use vanilla XNA in all its forms, however the "beyond" frameworks and engines just make it more appealing.
So for this little run up I’ve got 5 frameworks to run through, namely:
YNA framework – The Prototype Framework
Nuclear Winter by sparklinlabs
Visual Scripting Framework
XPF – A Layout Framework for XNA
Tiled / TiledLib / xTiled / tIDE – Tile based game engine / editor
(Late Entry)
Gearset – Game monitoring toolset
Nothing too deep but enough to whet your appetite to see if it interests you and encourage you to look deeper, or if you ask nicely / add it to my "Content Voting" page then I may consider adding it to one of the "diving deeper" articles for the XNA Futures series.
*Note
At the last minute I added a new entry to the list following a casual browse through my follower list, Thanks @juancampa for that.
Anyway, on with the show.
I put this first simply because it’s the one that intrigues me the most (at the time of writing because I am a fickle beast) just by its outlandish claims and steadfast delivery, it’s aimed mainly as a fast prototyping tool with some very unique features. Don’t let his put you off mind as there are several games already released using this as their base engine running on top of XNA and others in the works.
Putting it simply, YNA is a game Framework for XNA or MonoGame who allow you to quickly create prototypes and games. It has been inspired by Flixel, an ActionScript 3 Framework for 2D part and a bit by Three.js for 3D.
What you get
YNA gives you the following (Excerpt from the codeplex site)
Features
- Advanced Sprite (static, animated)
- Tilemap and Isometric tiledmap
- State management
- Input management (Keyboard, Mouse, Gamepad and touch)
- Group and hierarchy of graphical objects (Sprite, Text, Image, etc..)
- Audio manager
- Storage manager
- Skinnable GUI module (button, progress bar, etc..)
- Simple terrain, heightmap, cubes
- Camera (FPS, TPS, Fixed)
- And more…
Framework support
As for frameworks, YNA has already been tested with MonoGame On Windows, Windows 8 and Windows Phone (since that’s where MonoGame is focused) but it should also run on all of MonoGame’s other platforms as well. Its not a good fit for UnityXNA but should work with the SunBurn platform API as well when it’s released although it will likely need a few modifications to take advantage of some of the SunBurn Platform API’s advanced rendering features. Unlikely to be compatible with the SunBurn Engine since it’s effectively a competitor. (Although it would be interesting to reuse the InkScape features of YNA with the SunBurn engine as an Add-on, hmm)
MonoGame – YES
UnityXNA – NO
SunBurn Platform API – YES* (Some minor work required)
SunBurn Gaming Engine – NO
Current Status
YNA is still in active development with its latest build being released as recent as 2nd Jan 2013.
Price: FREE – Opensource
NuclearWinter is a set of libraries to develop games and applications using XNA and MonoGame.
A core selling point and the one that got me reading was its InkScape integration. InkScape is an Open Source vector graphics editor, with capabilities similar to Illustrator, CorelDraw, or Xara X, using the W3C standard Scalable Vector Graphics (SVG) file format. I have also got a huge library selection of tutorials and videos to learn how to use it more effectively but I’m still yet to actually get around to mastering it .
Other attempts in the past to use a 3rd part tool with XNA usually resort in either writing complex custom content importers or using a model format as an intermediary mechanism, Nuclear Winters approach seems to be more sensible and more importantly easier to maintain. However at present the functionality for this has been removed from the core code but is still available in the source for use, the developers note though that they may bring it back in the not too distant future (or with additional community support).
What you get
(Excerpt from the site)
The core of NuclearWinter, features game state management, screen resolution handling, an input manager and a user interface library.
Framework support
As with YNA, native XNA and MonoGame are supported with recent check-in’s showing evidence of it being updated to the latest versions of MonoGame for Mac as well. Again UnityXNA doesn’t really apply and some work may be required for the SunBurn Platform API as before. Not suitable for the SunBurn Gaming Engine
MonoGame – YES
UnityXNA – NO
SunBurn Platform API – YES* (Some minor work required)
SunBurn Gaming Engine – NO
Current Status
Nuclear Winter is still in active development with its latest build being released as recent as 6th Jan 2013.
Price: FREE – Opensource
The VSF is a scripting framework that allows you to control the flow of your game and also provides an easy way to storyboard cut scene events, its composition and use is very similar to the PlayReady framework for Unity3D.
The framework becomes invaluable to quickly put core gameplay elements together in your game that would be otherwise tricky to code and give your game that extra shine by adding story elements and an animated background.
I must say that CJ Bailey (@GreedyGoblins) certainly has been a busy chap with this and his several other SunBurn components, all currently still in active deployment / support.
What you get
(Excerpt from the site)
Accelerate your XNA game development
Key Features
- Build and execute scripts easily, in-game!
- Rapid development/prototyping of game logic and cut-scenes
- Quick and easy integration with your existing game.
- Game engine agnostic! Use it with the XNA game engine of your choosing.
- Write custom Script Elements in C# to suit the needs of your game.
- Custom made Script Elements… automatically made available in the Script Editor!
- Save scripts to XML files… load them via the content pipeline.
Overview
The Visual Scripting Framework was born out of my frustration with programmatically creating cut-scenes for my game. My workflow usually ended up being: code cut-scene, build and execute game, wait for game to start (maybe traversing a few menu options in the process), test the cut-scene, find something isn’t right, stop the game, tweak the code, build and execute, wait for game to start, test the cut-scene, stop the game, tweak the…. well… you get the idea. It was driving me mad. I wanted to be able to tweak things while the game was running; that would allow me to try out different ideas and get things just right, without all the tedium of my previous workflow.
The Visual Scripting Framework allows you to build scripts by dragging and dropping script elements into a script. A script element can contain both inputs and outputs which can be connected to other script elements. The Visual Scripting Framework is designed to be game engine agnostic. This means that out of the box the framework doesn’t contain many script elements, since every game engine and every game developer’s requirements are different there is no way I could account for every eventuality. Instead, the framework allows you to load additional components as required or even write your own components which it will automatically detect and make available at runtime.
Framework support
VSF at its core is a XNA derivative and as such is compatible with any framework that is based on XNA but to add to that there are even SunBurn engine components that are woven tightly with SunBurn to take advantage of its extra power and features.
MonoGame – YES
UnityXNA – NO
SunBurn Platform API – NO* (not fully yet but expect update on platform API release)
SunBurn Gaming Engine – YES
Current Status
VSF is a paid for framework and as such is still under support at present with future development plans as expected.
Price $30
The offering through the RedBadger team (@redbadgerteam) is nothing if not Unique, it effectively recreates the XAML rendering engine through XNA graphics processing. Similar to other GUI tools except it also applies the same 3D rotation features as XAML, also it provides similar data binding capabilities to its XAML counterpart.
If you watch some of their example videos you will get a great feel for where it’s heading since you can also meld the XPF components directly on to a 3D surface using the best of both worlds.
What you get
(Excerpt from the site)
Familiar Development Experience
XPF has been specifically designed to be familiar to WPF & Silverlight developers and comes with a collection of out of the box controls, that can be composed together to create flexible layouts in no time at all. The beta launches with the following controls:
- Border
- Button
- ContentControl
- Grid
- Image
- ItemsControl
- RootElement (similar to Window)
- ScrollViewer
- ScrollContentPresenter
- StackPanel
- TextBlock
XPF also supports Dependency Properties, Attached Properties, Animation (currently WP7 only) and Data Binding (one and two-way).
Pure XNA
XPF is designed to run in a pure XNA application, it doesn’t host XNA inside a WPF or Silverlight application. All the controls have been written from the ground-up to work in XNA 4.0 and fit into XNA’s Update & Draw game loop.
Extensible
XPF has been designed to be modular and extensible in two key ways. Firstly, creating custom controls to use alongside the controls you get out of the box is easy. If you’ve ever created a custom control in WPF or Silverlight, using the 2 phase measure and arrange layout system, then XPF gives an almost identical experience.
Secondly, the integration point between XPF and your XNA application has been designed to be extremely flexible. XPF doesn’t really know anything about XNA, it’s written entirely around agnostic interfaces – so whilst XPF comes with a renderer that you can use out the box, should you want to create your own, or integrate to an existing engine, you simply have to satisfy a few core interfaces.
Framework support
XPF is now a community based development and recently got courted by the MonoGame team themselves, so as with most other frameworks based on XNA it should run on any XNA based framework.
MonoGame – YES
UnityXNA – NO SunBurn Platform API – ? (Needs in depth review but should be compatible)
SunBurn Gaming Engine – NO (Not at present but could be enabled for SunBurn as it’s opensource)
Current Status
Unable to ascertain the exact development stats of the project at present since it was pushed opensource, the original devs are not contributing as far as I can tell but others including the MonoGame team have taken a keen interested. The edition before it was made open source was very stable as far as I can tell.
Price: FREE – Opensource
Now this section might get a bit confusing but hopefully it’ll all make sense in the end, what we have are four implementations for what is effectively the same technology.
Tiled started off some many many moons ago as a Tile Map Editor / Generator with a kind of standard "Tile Map Format" (TMX), this allowed level editors to create designs in either flat top down 2D style maps (orthogonal) or 2.5D perspective maps (isometric) for a little more depth.
Nick Gravelyn (@nickgravelyn) kicked things off by creating TiledLib which imported the TMX files and then provided rendering / management techniques for levels, more recently he has dropped the "Processing" part of the Lib to allow developers to apply them how they will. A little while later Michael Neel from GameMarx (@ViNull) and Co-Founder of FuncWorks, while trying to create his awesome entry for the DBP 2012 competition using TiledLib responded to Nicks update and set forth on his own "Fork" called XTiled (technical term to link to another developers code, not the thing you eat with) Nick’s project and take it further to resurrect the full content pipeline importer and graphics rendering engine, this being run strictly the way he wants to use it from his (and colleagues) experience of making games (if you want it another way get your own Fork).
**Note - Had an update from Mike to state that xTiled has moved a ways on and is likely now incompatible with Nick's tiledlib, so just be aware when choosing which of these frameworks to use
In what appears to be a parallel universe another Dev (colinvella) went a different approach to Mike and has rebuilt the entire Tiled Editor from scratch in .NET (the original Tiled Ed was written in C++ / Qt) that can import TMX files if you have them and stores and uses them in a XML variant of TMX, for which the devs have also supplied a Content importer / processor for XNA plus a rendering engine for that format.
Phew, got all that.
What you get
Tiled
(Except from the Tiled Site)
Tiled is a general purpose tile map editor. It’s built to be easy to use, yet flexible enough to work with varying game engines, whether your game is an RPG, platformer or Breakout clone. Tiled is free software and written in C++, using the Qt application framework. The main features in a nutshell:
- General purpose tile map editor with XML-based map format
- Supports orthogonal and isometric maps
- Custom objects can be placed with pixel precision
- Full undo/redo and copy/paste support
- Add custom properties to tiles, layers, objects or the map
- Automatically reloads tilesets when changed externally
- Resize or offset your tile map later as needed
- Efficient tile editing tools like stamp and fill brushes
- Supports input/output plugins to open and save files in custom formats
TiledLib / xTiled
Both are extensions to the XNA framework offering different levels of support for TMX file importing / processing and graphical rendering, together with some map management techniques.
TiledLib is a C# library for utilizing the Tiled map editor for use in a game made with XNA Game Studio 4.0. With the latest version (from 12/2/2011), the library is now targeted entirely to the parsing of the Tiled .TMX files as a Content Importer. This means that your game needs to create an appropriate processor to take the data provided and turn it into the correct types for your specific game.
XTiled is a C#/XNA library for reading and rendering TMX maps created in Tiled Map Editor. The library supports orthogonal and isometric map formats as well as all TMX 0.8.1 map features and has runtime components for PC and Xbox 360.
Project documentation is in the Wiki. There is also a discussion group at XTiled on Google Groups
tIDE
(Excerpt from the tIDE site)
tIDE Tile Map Editor
tIDE is a fully-featured, .NET-based tile editor that allows level designers to easily create content for tile-based games. tIDE supports a custom XML-based map format, a custom binary format (tbin), Tiled TMX, Mappy FMPand Flixel. Additional formats may be included via the .NET-based plugin system within tIDE.
Features
- Intuitive user interface
- Support for multiple tile layers to facilitate the design of games featuring parallax scrolling
- Automatic tile transitioning (autotiles)
- Animated tiles
- Full-featured drawing toolbox to facilitate level design
- Layer ordering and visibility
- Support for an extensive range of display sizes to facilitate alignment when designing multi-layer maps
- Support for arbitrary tile sizes and multiple tile sheets
- Brushes to facilitate reuse of common composite elements
- Multiple file formats (currently tIDE, tBIN, Tiled TMX, Mappy FMP and Flixel formats)
- Full undo/redo capabilities
- Support for custom properties at every level of the map structure
- Full-screen editing mode
- Zooming capabilities
- Map structure navigation and manipulation via the Map Explorer panel
- Intuitive tile picker
- Auto-scrolling capabilities
- Dockable editor components
- Tile sheet auto-update feature to streamline content creation pipeline
- Painless tile sheet rearrangement
- Tile guides and layer viewing options
- Statistics on dimensions and tile usage
- Extensive potential for customisation via a plugin management system
- Built-in help system
xTile Tile Rendering Engine
xTile is a multi-platform tile rendering engine component for XNA-based games.
Features
- Available for
PC, 
Xbox 360, 
Windows Phone 7 and 
Zune*
- Parallax layer support
- Tile animation
- Custom property support at map, layer, tile sheet and tile level
- XNA Content Pipeline Support for tIDE map files
- Automatic validation and asset building of tile sheet image source dependencies in content pipeline
- Customisable XNA content processor
- Map loading interface for multiple file formats
- Native XML-based file format
- Integration with
tIDE
- Abstract display device to facilitate platform extensibility
* For Zune development, you need to use xTile v1.2.5 with XNA Game Studio 3.1
Framework support
As you can see there has been a lot of support for this map format for XNA with two IDE’s and several variations of XNA importers it is certainly in good stead, all that remains is for you to give each a whirl and select the best one that meets your needs. Either Use the original Tiled Editor which has been stable for some time and one of the three importers, if you’re feeling adventurous then you can have a go at writing your own processors from Nick’s great work for your particular needs or leverage Mike’s experience in building games.
The newest member isn’t too shy either and although fairly fresh it shows a lot of promise and bonus features.
MonoGame – YES, YES & YES
UnityXNA – UNLIKELY (however since it is content processor driven the 2D system may be compatible)
SunBurn Platform API – YES* (With a little effort updating the tile renderers for the Platform API way of doing things)
SunBurn Gaming Engine – NO* (out of the box no, however updating the renderer to be SunBurn aware could be very advantageous, especially with SunBurn’s own or the Bepu plug in for Physics)
Current Status
The only one not currently in active Development is Nick Gravelyn’s branch of code but Mike’s work is based on that and extending it so you could argue it still is 
As for tIDE and Tiled, both are still in progressive development cycles, Tiled has fewer releases purely because it’s stable but tIDE is newer and built on .NET so more easily manageable.
Price: FREE – Opensource
This one took me completely by surprise early on the morning when I was about to hit publish, I was browsing my followers list (trying to find one of the contributors above) and one follower in particular caught my eye, namely Juan Campa @juancampa
I had not even heard or seen a whisper about Gearset in all my years of XNA and actually feel worse off because of that, the toolset looks absolutely amazing, enough to stop me in my tracks and pause to add it to this article before publishing, check it out below and you’ll see why.
What you get
(Excerpt from the site)
Features
Here’s a glimpse of what Gearset have to offer to professional and hobbyist XNA developers. New features will be coming soon so stay tuned.
Inspector
Everybody loves Visual Studio’s Watch Window, we definitely do, it shows us in a convenient place the state of our data, and this information becomes extremely important when developing any kind of software and especially when debugging it.
When developing games, the need to break the game execution is sometimes too expensive, the break-modify-continue cycle can become quite slow and unproductive. With Inspector things are different, you have speedy and convenient read/write access to all your fields and properties for easy and productive tweaking. You can drag and drop to assign values, is that easy.
Finder
The Finder is the easiest way to get your game objects into the inspector. By default it will search through your Game’s Component collection but if you have a special object model (for example, a hierarchy of some game entities) you can easily customize the search function to better suit it.
Bender
Need to tweak a curve? Use Bender, Gearset’s integrated curve editor. You won’t have to stop your game execution anymore. You can create curves at runtime, you can also drag and drop it to an object in the Inspector, and you can save them when you’re ready. It’s just awesome.
Overlaid Plots
Want to know how this or that variable is behaving over time? We know you do, knowing it instead of guessing it makes a huge difference and the overlaid plot gear is just for that. Get a real-time, visual representation of your variables and really understand how your game is behaving. You’ll enjoy this one.
Streamed Logging
Writing stuff to the console is an old-school debugging trick we’ve all used which usually works great. It works perfect until we start using it too much and our game’s output starts looking like a real mess with messages from unknowns sources mixed in a single text box of what is now useless garbage.
The Logger gives the programmer a clear view of when and where every log message was generated in a speedy and convenient window. Just open the logger and get really into knowing how your game is doing. The generated log can be saved to a file which is extremely useful when added to a bug report. Your QA sessions’ productivity will be boosted.
Overlaid Geometry
Imagine that you’re trying to solve a bug, you realize that you need to visualize what’s going on better so you decide to draw a line, box, sphere, vector, 3D transform or whatever to get a clearer view of the situation. But you are not inside a Draw method! And the data you need to draw is not available inside any Draw method either. Gearset will help you in this situation, it can draw geometry and remember it so you don’t have to redraw it every frame (useful when data is only available for one frame, e.g. the game is making a decision)
Ease of use
One of the main goals while designing Gearset was to make it a tool that helped development without getting in your way. That’s why everything is conveniently done with a single line of code, take a look at the User Guide examples and see what we mean.
Also, Gearset’s looks are minimalistic in order to take as little resources as possible, we understand that your game needs the resources, Gearset won’t steal them.
More…
- Quick actions: call methods with a button (reset your game, toggle stuff on/off, whatever you can think of)
- Overlaid value tree: show values in a convenient tree view.
- Overlaid text labels: name things in 2D/3D space.
- Alerter: get alerted when something very important happens in your code.
- We have plenty of ideas for future versions of Gearset. If you have some,please let us know and we’ll try to help.
Gearset Pro adds the ability to modify your objects’ fields and properties in real-time from The Inspector. This is the only missing feature in the free version.
To upgrade to Gearset Pro, you simply need to purchase a license and generate a Product Key for your computer.
Framework support
Told you.
As framework support goes Gearset has only been exclusively used on native XNA but after an hour or so pouring over the docs which state "its compatible with any XNA based framework" I have no reason to doubt it wouldn’t work with any of our XNA Futures contenders (except UnityXNA though). I would have to wonder what it would take to get this working with Unity though, maybe a thought to add in to the feature request list.
MonoGame – LIKELY*(The docs state any XNA based framework should be supported however it hasn’t been tested as far as I can see)
UnityXNA – NO
SunBurn Platform API – LIKELY*(With a little effort updating the tile renderers for the Platform API way of doing things)
SunBurn Gaming Engine – POSSIBLY* (As SunBurn is based on XNA, according to the docs it should be supported but hasn’t been tested as yet)
Current Status
Gearset is still in full development and support at present and they seem to have a yearly release cycle, V2 was released in Feb 2012 with the previous release about the same time the previous year.
Not sure if this has waned over the last year with the current state of XNA but the author Juan is still quite active on twitter.
Price:
Final Round-up
Hopefully through this article I’ve shown you some more XNA tricks that viable going forward and which frameworks will work straight away and which need a little a little love but will eventually offer a great deal more. All apart from UnityXNA can make use of these frameworks to make your life easier going forward.
So whether you want to use this as you base with MonoGame or the SunBurn Platform API, or just extend the already extensive SunBurn engine, even possibly use it with Unity3D itself. All these XNA treasures are mint for the taking and helping to build your dream.
*Update
I must say Gearset certainly blew me away by it’s shear scale and capabilities, more so because I hadn’t even heard of it until today, certainly worth a try.
