Ace on Steroids Windows & IGF v0.9.2.0 releases!

Today is a release day!

Ace on Steroids for Windows

Ace on Steroids just passed IndieCity CAP (Community Approval Process) and is now available on Windows Vista & Windows 7 (32 and 64 bits editions). Browse to the store to see what you get: http://indiecity.com/game/Ace

Other platform releases (WP7 and Xbox 360) as well as Desura’s are getting ready too and I expect a full blown communication about it mid April. At least, that’s what I’m aiming for press wise

IGF v0.9.2.0

On another note, the Indiefreaks Game Framework gets an intermediate release before v1.0 based on requests I received from developers asking for an official release with support for SunBurn engine 2.0.18.7.

It actually is a pretty heavy release even as I’m adding a lot of features I’ve been working on as well as a set of bug fixing and performance improvements.

As usual, you can get the release following this link, its source code here  and the SunBurn Plugin here.

IGF v0.9.2.0 release notes:

• Feature: Added SunBurn engine v2.0.18.7 support (doesn’t support versions below).
• Feature: Added GammaCorrection Post processor to allow developers or even players to tweak the Gamma of the game depending on their screen (courtesy of bamyazi)
• Feature: Added Windows, Xbox 360 & WP7 enabled StorageManager (based on Nick Gravelyn’s EasyStorage) to read/write files for player or game data.
• Feature: Added VirtualGamePad feature for WP7 allowing developers to define Touch areas on screen and mapped gamepad controls.
• Feature: Added IndieCityManager for Windows allowing developers to easily plug IndieCity SDK within their game such as DRM, Achievements and Leaderboards (more information about IndieCity http://developers.indiecity.com)
• Feature: Added support for IGF’s Project Mercury Effect Editor content files. Developers can now create their particle systems in the tool and load them through their Content Projects.
• Feature: Added BEPUPhysicsRenderer manager to IGF Physics assembly allowing developers to see physics debugging information in their game (contacts, islands, physics’ bounding boxes, etc…)
• Bug: Fixed a bug in Goal driven AI where the implemented code wouldn’t get processed in rare occasions.
• Bug: Fixed a few trigonometry issues in AutonomousAgent and Steering Behaviors.
• Bug: Fixed a bug on FadeIn/FadeOut transition effects where they could be called at the same time.
• Bug: Fixed a bug in Lidgren Session Client code where SceneEntities and Commands wouldn’t properly register themselves with the server.
• Bug: Fixed a bug in Lidgren Session to allow the creation of 1 player LAN games (previously, it required at least 2 players which wasn’t possible since the session needs to be created to create a lobby).
• Bug: Commands and Behaviors now properly unregister when their Agent’s ParentObject is removed from SunBurn ObjectManager (accross network too).
• Bug: Fixed a bug where some GUI controls wouldn’t get properly refreshed once loaded.
• Bug: Fixed a bug where GUI controls would throw an exception on WP7 if not using a power of 2 size.
• Misc: Added ClearDevice management on the Application class so developers can control when calls to GraphicsDevice.Clear() are performed.
• Misc: Added Application.Run<T>() enabling automatic Exception report on Xbox 360 (useful for Exception tracking on Xbox 360 builds of your games).
• Misc: Developers can now tell their GameStates if they should use a local ContentManager to load content or use the global Application one.
• Misc: Slight performance increase on games using multiple Layers.
• Misc: InputManager can now return useful Keyboard and Mouse helper methods through its KeyboardInputState and MouseInputState properties.
• Misc: Layer.IsVisible property is now set as Virtual allowing developers to override it and react to property changes on their inherited Layer classes (i.e.: GUI transitions)
• Misc: All session implementations now have an additional Starting state set when the StartSession() is called to allow games to setup and synchronize players, scenes, entities and commands before the actual session really starts.
• Misc: Added an Enabled property on Agent, PlayerAgent and NonPlayerAgent classes to allow easy activation/deactivation of their Behaviors and Commands (useful for game pauses or the like).
• Misc: Performance improvement on Behavior and Command processing.
• Misc: Particle assembly is now splitted in two: Indiefreaks.Game.Mercury.dll for Project Mercury implementation and Indiefreaks.Game.Particles.dll for actual SunBurn engine integration (no breaking changes to the API, just internal design).
• Misc: Small performance improvement on ParticleSystem update and rendering.
• Misc: GUI Image controls now set their rendering size based on the texture size (Scale is applied to Texture width and height)
• Misc: GUI Label control has now a readable Font property allowing developers to access Font properties.
• Misc: Added WP7 touch support to GUI.

Abstract Logic & Lidgren implementation headaches

I started working on one of IGF v0.9.0.0 features: the windows network implementation to support the abstract logic services so that Windows Games can easily plug their game logic on a multiplayer game. I decided to use the Lidgren network library for 2 main reasons instead of developing my own network socket code:

First, Lidgren is a very active open source library with multiple comments, issues, discussions and code ckeck-ins per month.
Second, it exposes all the features I need on a network library.

Still implementing the abstract logic processing isn’t an easy task as there are a lot of cases to handle.

I actually found a few issues in the current implementation and after checking in a few source code additions, I decided to create a dedicated branch on the Codeplex source repository as I may potentially break some of the existing assemblies: Indiefreaks.Game.Logic.dll and Indiefreaks.Game.Live.dll mostly.

But this should end up with additional features for the existing libraries especially on the synchronization and overall network state management.

So far, with the current v0.8.0.0 release, the developer would have to handle all the world synchronizing when a new player join while the game session is already started. With the future expected implementation, the framework will handle most of the world synchronization for you.

I’m expecting to work on this on the coming weeks with some good results by the end of November. I’ll share more about it as soon as I get a good alpha version of the code.

Until then, hopefully we’ll see the SunBurn 2.0.17 release somewhen this week and as soon as it is available, I’ll spend some time to make a v0.8.5.0 with its support and move on the Ace on Steroids tutorial videos.

IGF v0.7 news update

I’ve been very busy with life since my last blog entry but stilll a lot happened since then regarding IGF development so I decided to sum them up and make a quick post.

Open Source & Contributors

As I shared with you a couple of months ago, after I called for contributors to help me move IGF forward, I received a few emails asking to participate. So far, I have 3 contributors that would be likely helping building IGF v1.0. They’ll shortly be able to work on the project as I put the team workspace in place.
This workspace will be composed of a source control repository and a set of project management & communication tools. I’m still talking with John from SynapseGaming to prepare that environment and making sure we don’t break any SunBurn EULA rules. I hope to get that working with IGF v0.7 release.

Development status

IGF v0.7 was mainly targeting the Project Mercury particle system implementation and I’m quite satisfied with current status which will probably be on the next release as is. However I also made some R&D on some other aspects and surprisingly I get most of them in a shape that conforts me to expand IGF v0.7 scope.

• Local Session system: IGF v0.7 will let you create local only sessions so that you don’t require Xbox Live to get the Logic domain & features being processed in a single player game.
• WP7 Support: I made IGF v0.7 work on Windows Phone 7 with a few changes. The sole point I didn’t made it through is how to handle WP7 input inside the InputManager: I need to make some more research here to implement best practices. I’m unsure to finalize the WP7 touch input integration within InputManager but I’ll for sure release an Alpha preview of WP7 support as part of IGF v0.7.

I also worked on a few optimizations but didn’t yet get them to work properly so they may not be part of the next release:

• Multithreaded AI execution: as of IGF v0.6, all AI using the Logic domain is executed in the main thread. While this is enough for simple behaviors and/or few agents, with a world composed of a great number of agents or if AI behaviors require more than the 16ms limit per frame (to get 60 fps) this execution pattern may become a problem. I’m therefore working on the Logic & Session domains to process it in a second thread. Almost there but I must ensure that all the Logic is thread safe which isn’t trivial
• Performance control on Logic processing: I’m also implementing some properties in Steering Behaviors, Finite State Machine and Goal Driven AI to provide you with a better control how often their logic gets processed to let you optimize how many times they get called. This will let you optimize their usage depending on your game needs.
• BEPUPhysics Manager: One of the contributors is working on a BEPUPhysics manager implementation that will replace the standard SunBurn CollisionManager instance and respect the ICollisionMove contract set in the SceneObject class. This should let you switch from CollisionManager to BEPUPhysicsManager without making any changes to your code still getting all the features from BEPUPhysics. I didn’t see the code yet as we don’t have the workspace environment setup yet but I’m eager to have a look

Expected release?

Well, since I’m going on vacation the 22nd August until the 3rd September, I don’t want to flew far from any internet connection without pushing v0.7 up for you to play with.

You should therefore expect a release before the 22nd August

More than expected…

If you followed my previous blog entry as well as my tweets, you may have noticed that I got Mercury particle system integrated quite quickly to IGF v0.7 and SunBurn. Therefore, I decided to implement a small additional feature as part as the v0.7 release: Local sesion system.

LocalSessionManager

Up to now, the sole way to get the Logic system coming with IGF was to use the LiveSessionManager which wraps Xbox Live networking. But what if you are developing a Windows title? What if you don’t care about multiplayer but still want to use the IGF Logic system?

I had that in mind from the beginning when I conceived the level of abstraction surrounding the Logic and Network namespace in IGF and it was time to get a proper session system.

I have now a fully working local only session system for you to play with the Logic code. From my early tests, I already plugged the system with my own game (Cosmos Conflict) as well as the Pong sample accompanying IGF releases so far with just a single line change in the code. In the Application.InitiallizeSunBurn() method, instead of using:

SunBurn.AddManager(new LiveSessionManager(this));

I simply replace it with:

SunBurn.AddManager(new LocalSessionManager(this));

With this single line changed, all the logic code I used including the AI code coming with v0.6 (Goals, States, Steering Behaviors), all works like a charm.

I’m really pleased to see that working as I expected. If you want to develop your game, you’ll now be able to develop the single player game logic using the LocalSessionManager and if you want to port your game to Xbox, simply change it to LiveSessionManager and done!

Windows Phone 7 support

This session system was also the sole feature in IGF that couldn’t be ported to WP7 impeding me to release such build. Now that I have a local session system ready, I’ll experiment porting the whole framework to WP7. If I get it close to work before the end of the week, I’ll consider WP7 support as part of v0.7 release

I’ll try to keep you updated with my progress.

IGF v0.4 released!

It took a bit longer this time to get the new Indiefreaks Game Framework version released but there are a lot of work done and 2 new main features to help you making your games.

I spent a lot of time working on the new Abstract Networking system and the first implementation on Xbox Live (I’ll soon be working on a Lidgren implementation for Windows) as well as the new Sprite system but what I’m really proud of is the Abstracted Logic components & Behavior system that works tightly with the Abstract Network feature. This is something I don’t think we’ve seen before and it eases a lot game logic implementation with portability in mind.

Using these newest features, it will be really easy to make single or multiplayer games without having you to take care of managing client or server implementation or either you are using Xbox Live or the future Lidgren API.

The Pong Net sample I added to this release should help you understand how it works and see the power it will bring to your own games.

As always, the IGF source code is included and you can therefore also learn some of the magic Xna and C# brings to us all

Download it now clicking here!

IGF v0.4.0.0 Release notes:

• Feature: Implements SunBurn engine 2.0.13.1 (Click here for release notes)
• Feature: Added a new Sprite system
• Feature: Added Network Abstraction system
• Feature: Added Xbox Live Networking implementation on top of Network Abstraction
• Feature: Added Logic components with support for player and non player behaviors (works on Single player or Multi player mode independently)
• Fix: Now Application.LightingSystemPreferences are applied to SunBurn SceneInterface when created
• Fix: GameState constructor now correctly calling the default optimized 1152*640 SunBurn FrameBuffer constructor which was preventing Deferred renderer to work
• Fix: InputManager.PlayerX could return wrong PlayerInput when using Keyboard & Mouse input in one as one of the PlayerInput instances
• Fix: RandomGeometry.GetRandomPointInSphere() do not lose its polar coordinates anymore
• Fix: ForwardRenderer and DeferredRenderer now sort SceneEntity instances from back to front as it should always have been 
• Misc: Asynchronous Loading now throws an exception in the main thread when an exception raised while loading content
• Misc: Added a GetPlayerInput(PlayerIndex playerIndex) method to InputManager to allow you to retrieve the corresponding PlayerInput
• Misc: Added IsVisible property to ILayer interface and implementations to enable/disable each Layer rendering
• Misc: Removed IUpdate dependency on Layer class
• Misc: Added BeginDraw(GameTime gameTime) and EndDraw(GameTime gameTime) to ILayer interface and its implementations
• Samples: Modified all samples to reflect SunBurn engine and IGF changes
• Samples: Added new Pong Net Sample to demonstrate Sprite system and SessionManager usages