Ace on Steroids released!

Posted by on Apr 18, 2012 | 7 comments

I made it! Ace on Steroids is now available on the three platforms I intended to get and YOU can get its source code by just getting the game for just around 1 buck (US$1.29, €0.99, £0.79 and 80 MS Points on Xbox 360).

Here is the PR I sent over some online media press:

FOR IMMEDIATE RELEASE

The US$1.29 guide to learn
how to make windows, xbox 360 & windows phone 7 games having fun

ACE ON STEROIDS IS AVAILABLE!

 

PARIS, FRANCE. – April 17th, 2012

Indiefreaks studio proudly announces the release of Ace on Steroids on Windows, Xbox 360 & Windows Phone 7. Ace on Steroids is a beautiful simple top down asteroids shooter game yet the promise lands in the fact that every purchaser of this game will be granted a full access to the game source code and assets.

Their goal is to share their knowledge with as many game developer “wannabees” as possible to support game development creativity and quality.

“By sharing best practices and real examples to a wide audience, we improve the chances to see new game developers joining the party and make great games for us to play” says Philippe Da Silva, Indiefreaks studio owner. “We believe Ace on Steroids players will have a lot of fun making their games and, who knows… Maybe we’ll team up and create some other great games together.”

Ace on Steroids source code will be accompanied with step by step tutorial videos explaining in more details how and why things were done the way they were.

Ace on Steroids is available right now on the following platforms:

About Indiefreaks

Indiefreaks is a one man indie development studio which aims to beat the record and demonstrate fun games can be achieved without the AAA promise.

In order to do so, it aims sharing as much knowledge as possible regarding game development so then other talented people can join in the party;

Thus the creation of the “Indiefreaks Game Framework” open source initiative.

For additional information

You can learn more about Indiefreaks here: http://indiefreaks.com.
You can learn more about the Indiefreaks Game Framework initiative here: http://igf.codeplex.com

read more

Armlessoctopus.com Interview

Posted by on Mar 27, 2012 | 0 comments

Yesterday, 26th March 2012, Dave Voyles published an interview of me sharing my thoughts and why I worked on Ace on Steroids as well as the open source Indiefreaks Game Framework.

You can read it here: http://www.armlessoctopus.com/2012/03/26/phillipe-da-silva-spills-the-beans-on-ace-on-steroids-and-the-indiefreaks-xna-framework/

read more

Ace on Steroids Windows & IGF v0.9.2.0 releases!

Posted by on Mar 22, 2012 | 0 comments

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.
read more

Ace on Steroids Announcement trailer

Posted by on Mar 20, 2012 | 0 comments

I’ve been quiet recently since I had a lot of side things to be done taking me away from game development.

However, I’m back now and I come with a couple of news:

Ace on Steroids announcement

Finally, I am ready to submit Ace on Steroids on 3 platforms (Windows PC, Xbox 360, WP7) and most of it is currently undergoing. I can now estimate a release date for April 2012 with not much worries (and hopefully on the first half of the month).

I am now working on the marketing material that will accompany the game release including PR, screenshots, videos, etc…

I actually have a simple announcement trailer available which I’m sharing with you today:

Ace on Steroids Announcement Trailer
Runtime
1:21
Views
525
Description
Ace on Steroids will be released April 2012 on Windows PC, Xbox 360 and Windows Phone 7 for around US$1.00 or €1.00 depending on your region.

I’m also going over the source code of the game to clean it up and place some useful comments to ease developer’s life finding how things work. Once this is done, I’ll start recording the tutorial videos series with updates probably coming every 2 to 3 days until the end of the series.

Indiefreaks Game Framework v1.0

With Ace on Steroids getting released, I’m way more confident for a v1.0 release of the framework. The game development and tests on the 3 platforms helped me a lot finding bugs or issues with the 0.9.1 release. I still have 2 major bugs to solve before releasing v1.0 but it should be along the lines of Ace on Steroids release date.

Until then, I’ll probably make an intermediate release named v0.9.2.0 since I had a couple of requests from IGF users to get a release build that supports the latest version of SunBurn (2.0.18.7). This build should come later this week as soon as I packaged everything correctly.

With that, I’m back to work and you may expect some more news in the coming days ;)

 

read more

WP7 Virtual GamePad usage

Posted by on Feb 10, 2012 | 4 comments

With the next release of the Indiefreaks Game Framework will come a new feature dedicated to the WP7 builds which will make IGF totally compatible with this platform:

The WP7 Virtual GamePad

The idea behind it is to map player touch input to screen areas which will then transform it into PlayerInput thumbstick directions, button pressed, hold and released states. The developer then has several options to skin a set of controls (Thumbstick, buttons) and define how they should be rendered on the screen.

Here is a video showing what it looks like at the current stage in Ace on Steroids:

IGF WP7 Virtual GamePad in Ace on Steroids
Runtime
0:38
Views
271
Description
Shows an example of how to use IGF's WP7 virtual gamepad feature to handle touch input and render a virtual gamepad.

