Please, feel free to share this news to your friends!

If you are interested to test Don’t Feed the Trolls, please contact me by mail or twitter with your device name. Android games will be sent as an apk (How to Install an APK). On iOS, I will need your UDID to create a specific version, that you will simply download and install with Safari.
Thanks for your help, feel free to share this post!

The gameplay is simple : bears and trolls spawn on the screen, you need to feed the bears and slap the trolls with the touch screen. Ten crazy characters add variety to the gameplay. There are four different game modes:

Classic mode:  Successive levels lasting less than a minute, where you need to make a perfect run to get the three stars. The game introduces new characters in each level. There are three unlockable difficulty levels.

100 bears mode: Feed 100 bears as fast as possible. You should probably use both hands on this one to make high scores. Be careful, a single troll hides among them!

Slap Party: Have fun slapping dozens of trolls spawning as fast as possible!

Versus: Play with a friend on the same screen. Feed your bears before your opponent while avoiding to feed the trolls.

Each mode has its multiplatform (iOS/Android) leaderboard. You can also unlock 20 achievements. On iOS, achievements and leaderboard are available in Game Center.

Why I left

At first, I was only selling games that were sold directly from my site. I developed PC and Mac games. However, the last few years, I also developped games on Xbox360 (Indie Games) and I am currently working on mobile games. All these platforms are tied with Microsoft, Apple or Google and I can’t use my own site to sell these games (that’s not totally true as I could sell Android games directly but I think you need to be on Android Market Google Play to get some visibility).

I therefore have very little direct sales these days and Plimus has a big drawback in this case: there is a dormant fee for accounts not selling for a few months. I find this really crazy, and thought about leaving when I first heard about that. They themselves suggest making a “self purchase” to avoid that fee. I suppose you could do yourself a 90% OFF Coupon and only pay a few cents, but that’s still a really bad way to do business in my opinion. This is the main reason I left Plimus.

Additionnaly, Plimus made a change in the way they deal with Paypal payments. They require the payments to be made directly to the vendor (me). You therefore need your own Premium ou Business Paypal account in order to accept Paypal payments. I preferred the old way, where everything was centralized by my ecommerce provider.

Why I chose eSellerate

I needed the following features:
- Accept CC and Paypal payments worldwide
- Can set prices in EUR and USD
- Ability to create coupons
- Can generate serial keys based using my own algorithm
Among the most well-known solutions, there is BMTMicro, eSellerate and Share It. I checked the commission taken by the e-commerce provider (for a $4.99 game):

I logically chose the cheapest one. A few questions to their support to make sure there is no hidden fee (I got a quick and positive reply) and my account is created.
It took me some time to figure out how to set everything up as the interface and wording are different from Plimus but nothing too complicated.
My oldest game is sold $1.99 (Shapy deluxe, my first game). I had a problem as you can’t sell for less than $4.95. I contacted the support and they quickly allowed me to set prices as low as $1. Problem solved, great support, once again!

Tips to switch without trouble

The full process of changing provider was not as difficult as I thought. But there is one reason as to why it went that smooth : I did not hard-code any “buy now” links. Nowhere. All the “buy now” links I used (in-game, on the game page, sent to reviewers, sent to games sites) points to the same url on my own site. The destination is a simple php file where I redirect to the right eCommerce page using header(”Location”). I just had to change the buy now links once in the php files. I’m glad I did it properly from the beginning!

Conclusion

Simple one: I really should have done it before! I will see how eSellerate goes in the long run but the transition was smooth.
Feel free to visit my eSellerate store! Use the coupon “BLOG” to get 30% on any order!. The games on this store are from 2005, 2006, 2008 and 2011, you’ve been warned!
Which provider are you using? Are you happy with it? Do you want to change? Feel free to comment here or contact me on twitter or facebook.

The effect

The shake is a small random movement. It can be applied to any cocos2d node (CCNode). In Don’t Feed the Trolls, I applied the effect to my top-most node, therefore the whole screen is shaking.

The action

I derived my CCShake class from CCActionInterval. The action is initialized with two parameters:
- time : the duration of the effect.
- strength : the distance of the shake movement. You can have different strengths in X and Y if you wish.
You create the action with CCShake::actionWithDuration and send it as a parameter of CCNode::runAction.

// Shake node_to_shake for 5 seconds.
node_to_shake->runAction( CCShake::actionWithDuration( 5.0f, 10.0f ) );

When the action is completed, the node is moved back to its starting position.

Source code

The code is free for personal and commercial use. If you plan to use it, feel free to credit me, send me an email and/or follow me on twitter/facebook. This is of course not compulsory.

Header: CCShake.h

#ifndef __SHAKE_H__
#define __SHAKE_H__

#include "CCActionInterval.h"
using namespace cocos2d;

class CCShake : public CCActionInterval
{
	// Code by Francois Guibert
	// Contact: www.frozax.com - http://twitter.com/frozax - www.facebook.com/frozax
public:
	CCShake();

	// Create the action with a time and a strength (same in x and y)
	static CCShake* actionWithDuration(ccTime d, float strength );
	// Create the action with a time and strengths (different in x and y)
	static CCShake* actionWithDuration(ccTime d, float strength_x, float strength_y );
	bool initWithDuration(ccTime d, float strength_x, float strength_y );

	virtual void startWithTarget(CCNode *pTarget);
	virtual void update(ccTime time);
	virtual void stop(void);

protected:
	// Initial position of the shaked node
	float _initial_x, _initial_y;
	// Strength of the action
	float _strength_x, _strength_y;
};

#endif //__SHAKE_H__

Source: CCShake.cpp

// Code by Francois Guibert
// Contact: www.frozax.com - http://twitter.com/frozax - www.facebook.com/frozax
#include "cocos2d.h"
#include "CCShake.h"

// not really useful, but I like clean default constructors
CCShake::CCShake() : _strength_x(0), _strength_y(0), _initial_x(0), _initial_y(0)
{
}

CCShake* CCShake::actionWithDuration( ccTime d, float strength )
{
	// call other construction method with twice the same strength
	return actionWithDuration( d, strength, strength );
}

CCShake* CCShake::actionWithDuration(ccTime duration, float strength_x, float strength_y)
{
	CCShake *p_action = new CCShake();
	p_action->initWithDuration(duration, strength_x, strength_y);
	p_action->autorelease();

	return p_action;
}

bool CCShake::initWithDuration(ccTime duration, float strength_x, float strength_y)
{
	if (CCActionInterval::initWithDuration(duration))
	{
		_strength_x = strength_x;
		_strength_y = strength_y;
		return true;
	}

	return false;
}

// Helper function. I included it here so that you can compile the whole file
// it returns a random value between min and max included
float fgRangeRand( float min, float max )
{
	float rnd = ((float)rand()/(float)RAND_MAX);
	return rnd*(max-min)+min;
}

void CCShake::update(ccTime time)
{
	float randx = fgRangeRand( -_strength_x, _strength_x );
	float randy = fgRangeRand( -_strength_y, _strength_y );

	// move the target to a shaked position
	m_pTarget->setPosition( ccp( randx, randy) );
}

void CCShake::startWithTarget(CCNode *pTarget)
{
	CCActionInterval::startWithTarget( pTarget );

	// save the initial position
	_initial_x = pTarget->getPosition().x;
	_initial_y = pTarget->getPosition().y;
}

void CCShake::stop(void)
{
	// Action is done, reset clip position
	m_pTarget->setPosition( ccp( _initial_x, _initial_y ) );

	CCActionInterval::stop();
}

Possible improvements

This is really a simple class, for a simple effect. You can improve the effect in many ways. For instance, we could animate the strength of the shake over time.

That's it !

Have fun with it, feel free to discuss the source code in the comments, twitter or facebook.

Are are some of improvements :

• Improved graphics (see screenshot below)
• Intuitive touch gameplay (very cool to slap trolls on a touch screen!)
• More levels
• Many different game modes (more information coming later)
• and other stuff that I’ll reveal periodically

Here is a work-in-progress screenshot showing the new art running on the iPhone simulator (click to enlarge).