As you can see, each control can have several options:

  • Should it always render?
  • What if the minimal and maximal opacity response to player input?
  • Should it be static (set at a given position) or dynamic (depends where the player first touches the screen)?

All of it is builtin the InputManager WP7 virtual gamepad feature ;)

Simple mapping setup…

One of the most important requirements I wanted for this feature was a really easy setup system and I’ll show you right here how an Indiefreaks Game Framework user would achieve similar result as in the above video. If you already played with the Windows virtual gamepad mapping, you know how easy it is to map your mouse or keys to it ;)

The first thing you’ll want to do is define the TouchArea instances for the controls you want to provide in your WP7 game.

To do so, somewhere in your game code, ideally in an initialization phase, you’ll write the following code:

PlayerInput playerInputOne = Input.GetPlayerInput(PlayerIndex.One);
playerInputOne.UseWindowsPhoneTouch = true;

playerInputOne.VirtualGamePadMapping.LeftStick = new TouchMap {Static = false, TouchArea= new Rectangle(0, 0, TouchPanel.DisplayWidth/2, TouchPanel.DisplayHeight)};
playerInputOne.VirtualGamePadMapping.Start = new TouchMap { TouchArea = new Rectangle(bounds.Width - 32, 0, 32, 32) };
playerInputOne.VirtualGamePadMapping.A = new TouchMap { TouchArea = new Rectangle(TouchPanel.DisplayWidth -75, TouchPanel.DisplayHeight - 75, 60, 60) };

Let’s now go through this code line by line and explain what we’re doing:

The first line retrieves the PlayerInput instance we want to associate our virtual gamepad with. On WP7, there’s only 1 player in a game so you’ll simple call for the PlayerIndex.One associated instance.

PlayerInput playerInputOne = Input.GetPlayerInput(PlayerIndex.One);

Then we simply tell the PlayerInput instance to use the WP7 touch input. This will just allow the InputManager component to update the PlayerInput with a list of Touch instances retrieved from Xna.

playerInputOne.UseWindowsPhoneTouch = true;

LeftStick

Now comes the fun part ;)
We’ll first start to create the TouchMap instance that will be used for the Left thumbstick. The TouchMap is a simple class that holds a few specific properties from which are computed all the Input logic and rendering.

playerInputOne.VirtualGamePadMapping.LeftStick = new TouchMap {Static = false, TouchArea= new Rectangle(0, 0, TouchPanel.DisplayWidth/2, TouchPanel.DisplayHeight)};

The TouchMap instance for our LeftStick will be set as Dynamic which means that we’ll wait for the player’s first touch in the screen to define where the thumbstick center will be; all values associated to it will be computed based on this center position until the player stops touching the screen. If we had set it to static, the player would have to touch a specific region where you’d probably always render the stick so that he can see which direction he wants to push it to.

The second property set for our LeftStick virtual gamepad mapping is a TouchArea which consists of a some Rectangle representing the region which will be considered to receive dispatched Touch events. In this case, we decided to use the whole left of the screen device.

TouchArea= new Rectangle(0, 0, TouchPanel.DisplayWidth/2, TouchPanel.DisplayHeight)

Note that I decided to make this stick dynamic and have a large TouchArea because the spaceship in my game may be placed behind the stick and therefore be very difficult to see what is going on with player’s input. In a FPS game, this won’t be necessary and the controls can be static and always render to the screen.

Start button

Like in many games, we’ll need a button to pause the game and it’s usually assigned to the Start button on Xbox 360 so we’ll use the same for our WP7 virtual gamepad. This is actually a pretty smart move as since IGF shares the same buttons and sticks for all platforms (Windows, Xbox 360 and WP7), the same code you write to react to a given input will be executed whatever the platform.

This time, we want our “pause” button to always be visible and static so the user knows exactly where to touch to pause his game session. We therefore simply create a TouchMap instance with solely a TouchArea which in our case is placed on the top right corner.

playerInputOne.VirtualGamePadMapping.Start = new TouchMap { TouchArea = new Rectangle(bounds.Width - 32, 0, 32, 32) };

A button

Now, I needed a button for the player to shoot and I decided to map it to the A button.

To do so, I decided to place it on the lower right corner of the screen as you’d expect it to be using a dedicated TouchMap instance.

playerInputOne.VirtualGamePadMapping.A = new TouchMap { TouchArea = new Rectangle(TouchPanel.DisplayWidth -75, TouchPanel.DisplayHeight - 75, 60, 60) };

And now our virtual gamepad is all set.

… and simple skinning setup!

But defining how input is mapped to our virtual gamepad isn’t enough: we also need to define its appearance and how it reacts visually to the player touches.

I maintained the same simplicity requirement as above yet wanted the developer to really be in total control on how it renders to the screen. Here is the code that I used to skin it in Ace on Steroids:

Input.VirtualGamePadSkin.LeftStick.SensibleVisibility = true;
Input.VirtualGamePadSkin.LeftStick.AreaTexture = Content.Load<Texture2D>("Textures/UI/thumbstickBase");
Input.VirtualGamePadSkin.LeftStick.ThumbStickTexture = Content.Load<Texture2D>("Textures/UI/thumbstick");
Input.VirtualGamePadSkin.LeftStick.MaxThumbStickDistance = 30f;

Input.VirtualGamePadSkin.Start.SensibleVisibility = false;
Input.VirtualGamePadSkin.Start.MaxOpacity = 0.5f;
Input.VirtualGamePadSkin.Start.NormalTexture = Content.Load<Texture2D>("Textures/UI/pausebutton");

Input.VirtualGamePadSkin.A.SensibleVisibility = true;
Input.VirtualGamePadSkin.A.MinOpacity = 0.25f;
Input.VirtualGamePadSkin.A.NormalTexture = Content.Load<Texture2D>("Textures/UI/shootbutton");

Simple and straightforward but let’s dig in each of these blocks.

LeftStick skinnning

The InputManager instance has a VirtualGamePadSkin which stores for each input control a set of properties to skin it.

One of the really important values is the SensibleVisibility property which accepts a boolean to tell InputManager if it should always render to the screen at MaxOpacity or only render it when the player touches the screen and slowly fades out to the MinOpacity property value (which ranges from 0 to 1). We’ll go slightly more in detail on the Min and MaxOpacity properties.

For the above mentioned reasons, we don’t want the LeftStick to be visible all the time so we set it to true. Then, it’ll only be visible when the player hits the screen and where he did. The MinOpacity defaults to 0 and the MaxOpacity defaults to 1 so we don’t need to set them manually.

Input.VirtualGamePadSkin.LeftStick.SensibleVisibility = false;

Then, we simply give to our LeftStick skin the paths to our Area and Thumbstick textures.
The LeftStick is actually splitted into 2 rendered controls, the one representing the base of the stick and another for the actual button where you place your thumb. The latter being the one that will move in the whole range of directions from the center of the stick.

Input.VirtualGamePadSkin.LeftStick.AreaTexture = Content.Load<Texture2D>("Textures/UI/thumbstickBase");
Input.VirtualGamePadSkin.LeftStick.ThumbStickTexture = Content.Load<Texture2D>("Textures/UI/thumbstick");

Here is what they look like individually:

Finally, the LeftStick skin has a specific property: MaxThumbStickDistance.

This property will tell the InputManager renderer how far from the center should the Thumbstick be allowed to render. The input for our Sticks will be handled until the player removes his finger from the screen so the player could potentially move his finger far away from the center of the stick and even outside of its TouchArea (the system is smart enough to identify which finger from the multitouch surface is associated to the stick input control). Therefore, you may don’t want the thumbstick to be synchronized to the player’s finger position on the screen and emulate a physical stick like I do in Ace on Steroids. That’s what this property serves for.

Setting its value to 30 means the thumbstick is only autorized to be rendered up to 30 pixels from the stick center.

Input.VirtualGamePadSkin.LeftStick.MaxThumbStickDistance = 30f;

Start button skinning

The Start button skinning is also setting its SensibleVisibility to false so that it always renders at MaxOpacity and is always visible to the player.

Input.VirtualGamePadSkin.Start.SensibleVisibility = false;

We set the MaxOpacity to 0.5 so that it doesn’t occlude what could be rendered behind it.

Input.VirtualGamePadSkin.Start.MaxOpacity = 0.5f;

Buttons in the WP7 virtual gamepad use the TouchArea defined in their VirtualGamePadMapping property as their rendering location so be sure to set them both accordingly: size of the texture should match the TouchArea rectangle width & height.

Finally, we provide the skin with the path to the normal state texture (you could also set a pressed state texture if you want to but we don’t use it in this specific example) which looks like this:

Input.VirtualGamePadSkin.Start.NormalTexture = Content.Load<Texture2D>("Textures/UI/pausebutton");

A button skinning

The A button skinning should now be quite easy to understand if you got previously explained concepts.

It is set to use SensibleVisibility so that it reacts to player’s input touches.

Input.VirtualGamePadSkin.A.SensibleVisibility = true;

However, we still want it to be slightly visible so the player knows where to hit the screen to shoot so we defined a low MinOpacity value. When it gets hit, the button uses its MaxOpacity value and then fades out to MinOpacity when the player removes his finger from the screen.

Input.VirtualGamePadSkin.A.MinOpacity = 0.25f;

And finally, we provide the skin with the path to the normal state texture:

Input.VirtualGamePadSkin.A.NormalTexture = Content.Load<Texture2D>("Textures/UI/shootbutton");

 

I hope it helps you understand how everything works. I expect this to be largely used as it is a common requirement for WP7 games.

This feature will be delivered within the next release of the Indiefreaks Game Framework. Until then, you can grab the latest changeset from http://igf.codeplex.com and start playing with it. It’s fully functionnal ;)

read more
Page 1 of 1712345678910...Last »