The new background is made by Vincent Guibert.

There is no precise release date, the game will be out when it’s done. You can see however that it’s going pretty well. I plan to make a beta because it’s my first mobile game, and I want to test a few gameplay features.

Follow me on facebook or twitter to get more information about Don’t Feed the Trolls and Frozax Games.

As you can this on the top left of this page, I now have a new logo. I hope you’ll like it!

It was made by Amaury Bündgen. You can see his portfolio here.

In 2012, I plan to release games on new targets: iOS and Android. I guess you already knew that according to the recent blog posts. I would like to release at least 3 games on mobile this year. The first two games will be modified ports of Spring Up Harmony and Don’t Feed the Trolls.

Get the latest information about these games with facebook, twitter or google+.

When I developed Don’t Feed the Trolls on X360 (using XNA), I did not optimize the textures files of the game : the game was very simple, the final hardware (X360) is very fast, so it was not necessary. I arranged the sprites so that I could get their coordinates in-game very easily. Every “troll” sprite for instance is the same size, so most of them are filled with transparent pixels. A lot of space is wasted. Have a look at the sprite sheet for the characters that I use on X360.

The characters texture on X360 is 2048×1024. I could easily have it into a 1024×1024 but it was a lot easier if I could have all the sprites of the same kind in a row (for example, all the bear heads are on the top row). I also made a few other sprites sheets for UI, birds, tutorial for instance.

For the first draft of my Android port, I first concentrated on the gameplay and integrate this sprite sheet as is. Of course, I quickly realized I had to spend some time to optimize as obviously, constraints on mobile and X360 are different.

Why packing your textures?

Why is proper texture packing important for games, especially on mobile? Packed textures use less pixels, and from this simple fact, the game is greatly improved in many ways:

Memory

Less pixels takes less memory. Mobile have big memory constraints and saving memory from the ressource is great. Texture ressources are often the biggest ressources.

Loading

There are less files to open, and less pixels to read, this will therefore be faster to load.

Runtime performance

When packing your textures in atlases, more sprites will share the same texture. In runtime, the GPU will then have less textures changes to make and this will therefore speed up your game. This will improve performance if you draw the sprites using the same texture in a row.

It will allow you to reduce your texture sizes. Some Android devices are performing very slowly with 2048 pixels-wide textures.

Game size

The downloadable package size will be smaller too. This is great, especially for people using 3G or with limited bandwidth that won’t download big games.

How to pack?

I first thought of packing my sprites manually but quickly searched for a tool to assist me in that tedious task. There are a few tools available to automatically pack your sprites, and I am currently using TexturePacker, and I’m very happy with it (please note that I got a free copy of TexturePacker from the developer). It’s easy to use and has a lot of functionnalities, such as:

• Auto-refreshes the packed texture in the tool when I add images to my folders
• Export in one click
• Support cocos2d and therefore cocos2d-x which I am using (and many more formats).
• Removes useless transparent pixels around sprites
• Efficient packing

All the features are listed here.

Here is a sample of a packed sprite sheet for the Android version of Don’t Feed the Trolls made with TexturePacker:

Instead of 2048×1024, this is just 1024×1024, and most importantly, I have all my characters, the UI elements, and some background elements in the same, smallest texture!

Generic code

I did some code so that resource loading does not have to deal with packs or single sprites. That way, I can send a version without packs to the artist and he can test his ressource live. In cocos2d-x, this is very easy. You first need to load your pack(s) with CCSpriteFrameCache ::addSpriteFramesWithFile( file_name ). And then, read the ressource from the file if it’s not found in the packs. I did it like this:

CCSprite *GetSprite(const char *file_name )
{
 CCSprite *psprite = new CCSprite( );
 psprite->autorelease();
 // Search in the cache, first
 CCSpriteFrameCache *sfc = CCSpriteFrameCache::sharedSpriteFrameCache();
 CCSpriteFrame *psf = sfc->spriteFrameByName( file_name );
 if( psf != NULL )
 {
  psprite->initWithSpriteFrame( psf );
  return psprite;
 }
 CCLog("WARNING : %s not in a PACK!", file_name );
 psprite->initWithFile( file_name );
 return psprite;
 }

Conclusion

Packing your textures is very important on mobile platform, but hopefully, great tools make that task very easy and straighforward.

Do you pack your ressources? Do you do it by hand? Which tool do you use?

Follow me on twitter, facebook or google+ for more game development information.

In a previous post (here), I was talking about my progress with libgdx, a Java library for Android (and other platforms). Shortly after writing this article, I realized that there is a big disadvantage that I forgot to talk about. It’s so big that it made me stop using libgdx : It is not portable on iOS. I knew this from the beginning but didn’t really think about using anything else than Java. I finally realized that while porting from one language to another is easy, it can take a lot of time.

Cocos2d-x

I searched for multiplatform libraries (Android and iOS). As the game I’m porting (Don’t Feed the Trolls) was developed with XNA, I looked at C# solutions. There is at least one but it’s too expensive. I’ve been doing C++ indie/casual games in the past and I develop in C++ in my day job, so this is the obvious choice. I like the efficiency of languages such as C# or Java (easy to write and debug), but if I want to avoid porting the game another time for the iPhone, I should to use C++. There are quite some libraries in C++ (such as Marmalade). I finally decided to use cocos2d-x. This is a C++ port of the famous cocos2d library for iPhone which is in Objective C. Cocos2d-x has an active community, some multiplatform games have been released already, it’s free and open source. All good stuff!

C++ on Android

I am mostly working using the Windows build of the library but I also did some work on Android. Mixing C++ and Java (using JNI : Java Native Interface) is doable, but really not user friendly. Debugging is terrible, building is slow, you have to install tools such as cygwin, use makefiles (how old school!), and so on. It really does not seem the right solution at first. However, once everything is set up correctly, it’s working fine. Cocos2d-x has good tutorials about this. I develop with Visual C++ 2010 Express on the Windows build, I have all the great tools to debug generic problems. The only real troubles are when you have android-specific bugs in the C++ code but it’s really not frequent. And there are a few ways to debug it with gdb and gdb-server (I never had to use it yet). When you have a crash, there is a very useful tool in the NDK called addr2line (here’s how to use it) that allows you to get the callstack. It’s usually enough to understand and fix the bug. You also can still use old-school debugging techniques such as logging to the output Hopefully, most of my bugs are multiplatform, or in Java code, so I can fix them easily.

Java is still needed

To develop Android-specific code, you still need Java. For example, I use Java for AdMob integration, In-App Purchases or the Facebook SDK for instance. Setting up Java functions called from C++ is not very intuitive, so I opted for a very simple and centralized way: I have one Java function that can be called from C++ with two String parameters. In the Java code, I read these parameters that contains all I need to know to call the specific Java code.

Conclusion

Even though libgdx is really a great lib, after a few weeks working on C++, I’m confident that I made the right choice with cocos2d-x. I did not start developing on iPhone already but it should be quite fast compared to porting Java to C++ (or worse, Objective-C!). I have a working Android version of my game and the performances seems good.

Which language do you use to build your multiplatform mobile games? Do you know other good C++ solutions? Feel free to comment!

Follow me on twitter, facebook or google+ for more game development information.

The sales are better than my first XBL Indie Game (Spring Up Harmony, stats here). However, Spring Up Harmony was initially sold 240 MS Points, and Don’t Feed the Trolls is sold 80 MS Points. Don’t Feed the Trolls was also faster to develop, but art costs were similar to Spring Up Harmony ($500). I need about 750 sales to recover all my costs. I don’t think I will reach this threshold.

I could recover Spring Up Harmony’s costs with the PC version of the game (especially with the 5 For $5 Bundle). I hope to do the same with Don’t Feed the Trolls, and I’m porting it right now on Android (and probably iPhone later). I think the game is too simple to be sold of PC, but mobile phones are great for this kind of game.

As commonly reported by indie developers, I also don’t find the XBLIG platform very lucrative (but it can be).

Feel free to comment about the game the sales statistics or your own experience. You can also find out more about us on twitter, facebook or g+.