Spyn Doctor Games

XBLIGs and the Xbox dashboard update 2011

2011-12-09T17:52:00.000+01:00

So here's my take on the recent Xbox dashboard update, and how it affects XBLIGs.

To give the tl;dr first: I think it's horrible how XBLIGs are treated by this update.

And in a few more words:

I think that there are two different problem areas for XBLIGs with the 2011 dashboard.

The first, which somehow overshadows much of the discussion I've read so far, is discoverability - how easy/difficult it is to find the XBLIG section on the new dashboard. I guess there are different opinions here: Some (probably most) are saying it's worse than before, other saying it's not so bad, and others again saying that it simply is Microsoft's right to decide how many "precious" dashboard tiles they want to allocate to XLBIGs. So they decided to put us into a difficult to find corner? I guess we have to deal with that...

This alone is of course already a big problem, but then, what totally baffles me, layered on top of this is the second problem:

Even there, inside our already hidden XBLIG corner, Microsoft continues to make our XBLIG dev lives difficult by removing all options for filtering the huge game list! So we now have a single huge list with currently >2000 entries (and growing) that can be sorted in four different ways (by release date, by rating, by downloads, by title), but no way to filter it! That means that any game that happens to not be among the say first 100 under any of these four sort methods, is virtually invisible. There is no way for a user to find it unless he already knows the name and bings it. Because face it, nobody will scroll to the right more than about 100 games (if even so many) and scan through the covers to find a game.

I understand (even if I don't like it) that MS doesn't want to include XBLIGs in the "main" new-release lists, or in the main "by-genre" or "by-first-letter" lists, where AAA and XBLA games live. But why on earth did they not at least give XBLIGs their own "by-genre" and "by-first-letter" filtering? Or at least a "skip to next letter" option in the "by title" list?

My only conclusion is: They either totally don't care about XBLIGs so they didn't realize this omission. Or they consciously left it out to marginalize XBLIGs even more. Both versions shed a very very dire light on the future of XBLIG. No matter which death we die, the passive one because no one cares, or the active one because we are cut down - dead is dead!

So you better have a game that is among the first 100 or so by one of these four sort methods, or your game will virtually be invisible on the service to anyone who isn't actively bing-ing it by name.

My prediction: We'll see an influx of games with a name that starts with a number, to guarantee at least a front slot under the "by title" filtering.

Too bad for me that my last game's name starts with a "Y"! I just timed it: It took me 1:16min(!) to scroll to Your Doodles Are Bugged! under the "by title" sort order. And then it didn't even show me the box art of the game (or the ones surrounding it). Most likely it first had to load the ~2000 box arts of all the other games that I passed on my way to the letter "Y". So I thought I'd just wait a bit until the box art appears - but I gave up after half an hour, when the box art still wasn't showing...

Very, very disappointing...

IndieGala - Pay-What-You-Want Indie Game Bundle

2011-12-06T17:47:00.001+01:00

By now this probably isn't news for you anymore, but anyway, for the record:

Your Doodles Are Bugged! is part of the first IndieGala pay-what-you-want-and-support-charity indie game bundle.

And of course it is not the only game in the bundle. In the main bundle, there is

Hacker Evolution: Duality
inMomentum
Saira
Your Doodles Are Bugged!
Zombie Shooter 2

plus, there's some bonus stuff: two more games (Hacker Evolution: Untold and Zombie Shooter 1), the soundtrack theme for the Zombie Shooter games, and the "Easter Special 2011" bonus doodles for YDAB!. If you buy during the first 48 hours you get it for free, after that, you have to pay above the average to get the bonuses.

All games come in form of separate Steam codes. So the bundle is a great deal even if you already own some games, because you can give away those duplicate codes to family and friends.

So what are you waiting for? Go there and help us "up the average"!

[[[ http://www.indiegala.com ]]]

Rodeo - A New Game in XBLIG Playtest

2011-08-21T18:40:00.001+02:00

It has been a long time, more than one and a half years, since the release of my last XBLIG, during which I was busy with the PC release of YDAB!.

But now, finally, I have another XBLIG in playtest. Working title: Rodeo.

If you are an AppHub peer, check it out here (and here is the matching playtest thread in the AppHub forum, where I also made a post explaining how to play the game).

The version that is in playtest right now is purely a gameplay prototype. So far, it has placeholder graphics only, and no sound effects, music, or any other kind of polish. Based on the feedback I get about the gameplay, I'll decide if I make this into a full game or not. So, if you like it, don't forget to tell me! :-)

Raising Game Prices - I Must Be Mad, Right?

2011-08-03T18:44:00.000+02:00

After thinking about it for a long time (even since before Luke did his Bizarro Sale), I have today raised the prices for my games Your Doodles Are Bugged! and Kuchibi on the XBLIG marketplace (not the PC version!).

Both games are now at 240 MSP. Yep, that's a whopping "you'll-never-be-able-to-pay-this-without-going-bankrupt" 3$ (or 3€). For Kuchibi that is actually the same as its original launch price (I lowered it to 80MSP a while ago), while for Your Doodles Are Bugged! this is indeed an increase.

So I must be utterly mad, right?

Well, probably... But I did it anyway. :-)

I think 3$ is a fair price for these games, if you enjoy them. If you don't enjoy them, then even the old price of 1$ would have been too much. I always felt that, but the XBLIG price race to the bottom (hunting the oh-so-important spots on the top-lists) compelled me to go with a price that was below what I felt fair. Well, I decided to get out of this rat race.

Will some players think this is unfair? Probably. In this age of entitlement, where even other developers(!) write lengthy threads about how something like the Humble Indie Bundle is morally suspect because it is just "guilt-tripping" the customers, I think that no matter what you do, you will always have someone who complains. Probably even if you give the game away for free. So if anyone thinks that the new price is unfair, then by all means, do not buy the games!

And last but not least, it's an interesting experiment to see if (and how) sales are affected by this.

XNA GameComponent for IndieCity Integration

2011-07-31T16:52:00.007+02:00

By now you have probably already heard of IndieCity, the upcoming new portal for indie games.

IndieCity is currently still in closed beta, for invited developers only, but I'm fortunate enough to be among the invited, so I'm already in the process of implementing integration with the IndieCity achievement and leaderboards system into Your Doodles Are Bugged!.

For this I have created a nice little XNA GameComponent that wraps all the nitty gritty details of the ICLIB (IndieCity's underlying development library) to make it easily accessible in a XNA game.

And I thought I might share this component with all the other XNA developers out there, so here it is:

Download IndieCityComponent-2011-11-27.zip

I hope that this may help some of you with your own IndieCity integration. There's actually only a single class file, and the source code contains a detailed description of how to integrate and use the component. For the curious of you, I've also quoted that description below. This is a work in progress and will evolve as the ICLIB matures. Any insights, ideas, suggestions and questions are welcome. Just post a comment below or contact me. Or even better: Post in the discussion thread about my component on the IndieCity forum:
http://www.indiecity.com/forum/viewtopic.php?f=20&t=118

Happy programming!

EDIT: Since I made this blog post, I have made updates to my component. I changed the download link above to point to the latest version of the component, but the description below is still the now outdated description of the very first version. Please see the IndieCity forum thread that is linked above for the updated description and the changes I made.

IndieCityComponent - a XNA GameComponent for the integration with the IndieCity ICLIB, with support for achievements and leaderboards.

Developed with ICLIB version 1.0.1.2849.

Compatible with XNA 3.1, XNA 4.0 and .NET 2.0 (or later).

The goal was to create a GameComponent that is easy to integrate into a XNA game and that does all the session updates, state management and event handling for you, so that you don't have to deal with them yourself.

Disclaimer: This component was written against a beta version of the ICLIB, for which the documentation at this time is rather incomplete. Therefore, if something in the code seems strange to you, then this may be because I was forced to work around some peculiar behavior in the current ICLIB (of course it may also be because I just didn't understand the ICLIB properly ;-).
Some of the code is also untested. For example the methods for paging a leaderboard are kind of hard to test if the only leaderboards I can test with are either empty or have only a single entry (i.e. my own). Similarly, some methods are untested because the underlying method in the ICLIB itself is still not implemented (for example "RequestLastPage").
The component will likely change a bit in future versions, as the ICLIB matures.

Integrating the Component With Your Game

This is very simple. First some preparation:

- Install the ICLIB (or ICSDK).

- Add ICEBridge, ICECore and ICELanda to the "References" section of your game
(you find them on the "COM" tab of the "Add Reference" dialog).

- Add the IndieCityComponent.cs file to your project.

- Edit the namespace in that file to match your project.

Then in your main Game class, add a member for the component. Let's assume that you called this member "mIndieCityComponent". Then add the following to the Initialize method of your Game class:

mIndieCityComponent = new IndieCityComponent(
"11111111-2222-3333-4444-555555555555", // replace with GameID
"66666666-7777-8888-9999-000000000000", // replace with Game Secret
true, // replace with false if your game has no achievements
true, // replace with false if your game has no leaderboards
this);
Components.Add(mIndieCityComponent);

That's it. :-)

IndieCity Component Properties

The component exposes the following properties:

SessionActive: "true", if the IndieCity session is connected, "false" if not.

UserId: The IndieCity ID of the current user.

UserName: The IndieCity user name of the current user.

SessionEndDelegate: A delegate that is called after the IndieCity session ends for some reason (see below for details).

Starting an IndieCity Session

Before you can do anything with the component, you need to start an IndieCity session. So at a convenient location in your code, add the following:

mIndieCityComponent.RequestSessionStart(null);

For example, you could do this after loading the game assets, or at a similar moment.

Note, that this call only begins the process of starting a session. The session will not be completely started immediately, but will take some time to become active.

While the session is not yet active (or hasn't even been started yet), any calls to the achievement or leaderboard related methods will have no effect and will return empty defaults.

To see if the session is active already, you can check the SessionActive property.

Optionally, if you want to be notified as soon as the session becomes active, you can also provide a callback delegate to the RequestSessionStart call (instead of the "null" argument). For example with an in-line delegate:

mIndieCityComponent.RequestSessionStart(delegate()
{
// This code will be called once the session has been
// started and is active.
});

Of course you can also specify any other method as a delegate that matches the ICCNotificationDelegate signature.

Ending an IndieCity Session

Normally, you will probably never need to end the IndieCity session yourself, because the component already ends the session for you when the game exits.

But if for some reason you want to prematurely end the session anyway, you can call:

mIndieCityComponent.EndSession();

While you will usually not need to end the session yourself, you need to be aware that an IndieCity session can also end for some other reason than you ending it actively. For example it could end because there is a network timeout.

Once a session ends, the SessionActive property will be "false" again.

If you want to know the reason *why* the session was ended, and/or if you want to be informed as soon as the session ends (and not only when you check the SessionActive property the next time), you can use the SessionEndDelegate:

After you create your mIndieCityComponent, and before starting the session, set the SessionEndDelegate property to point to a callback method that is to be called when the session ends. For example with an in-line delegate:

mIndieCityComponent.SessionEndDelegate = delegate(IndieCityComponent.SessionEndReason reason)
{
// This code will be called once the session has ended,
// with the applicable reason
}

(Or any other delegate method that matches the ICCSessionEndDelegate signature.)

Another example - light-weight DRM:

If the game is an unlicensed (for example pirated) copy of the game, i.e. if CoAccessControl.LicenseState == LicenseState.LS_NOLICENSE, then after the session starts, the component will immediately end the session again, with the SessionEndReason.NO_LICENSE. That way, in an unlicensed game the component will never be active, so achievements and leaderboards will never work.

Additionally, you can use this as a light-weight DRM that shuts down the game if it is unlicensed, like this:

mIndieCityComponent.SessionEndDelegate = delegate(IndieCityComponent.SessionEndReason reason)
{
if (reason == IndieCityComponent.SessionEndReason.NO_LICENSE ||
reason == IndieCityComponent.SessionEndReason.BAD_CREDENTIALS)
{
Exit(); // replace with the correct code to exit the game
}
}

This callback will automatically close the game if the session ends either because there is no license or because of incorrect user credentials. If however there simply is no internet connection to IndieCity, the game will still run (but of course then you can't access IndieCity achievements or leaderboards).

Indie City Achievements

If you have created a valid achievement set on the IndieCity developers site and have associated it with your game, you can pass "true" for the "hasAchievements" parameter of the component's constructor and then access the achievements through the component.

In this case, when you request to start a session, the component will automatically download all achievement data as part of the session start process.

After the session is started (i.e. SessionAction == true), you can access the achievement related methods to get access to the achievements:

int GetAchievementCount() :
Returns the number of achievements in the achievement set in the IndieCity database.
NOTE: This method accesses the cached achievement data that was loaded when the session was started (or during the last call to RequestAchievementDataRefresh, see below). It does not necessarily reflect the current information in the IndieCity achievement database, if the achievement set has been changed in the meantime.

CoAchievement GetAchievementByID(long achievementID) :
Returns the achievement with the given ID (the ID is defined on the IndieCity developers site). You can then access the achievement details via the returned object.
NOTE: Like above, this method returns information from the cached achievement data!

CoAchievement GetAchievementByIndex(int index) :
Returns the achievement with the given index (where 0 <= index < achivement_count). You can then access the achievement details via the returned object.
NOTE: Like above, this method returns information from the cached achievement data!

bool IsAchievementUnlocked(long achievementID) :
"true" if in the IndieCity achievement database the achievement with the given ID is unlocked for the current user, "false" otherwise.
NOTE: Like above, this method returns information from the cached achievement data! This means in particular, that if an achievement has become unlocked in the IndieCity achievement database in the meantime (through a channel other than the UnlockAchievement method, see below), then the value returned by this method may be incorrect!

void UnlockAchievement(long achievementID) :
Unlocks the achievement with the given ID for the current user in the IndieCity achievement database and stores the same information in the locally cached achievement data.
NOTE: Theoretically you can also unlock an achievement by calling the CoAchievement.Unlock() method directly, but if you do this, you bypass the local achievement data cache. So while the achievement will then correctly be marked as unlocked in the IndieCity achievement database, any call to "IsAchievementUnlocked" (see above) will still return "false" (until you refresh the achievement data again, see below). It is therefore STRONGLY recommended to only unlock achievements through this method!

void RequestAchievementDataRefresh(ICCNotificationDelegate refreshCompleteDelegate) :
Normally you will not have any need to call this method, because all achievement data is already downloaded from the IndieCity server into the local cache while the component starts the session. This includes both the information about the achievements themselves, and the information which of them are unlocked for the current user. So once the session is active, you can access this cached data via the methods described above.
However, in some situations you may want to refresh the cached data while the session is already active (i.e. while the game is already running). For example:
If your in-game achievement UI displays the achievement score, and you want to display the "true-score" for an achievement. This true-score can change over time, as more and more players unlock achievements of the game. So when the user views the in-game achievemet UI, the true-score that was cached when the session was started (usually at game start) may already be outdated. If you want to make sure that your UI displays the latest true-score, you can use this method to refresh the achievement cache. Of course if you don't display the true-score in the first place, you don't have to care about this.
If you call this refresh method, then the same data refresh procedure is triggered that is also performed during a session start. The refreshed achievement data is not available immediately after the call returns, but takes a while to be fetched from the server. So normally you will want to supply a delegate for the "refreshCompleteDelegate" parameter, which is called as soon as the achievement refresh has finished.
NOTE: Do not call this method a second time while the previous request is still pending, i.e. do not call it again before the "refreshCompleteDelegate" has been called back.

IMPORTANT: Do not call any of the achievement related methods if you have passed "false" for the "hasAchievements" argument in the constructor. If you do, the behavior of the methods is undefined and may cause exceptions or otherwise unexpected behavior.

Indie City Leaderboards

If you have created a valid leaderboard set on the IndieCity developers site and have associated it with your game, you can pass "true" for the "hasLeaderboards" parameter of the component's constructor and then access the leaderboards through the component.

After the session is started (i.e. SessionAction == true), you can access the leaderboard related methods to get access to the leaderboards:

void PostLeaderboardScore(int leaderboardID, long score) :
Posts an entry with the given score and for the current user to the leaderboard with the given ID in the IndieCity leaderboard database (the ID is defined on the IndieCity developers site).

CoLeaderboardPage RequestOpenLeaderboard(int leaderboardID, int pageSize, ICCLeaderboardPageLoadDelegate pageCompleteDelegate) :
Request the first page of the leaderboard with the given ID. The page will have the given page size. The page object is returned immediately, but will not yet be completely populated. This will take some time. So you will have to store a reference to the returned page and wait until it is populated before you can display it. You also need to hang on to this page object because you will need it for the other page related methods (see below). I.e. before you can call any of the other page related methods, you first need to obtain a page object with this RequestOpenLeaderboard method.
To wait until a page has been populated, you can either poll the CoLeaderboardPage.PopulationState property yourself (in which case you would usually supply "null" for the pageCompleteDelegate parameter), or more comfortably, you can supply a pageCompleteDelegate that will be called as soon as the page is populated. For example with an in-line delegate:

mIndieCityComponent.RequestOpenLeaderboard(1, 10, delegate(bool success)
{
if (success) {
// The page has been populated successfully,
// you can now access its rows.
}
else {
// There was an error during the page population,
// you should not use the associated page object.
}
});

(Or any other delegate method that matches the ICCLeaderboardPageLoadDelegate signature.)

void RequestFirstPage(CoLeaderboardPage page, ICCLeaderboardPageLoadDelegate pageCompleteDelegate) :
Sets the given page (which must have been obtained with RequestOpenLeaderboard) to point to the first entries of the leaderboard that the page belongs to. The number of entries (i.e. the size of the page) depends on the page size that was specified during RequestOpenLeaderboard. For example for page size 10, this call will request entries 1-10.
Just like with RequestOpenLeaderboard, the page will not immediately be populated with the requested entries, but this will take some time. So again, you can either poll CoLeaderboardPage.PopulationState (and supply "null" for the pageCompleteDelegate) to wait until the page is populated, or you can supply a pageCompleteDelegate and receive a callback (with a success flag) as soon as the page is populated. See RequestOpenLeaderboard for details about this delegate.

void RequestLastPage(CoLeaderboardPage page, ICCLeaderboardPageLoadDelegate pageCompleteDelegate) :
Similar to RequestFirstPage, but sets the page to the last entries of the leaderboard.
NOTE: This method does currently not work, because the underlying functionality is not yet implemented in the ICLIB!

void RequestNextPage(CoLeaderboardPage page, ICCLeaderboardPageLoadDelegate pageCompleteDelegate) :
Similar to RequestFirstPage, but sets the page to the next entries of the leaderboard, depending on the selected page size and the entries that are currently in the page. For example (with page size 10), if the page currently shows entries 1-10, then this call will request entries 11-20.

void RequestPrevPage(CoLeaderboardPage page, ICCLeaderboardPageLoadDelegate pageCompleteDelegate) :
Similar to RequestFirstPage, but sets the page to the previous entries of the leaderboard, depending on the selected page size and the entries that are currently in the page. For example (with page size 10), if the page currently shows entries 51-60, then this call will request entries 41-50.
NOTE: I'm not sure if this method works yet (i.e. if the underlying functionality in the ICLIB has already been implemented).

NOTE: Do not call any of these leaderboard releated RequestXXX methods while a previous request is still pending. I.e. do not call any of these RequestXXX methods again if you already have called the same or one of the other leaderboard related RequestXXX methods before, and the pageCompleteDelegate of that previous call has not yet been called back, or the CoLeaderboardPage.PopulationState of the page is still LeaderboardPopulationState.LPS_PENDING.

IMPORTANT: Do not call any of the leaderboard related methods if you have passed "false" for the "hasLeaderboards" argument in the constructor. If you do, the behavior of the methods is undefined and may cause exceptions or otherwise unexpected behavior.

On Using Custom Content to Promote YDAB!

2011-07-14T17:30:00.001+02:00

While preparing for the PC release of Your Doodles Are Bugged!, the folks at Blitz 1UP had a very cool idea for how we could try to grab the attention of game reviewers:

The idea was to use the game's own Doodle Studio to produce a number of special custom levels (i.e. doodles). To be precise, we created an individual custom doodle for each of the main game review sites, incorporating the logo of the site into the doodle. And when giving out the review copies of the game, we would also give the reviewer the matching custom doodle for the site that he (or she) writes for, together with the suggestion to use that level for their review, and to also make it available for download to their readers, so that they too could play it.

Our hope was, that this would have several effects:

We were hoping that the individual custom level, with the site's own logo, would increase the interest of the reviewer in the game, so that he would feel motivated to play (and hopefully review) the game in the first place.
Also we thought that the reviewer might like the chance to offer his readers a free goodie, in form of the downloadable doodle. This too would hopefully convince a few reviewers to write a review who otherwise might have passed.
And of course we imagined that getting a free custom level from the review site would motivate a few readers to also download the trial version of the game, so that they would be able to actually try out the free doodle. (And hopefully they would then like the game enough to actually buy it.)

All in all, it sounded like a great idea and several people at Blitz 1UP put a lot of effort into creating these custom doodles. And I would like to use this opportunity to thank them again for this great help!

Well, it still sounds like a good idea, in my opinion. Only for my game Your Doodles Are Bugged!, it turned out that it didn't actually work like we hoped.
None of the reviewers made the doodle available to their readers as a download, and only a very few even mentioned it at all. For example the reviews at the larger sites like IGN and Gamespot, even though quite positive, did not mention the custom doodle at all.

So the question is: Was it worth the effort to create the custom doodles? We don't really know. It seems as if those doodles were largely ignored and did not have much effect. But of course they still might have had some effect behind the scenes, like sparking an interest in the game in the first place, even if the reviewer did not end up using or mentioning the doodle in the review. It is really hard to tell.

But that's how it goes when you try to promote a game: Some ideas work out and some don't, and for some, you just don't know.

The one thing that is frustrating though is, that all these lovingly crafted doodles did not end up where they would do the most good: In the hands of the players, who could enjoy them in the game.

So let's fix that!

Download the custom doodles here: [Download]

The above link downloads a ZIP file that contains all the custom doodles that we made for the review sites. This are 22 new doodles in total!
To play these doodles, unzip the 22 doodle files to a temporary folder and then import them (one by one I am afraid) into the game by using the [Import] button in doodle studio. Note, that these doodles are "DLC-style doodles", i.e. you can only play them, but can not edit/change them in doodle studio yourself. But on the other hand, there is also no "minimum-level" requirement. Everyone who has unlocked the doodle studio will be able to import and play these doodles.

Have fun!

Save 50% on Your Doodles Are Bugged!

2011-07-03T00:32:00.000+02:00

As part of the Steam Summer Camp Sale, you can now save 50% on Your Doodles Are Bugged! (Steam version). Obviously for a limited time only, until the sale is over.

Get the game here: http://store.steampowered.com/app/95500/

Time-lapse video of Doodle #24

2011-05-19T23:40:00.000+02:00

I'm not usually making a blog post for every video I upload on YouTube, but I thought this would be worth it, because it does not only show off the largest and most complex doodle in the game (which might be interesting for you to see if you are considering buying the game and want to know more about it), but it also demonstrates a few strategies and tricks for solving doodles in general.

Of course if you don't want to be spoiled and want to play this doodle with an unbiased mind, you better not watch this video. :-)

Your Doodles Are Bugged! Updated

2011-05-19T13:30:00.000+02:00

The new version 1.1 of Your Doodles Are Bugged! has been released.

The main new features in this version are the save options:

Mid-level saving. If you exit a doodle in the middle of playing it, either to go back to the level select screen or to quit the game, you now have the option to save your progress in the current doodle. When you later return to this doodle, you can then continue where you left it.
This is useful for example if you get called away from playing, or if you can't finish one of the larger doodles in a single playing session.
Checkpoint saving. At any time while playing a doodle, you can now save a new checkpoint (which overwrites the previous checkpoint). Later, you can return to the last checkpoint.
This is useful for recovering from mistakes. For example, if you had already progressed very far in a doodle and everything was running nicely, and then you make a mistake and the s$*#!d bugs fall to their death or get stuck in a particular difficult part of the doodle. Previously, you only had the option of either laboriously fixing your mistake by herding the bugs back to where you want them, or starting over the whole doodle from scratch. Now you can simply return to your last checkpoint - provided that you remembered to save one before you made the mistake! :-)
But be warned: Loading a checkpoint does not reset the clock. So if you are aiming for a new time record, better don't make any mistakes that require you to load a checkpoint!

If you bought the game on Steam, it should update automatically the next time you start it (if you are in online mode at the time).

If you got the standard version from Blitz 1UP, you can get the new version from the same download page where you originally downloaded the game, by re-entering your code. Simply run the new installer and install the new version into the same folder where YDAB! is already installed.

Leaderboards in Your Doodles Are Bugged!

2011-04-29T16:56:00.001+02:00

Over time, and with the different versions of YDAB!, I've programmed several different leaderboard implementations.

The first was of course the global scoreboard in the XBLIG version. Since XBLIGs don't have access to real XBLA leaderboards (and aren't even allowed to use that name, hence the term "scoreboard"), the workaround-of-choice is usually a distributed peer-to-peer solution: Every instance of the game (on the various Xboxes out there) keeps a local copy of the scoreboard content. Whenever the player starts the game, the game automatically searches for other instances of the game that are also running, via the Xbox LIVE network. If it finds another instance, the two instances then exchange their scoreboard data, thus updating each other to the newest "global" state. Scoreboard data thus propagates itself from Xbox to Xbox, sort of like a virus. At least if enough people are playing the game, so that you actually "meet" some other instances of the game online while playing.
I initially implemented such a peer-to-peer scoreboard for my game Kuchibi, and later I used the same implementation (with a few enhancements) in YDAB! too. And of course I've since made the code for it public, and quite a few XBLIGs are now using it (for example Explosionade, radiangames Fireball, radiangames Crossfire 2, Toy Stunt Bike, etc.).

Then came the PC version of YDAB!.

The folks at Blitz 1UP offered me to host global leaderboards for the game on their server, with Facebook IDs to uniquely identify players. Of course I took them up on that offer, :-) and so I implemented another version of the leaderboards. This version communicates with the central Blitz server to store new scores and to retrieve the data when a user browses the leaderboards.
For this browsing, in the XBLIG version I had implemented a page-based UI: You always see one page of the leaderboard (with 10 entries, but that's theoretically variable), and you can page up and down. Of course you can also jump to the first page and to the page that contains your own entry.
I wanted to re-use this UI in the PC version to save me some work. Luckily, Thomas, who did the server side implementation at Blitz, was very accommodating when it came to implementing my wishes. So I was able to specify exactly what kind of access methods for the leaderboard data I wanted, which in turn allowed me to design them in a way that fit nicely with my existing UI.
The implementation now supports all the request I needed for the page-based UI. This includes requests to retrieve the number of entries in the list, to retrieve the current rank of the player, and of course to retrieve a range of entries (a page).

The next step happened when it turned out that YDAB! was accepted by Steam. Because Steam of course has its own leaderboard system, and though I didn't actually ask, I doubt that they would be equally willing to implement my requests as Thomas was. :-)
Well, after reading their API documentation, it became clear that my design of the data access that I had done for the Blitz leaderboards wasn't so bad after all, as the access methods in the Steam API are almost the same. They are so similar in fact, that I could do an almost plug-and-play-style replacement of the Blitz leaderboards code with matching code for the Steam leaderboards. And code reuse makes for one happy programmer! :-)

So there are now three different versions of leaderboards in the various YDAB! versions: XBLIG, Standard Windows, and Steam.

YDAB! - The Vista Crisis

2011-04-24T15:08:00.002+02:00

It's probably a tradition, that even with a software that has been working without problems for a long time during development and testing, a serious bug shows up just when the release date is getting close (or sometimes just after release).

[Warning: This is about to get quite technical!]

This also happened with Your Doodles Are Bugged!. With release scheduled for Monday, on the previous Thursday I get a message from Neil at Blitz 1UP, that the Steam version of the game crashes! But for me it always worked - what can this be? After some more testing by Neil (a lot more, actually - thanks again for that!) the details become clearer. The Steam version only crashes on Windows Vista. It works fine on Windows XP and Windows 7. And on Vista, the standard non-Steam version of the game works fine too. It is only the combination Steam-version + Vista where the game crashes. Which is also the reason why we didn't find this earlier. The game had been tested on Vista, but only the non-Steam version. And the Steam version had been tested too, but only on Windows 7.

The kind of error messages that Neil reported led me to believe that this crash was related to calls into the Steam API. But to find out what was going on, I would have to test this myself.

Which meant that I needed access to a Vista machine. Being only a small indie developer, I do not have a large collection of computers with various OSes. And of the computers I have, none is running Vista (thank god!).
So I ended up ripping out the system disk from my development workstation and temporarily replacing it with a spare disk I had lying around, on which I then installed Vista, VS C# Express and the XNA Game Studio 3.1. This alone was a huge undertaking. Vista installs are so slow! Especially if you then need to have SP 1 too (for GS 3.1). I think Vista downloaded and installed about 125 updates from Microsoft before it was ready to install SP1. And this takes a lot of time!

So a few hours later, I finally had a computer with Vista, and yes, I was able to reproduce the problem. I got the same crash and error messages that Neil had reported. Which was actually good, because reproducing a problem is the first step in fixing it.

As said, my suspicion was that the crash was related to a Steam API call. And a quick run with the Debugger attached confirmed this: The game crashed when it called the achievement init function in my Steam wrapper DLL. In that init function, there was a call into the Steam API that returned NULL when actually it should not, so I ended up with trying to access a NULL pointer reference - with the expected disastrous results.

But why did this call return NULL on Vista, when it worked fine (returning a proper non-NULL object) on Windows 7 and Windows XP?

To be honest, I still don't know. I only know what I changed so that this doesn't happen any longer.

To explain this, I have to explain some background:

The Steam API comes in form of a DLL that is written in unmanaged C++, plus some C++ header files. It can therefore not be used directly in a program that is written in managed C# (the language of XNA, which I also used for YDAB!). Instead you have to do PInvoke calls, where you correctly marshal the arguments and return value of the function call. For complex C++ objects, this marshaling is very difficult (if even possible at all), so the usual solution, which I also chose, is to write a wrapper DLL in C++. In this wrapper, I have code that creates and uses the more complex C++ objects, and that exposes external functions in a way, that these functions are easy to call with PInvoke. So on the C# side, instead of having to deal with the complexities of the C++ objects (and how to marshal them), I only have to deal with the "nice" functions that I exposed in the wrapper DLL.

Some of the Steam API functions however have such a trivial signature, that it is easy to call them with PInvoke directly, without the need for such a "nice" wrapper. For example there is a steam_init function that does not take any arguments and returns bool. Totally trivial to call with PInvoke.

So for a handful of these trivial functions, I did not create stubs in my wrapper, but instead I called them directly from my C# code via PInvoke.

And this, for some reason that I do not understand, created the problem. Or more precisely: There was no problem on Windows 7, which is why I was never aware of this during development. And there doesn't seem to be a problem on XP either, as Neil's testing showed. But on Vista, it just didn't work.

The NULL pointer I mentioned was returned from a call into the Steam API that would normally return a pointer to an object. But only if you had previously called the steam_init function in the Steam API. Of course I had called it (otherwise it wouldn't have worked on Windows 7 either), but I had called it like this:

First my C# code called the steam_init function in the steam_api.dll directly, via PInvoke.
After steam_init returned, my C# code then called the achievement init function in my SteamWrapper.dll, via PInvoke.

In this SteamWrapper, my C++ code then called a function in the Steam API to retrieve a certain object. This call returns NULL if steam_init has not been called before.

This last call should normally return the object, but it returned NULL - at least on Vista - as if I had never called steam_init (which I however had, see the first bullet).

A bit more testing showed me, that there was no problem if I added another call to steam_init directly in the achievement init function of my SteamWrapper code. Which sent me on the right track: It turns out, that if the call to steam_init happens via a direct PInvoke call into the steam_api.dll, but the the later call to another Steam API function happens from code in my SteamWrapper.dll, then on Vista this latter call behaves as if steam_init was never called.

So my solution was to never call any function in steam_api.dll directly. Instead, even for the trivial functions like steam_init, I made stubs in my wrapper DLL, and all my calls would now go through the wrapper DLL. So I now have the following, slightly different flow:

First my C# code calls the steam_init stub in my SteamWrapper.dll, via PInvoke.

In the SteamWrapper, my C++ code then calls the real steam_init function in the steam_api.dll.

After the steam_init stub returns, my C# code then calls the achievement init function in my SteamWrapper.dll, via PInvoke.

In this SteamWrapper, my C++ code then calls a function in the Steam API to retrieve a certain object. And now this call no longer returns NULL!

And this works on Vista too. Crisis averted! :-)

Release Date for Your Doodles Are Bugged!

2011-04-15T18:45:00.000+02:00

Finally I am able to announce the release date for Your Doodles Are Bugged!

YDAB! will be released on

April 25th, 2011 (Easter Monday)

And there will be an Easter surprise too! (which is however still secret...)

This will be the version for Windows PC of course (as the XBLIG version has been released since Feb. 2010 already). It will be released both on Steam and as a standard non-Steam version. Releases on other gaming portals will likely follow at a later time.

Achievements in Your Doodles Are Bugged!

2011-04-06T21:05:00.000+02:00

The PC version of Your Doodles Are Bugged! comes with achievements. In the standard version, they are purely in-game achievements. But in the Steam version, they are of course real Steam achievements.

And they look really cool in the Steam client, in my opinion (although I may be biased on account of seeing my own game in the Steam client is already very cool to begin with :-):

As you can see, there will be 21 achievements in total, 4 of which are secret achievements. Here are the other 17:

Journeyman: Reach the rank of Journeyman Doodler
Master Doodler: Reach the rank of Master Doodler
Campaigner: Complete all doodles of the main campaign
Smoking Pen: Complete all main campaign doodles in a total time of under 3 hours
Pen of Steel: Solve enough doodles for a total completion time of more than 10 hours
Knight in Shining Armor: Rescue ALL bugs in all main campaign doodles (except "Suicide Mission")
Marathon: Solve all main campaign doodles in a single game sesion
Life-Guard: Rescue a total of 10,000 bugs
PWNED!: Beat the developer time in doodle 13, 17 or 18
Deft Touch: Solve doodle 5 "Skydiving Lessons" with a single stroke
Thrifty: Solve doodle 11 "Dancing On The Highwire" without running out of ink a single time
No Regrets: Solve doodle 14 "Ghost From The Bottle" without using the eraser
Quick 'n Slick: Solve doodle 15 "Things That Go Bump In The Night" in 2 minutes after removing the first barrier
Pacifist: Solve doodle 20 "Suicide Mission" without killing a single bug
Work and Play: Create a new doodle and play through it
Mega-Collage: Create a new doodle with at least one element from every main campaign doodle
Collector: Import a doodle that was created by another player

Your Doodles Are Bugged! is coming to Steam!

2011-03-28T22:46:00.001+02:00

WOHOO! - The headline says it all! :-)

This is probably not very important for anyone else, but for me, it is a very big thing. Steam simply is the downloadable PC game platform to be on, and I'm super happy that my little (buggy ;-) game was accepted by Valve.

You might have wondered why I've been so mum about YDAB! development news lately, both here on the blog and on Twitter. After all, my last blog post was last year, and that wasn't even YDAB! related.

It has driven me crazy not being able to write about all the exciting stuff that was happening (and there are still some things that I can't divulge yet, like the release date), but now everything has come far enough that I finally can talk about a few things. So let me give you a short history of how this unfolded.

Well, around the end of last year, when it looked like I had wrapped up all development for the YDAB! PC-version, we started looking into which game portals we wanted to approach about the YDAB! release. "We", that is the awesome people at Blitz 1UP, who are helping me with this. The portal of choice would of course be Valve's Steam, so that's where they pitched the game first. Only I couldn't talk about that, since at that point it was of course very uncertain how it would turn out.

And then, actually quite quickly and much sooner than I had thought, we got the green light from Valve! YDAB! would indeed be coming to Steam! You can imagine the victory dance I did when I got those news! :-)

Only of course I still couldn't talk about it, since everything was still in a much too early stage.

But behind the scenes I got busy... Remember my "The todo-list is now empty" tweet a while ago? - Ha! I should have know better than to twitter something like that! Suddenly I had a new set of tasks on the list: Integration with Steam, meaning the support for Steam achievements, leaderboards and cloud storage.

All very cool features that I absolutely wanted to have in my game, but it also meant learning how to use the Steam SDK (which, to complicate things, is in unmanaged C++, and YDAB! is XNA and thus in managed C#). And of course it also meant programming a lot of new stuff. Especially for the achievements, since of course I had to actually have some achievements first, before I could make them into Steam achievements.

And that's what I've been busy with lately (well, and creating a lot of assets and marketing material, of course). While I couldn't twitter about it while I worked on this stuff, I'm planning to do a few blog posts in the near feature. Coming soon!

Global scoreboard component for XNA 4.0

2010-12-23T19:05:00.003+01:00

I have now updated my global scoreboard component to make it compatible with XNA 4.0.

Such global scoreboards are a XBLIG-workaround for the missing leaderboards. They use a peer-to-peer mechanism to distribute the scores via Xbox LIVE, from player to player. This here is my implementation for such a global scoreboard, now ready for XNA 4.0.

Download the component for XNA 4.0 here:

OnlineDataSyncManager-XNA4.0-20110120.zip

See the readme.txt in the ZIP file for details about how the component works and how to integrate it into your game. You may also want to visit the thread about my component on the App Hub forum, for more useful information sprinkled through the questions and answers there.

It was actually quite simple to make the component compatible with XNA 4.0: I just had to remove a statement where the Thread.Priority was set, and had to #ifdef a few Debug.Write statements so that they are only active in the Windows configuration. Everything else was already good for XNA 4.0.

From now on, if I implement any further fixes or changes, I will only implement them in this XNA 4.0 version. I will no longer maintain the version for XNA 3.1 (but you can still download it from my original blog entry, if you absolutely want to).

It's Bonus Time - Bonus Doodle Time!

2010-11-28T18:58:00.000+01:00

I have now finished all 25 bonus doodles that will be included in the WinPC version of Your Doodles Are Bugged! These bonus doodles will be unlocked one after the other, as the player finishes the doodles in the main campaign.

Here is a collage showing all bonus doodles at once:

(click for larger view)

Time-Lapse Video: Creating a Bonus Doodle

2010-11-19T18:04:00.000+01:00

Below is a time-lapse video of how I created the bonus doodle #8 for the upcoming Windows PC version of Your Doodles Are Bugged!.

The doodle is based on the famous picture of a hare, by Albrecht Dürer. I created it in Doodle Studio, so everything you see in the video was done in the in-game editor. I used an image of the hare picture as a backdrop template, on which I then created the doodle, by combining only existing elements from the doodle palette. Everything you see in the video, you will be able to do yourself in the game (well, if you are capabable of working at 4x time-lapse speed).

This bonus doodle, and many others, will be available in Your Doodles Are Bugged! (WinPC) as unlockables, to play through, or to edit/change/experiment with in Doodle Studio.

A very special "Bug Report"

2010-11-04T23:16:00.000+01:00

I just got a very special "list of bugs" in YDAB!, from a concept artist at Blitz Games Studios. The list was in form of an image. It's so cute, I just had to share it with you:

Become a Tester of Your Doodles Are Bugged! for WinPC

2010-11-04T14:38:00.004+01:00

Interested in becoming a pre-release tester of the Windows PC version of Your Doodles Are Bugged! ?

Then go ahead and download the free pre-release demo build below, install it on your Windows PC and start playing (and testing)!

~~Download Your Doodles Are Bugged! - 0.8 - Demo~~
EDIT: I removed the link to the beta version, as the full game is now available. There's a free demo too.

Primarily I am interested in feedback about bugs and compatibility issues:

Did you have any problems with the installation?
Does the game start and run properly?
Any problems with the full screen mode?
Any problems with the mouse control?
If you have a pen tablet, try playing with the pen, any problems with that?

All feedback (also about other issues) is welcome. Please see my contact page for my email address (or just write a comment to this post).

EDIT: The latest demo is now version 0.8.

Improvements of Magic Pen in YDAB! for PC

2010-10-25T18:55:00.003+02:00

In the upcoming PC version of Your Doodles Are Bugged!, I made some improvements to the magic pen, which you can check out in the video below:

The pen now rotates slightly to the right when drawing and to the left when erasing.
There's now an animated rainbow color effect in the ink window: When not drawing or erasing, the color effect appears randomly every now and then. When drawing, the color effect runs in the direction of the pen's tip, to show the ink flowing out. When erasing, it runs in reverse direction, to show the ink flowing back in.
There's now also a very slight additional frame around the ink window to make it stand out a (tiny) bit more.

Global Leaderboard for YDAB! on Windows

2010-09-21T18:28:00.001+02:00

With the help of the good folks at Blitz 1UP, who are taking care of the server side, I am currently adding support for a global leaderboard to the Windows version of Your Doodles Are Bugged!.

In the XBLIG version, there are of course already global record lists, using the peer-to-peer score distribution system I have recently made public here on my blog.

So I am happy that the Windows version will also have such a feature. Of course on Windows, there is the problem of how to uniquely identify different players.

For the YDAB! leaderboard on Windows, players will be indentified with their Facebook accounts. Which of course means, that to make entries on the leaderboard, you need a Facebook account (and you need to grant the game some access to the account data). But I guess in these times, and especially in the target audience of players that like games like YDAB!, most players will have such an account anyway. And people who are not on Facebook will only miss out on the global leaderboard - all other features of YDAB! will of course be available for them too.

Global scoreboard component for XBLIG, by Spyn Doctor

2010-09-12T18:57:00.005+02:00

On the XNA forums and Twitter, there have recently been a few postings of developers who did not have much luck integrating global scoreboards into their XBLIGs. Such global scoreboards use a peer-to-peer mechanism to distribute scores, to approximate Xbox LIVE leaderboards, which are not available for XBLIGs.

So I decided to finally tidy up my code (mostly comment and describe it) and make my own global scoreboard implementation public, which I have used in Your Doodles Are Bugged! and Kuchibi.

EDIT: This is the scoreboard version for XNA 3.1 (which I no longer maintain with bug fixes or changes). You can find the version for XNA 4.0 here.

You can download it here: OnlineDataSyncManager-XNA3.1-20101223.zip

The ZIP file contains a readme.txt that explains how the component works and how to integrate it into your own game. See also the comments in the source code for more details.

You can use this code however you want, but of course the usual disclaimer comes with this code: Provided "as is", no warranties whatsoever, use at your own risk, etc. etc. See the readme file for the full legal mumbo-jumbo, if you feel masochistic.

EDIT: I have updated the ZIP archive with some changes. Some minor bug fixes, plus I added optional friends-list filtering to the sample implementation for a global scoreboard. And the readme.txt now contains an additional "how-to" about how to write an UI to display the scores from this sample scoreboard.

EDIT 2: The first game (that I know of) that uses my global scoreboard has now been released on XBLIG: Explosionade from Mommy's Best Games.

Player Creativity - Beware the Angry Granny!

2010-08-27T19:34:00.000+02:00

One of the things I am looking forward to the most, regarding the release of Your Doodles Are Bugged! for PC, is to see what crazy and creative user created doodles the players will come up with in Doodle Studio.

When releasing a game, it is already immensely satisfying to know that "out there" are a lot of people playing and enyoing my game. But, for me at least, even better is when players start to get creative and do new and unexpected things with my game. Of course not every game lends itself to such player creativity, but YDAB! with Doodle Studio surely does. I am so looking forward to see what people will create!

Here is a first example: Angry Granny, a doodle created by Kory, from Blitz Games Studios, during one of his beta testing sessions. I had a good laugh when he first sent it over. BTW, it is assembled solely out of predefined doodle elements!

Angry Granny

(click for larger view)

Kory also came up with the "Flying Machine", which is totally awesome: He created a contraption out of the predefined doodle elements that causes two bugs to "cooperate" in such a way, that they help themselves to "fly" over the whole width of the doodle, without needing any ink to land on. If I hadn't seen it myself, I would have said it's impossible. Of course the bugs will simply fall down if there is no ink to walk or jump on. No way around it!

Hah! The "Flying Machine" taught me better!

Doodle Studio - Demo Video

2010-08-19T19:59:00.000+02:00

The new Doodle Studio, which will be part of the upcoming PC version of Your Doodles Are Bugged!, is almost complete. So I took the time and recorded a video of myself playing around with it, demonstrating most of the features.

Yes I know - the video is a bit lengthy. But there is a lot in it:

In the first part, I show how to create a doodle out of the standard lines and "squiggles", including poisoned lines and gravity invert lines.
Then I use the pre-defined doodle elements to create a new doodle by combining them like in a collage. These doodle elements come directly from the original doodles in the game, and the player has to unlock them by playing through the standard doodle levels. Each time he completes a new level, the elements from that level will become available in the doodle studio.
In the third part I load a "flat" PNG image file with a simple drawing that I created earlier in a drawing program. The game automatically detects the black lines in that drawing and uses them as the black "ink" that the bugs can crawl and jump on.
In the last part, I combine the loaded PNG file with some of the pre-defined doodle elements, showing how seamlessly the image and the pre-defined elements can be used together.

Handling of large background textures in YDAB! on PC

2010-08-08T21:15:00.000+02:00

Your Doodles Are Bugged! uses background textures for the doodles that have a size of 3840 x 2160 pixels. On the Xbox, that was no problem, as it is able to handle textures of sizes up to 8192 x 8192.

But on the PC, the texture size that a given graphics card can handle varies. Quite a lot of graphics cards can only handle textures of up to 2048 x 2048. Too small for the large doodle background textures. So already a while ago I created a custom texture processor for the XNA content pipeline which splits the 3840 x 2160 background textures into 4 smaller textures. I also created a LargeTexture class that encapsulates these four textures so that for the rest of the code it still looks like there is only one very large texture.

The thing is, that I split the large texture in the middle, i.e. into 4 textures of size 1920 x 1080. This worked fine on my workstation, but when I recently tested YDAB! on my little netbook, it crashed. Previously I had been able to run it without problems, but there had been one specific change since then: I had added mipmaps to these textures (generating them in my custom processor). If you've dealt with mipmaps before, you probably already see the problem: On many graphics cards, textures with mipmaps must have sizes that are a power of 2. And neither 1920 nor 1080 is a power of 2.

To work around this problem, I have now changed my custom texture processor to split the large texture in a different, uneven way, with a bit of overhead. There's still a 2x2 grid of four textures, but those do not have equal sizes anymore, and together they are slightly larger than the required 3840 x 2160 pixels:

The two textures at the top-left and top-right are 2048 x 2048, but in the top-right texture, only the 1792 pixel columns at the left are used, so there is an unused overhead of 256 pixel columns.
The two textures at the bottom-left and bottom-right are 2048 x 128, but both use only the top 112 rows, i.e. there are 16 rows unused at the bottom. And the bottom-right texture also has the 256 unused columns at the right, like the top-right texture.

There's now a bit of overhead of unused pixels, but all textures now have width and height sizes that are a power of 2, and they are still inside the 2048 maximum range. Hopefully this will now be compatible with a wide range of graphics cards.

Oh, and it runs on my netbook again. :-)

Blitz 1UP Signs Your Doodles Are Bugged!

2010-08-03T19:52:00.001+02:00

Now that the press release is out, I can finally write about this: For its PC release, Your Doodles Are Bugged! has been signed by Blitz 1UP - and other possible platforms for release are also being looked into. (And if that doesn't sound good? ;-)

Blitz 1UP is a great initiative from Blitz Games Studios. If I may quote from the press release:

The Blitz 1UP initiative was launched in 2008 as an outlet for small, independent teams to bring their titles - finished and unfinished - to market on XBLA, PSN, PC, WiiWare, iPhone Flash and Mac. The scheme offers tailor-made packages to indie developers including PR, QA and access to its established distribution channels. The initiative provides a wide range of services, from design and production advice through to assistance with finding distribution and publishing partners.

Since I initially approached Blitz 1UP a few months ago, the people from Blitz have always been very friendly, supportive and of great help. I am very happy indeed that my game was accepted into this great initiative, where already a few other great XBLIGs have found a "second home away from the Xbox", like for example Clover: A Curious Tale from Binary Tweed and, not yet released, Weapon Of Choice from Mommys Best Games.

This are exciting times for the little bugs too, I can tell you. I can hardly concentrate to write this, with all the squeaking and "Bingo!" and "Yippie!" shouts going on!

Some Details about the new YDAB! Doodle Studio

2010-07-18T17:58:00.000+02:00

Feels like I have come far enough with the implementation of Doodle Studio to share some details about how it will work.

When creating a new doodle, the user will have the choice of starting off with a blank white canvas or to load an image file as the initial doodle. In both cases, the user will then be able to place doodle elements from the YDAB doodles onto this canvas, to complete his own doodle. This allows for different styles when creating a doodle: You can either create the whole doodle out of the predefined YDAB doodle elements, or you can pre-draw the whole doodle in a graphics application or drawing program of your choice, and only load it into Doodle Studio. Or you combine the two methods.

When placing the predefined doodle elements into your own doodle, you have the choice of a large selection of elements from the YDAB doodles. But: You will only be allowed to use elements from YDAB levels that you have already solved. So there's now additional motivation to play through all levels (and to solve the secret of the blue bug), as each complete level will give you access to more doodle elements for your own doodles.

A page from the doodle elements palette,

showing the elements from the first eight doodles.
(Click for larger view.)

To work with the elements in your doodle, you have the usual tools at your disposal: Select one or several elements by clicking or with a rubber-band selector. Move, rotate or flip elements, or copy, delete, pull-to-front or send-to-back, etc.

The toolbar in Doodle Studio.

However you arrange all the doodle elements and/or combine them with a pre-drawn background doodle, as the result, the game will create a single doodle from this and will automatically detect where there is black ink in the doodle (i.e. ink that is a barrier for bugs and that bugs can walk on), in comparison to non-ink areas (colors etc.) that are no barriers for the bugs. And yes, this ink-detection works for the imported background image too, as long as you used black ink on relatively light background when you created it (similar to the original doodles).

You will also be required to place at least one bug into the doodle (and you can place a lot more than only one if you want) and at least one honey pot (again, you can have several honey pots if you want).

A simple user created doodle: The rather crudely drawn mountains, sun and hot air ballon and the blue frame are from the loaded background image. The honey pots, bugs, little houses and the circle of funny faces have been created in Doodle Studio, from doodle elements.
(Click for larger view.)

Of course you will be able to save your own creation. And you will be able to export a user created doodle to share with friends (or whoever else you like) and you can import user created doodles from other people to play through, or to edit them yourself.

As a little special: While you will be able to import any user created doodle, you will only be able to actually open it (to play or edit) if the maximum level that the doodle's elements come from is not higher than the latest level that you have already solved. So if you get a user created doodle from a friend who has used elements from level 18 (and all other elements are from lower levels), then you can only open this doodle if you too have already solved level 18. Again, this gives the player additional motivation to solve all levels, to be able to open all user created doodles from other users.

From playing around with the Doodle Studio in its current state, I can already say that it is great fun to create your own doodles from the predefined elements (and get creative and combine them in unusual/surprising ways), then place a few honey pots into the creation and a lot of bugs, and let the bugs loose.

New Feature in YDAB! for PC: Doodle Studio

2010-07-08T22:58:00.002+02:00

If you know YDAB! from XBLIG, and if you took a close look at the new level select screen for the PC version (which I posted at the end of my previous blog entry), then you might have noticed that in addition to the four new level icons, the level select screen is now also sporting the following two new icons:

This is the new access icon for the free-play arena. Of course you already know the free-play arena from the XBLIG version, only there it was accessed via the X-button on the Xbox gamepad. In the PC version it will be accessed via this new icon instead.

This second new icon is more interesting, because it gives access to a new feature that is not included in the XBLIG version: It is the icon for the new Doodle Studio. In the doodle studio, the player will be able to create his own doodles (and export and share them with friends). This new feature is currently under development. I'll be posting more details about it as development progresses.

YDAB! for PC With New Levels

2010-07-03T14:03:00.000+02:00

The PC version of YDAB! will have four new levels in comparison to the XBLIG version. I inserted these new doodles in the early phase of the game, to provide for a gentler difficulty curve than in the XBLIG version. Here are a few cut-out details from these new doodles:

You may wonder why I only add those four new doodles now, in the PC version, and why I didn't already include them in the XBLIG version. After all, having a gentler difficulty curve would be good thing there too, right?

Well, there are several reasons for this, actually. The main reason is "80 MSP". On XBLIG, to be allowed to be sold for 80 MSP, a game must be below 50 MB in size. And I had already fully used up this size with the doodles that I included in the XBLIG version. There simply wasn't room for any more doodles.

But then I could just have made some of the other doodles easier, for a gentler difficulty curve? Well, I had considered this, but that would have meant to take out some of the more interesting (and more difficult) doodles later in the game (to stay below 50 MB), a thought which I didn't really like.

And I had to weigh this against the typical trial experience on XBLIG. An XBLIG trial game expires after 8 minutes (at least that's the current trial duration - in the early days of XBLIG, then called "community games", it was only 4 minutes!). Already with the 8 levels that are available in the current XBLIG version of YDAB!, I don't think that any player who plays the trial for the very first time will be able to go through all 8 levels in these 8 minutes. But he may start the trial at least a second time, if he is interested but not convinced yet. The trial version saves your progress, so in order to convince a player that YDAB! is fun, I wanted to have some of the interesting features which appear in the later levels to already be available in the trial levels. So already in the trial levels, the limited ink, the deadly/poisonous floor and the teleport portals are introduced. If I also had wanted to include more easier levels, then a player would probably have to restart the trial several times to even reach these later, more interesting levels. Something which I think is highly unlikely - a player either already likes an XBLIG during the first trial session, or he gives up on it. He may start a second trial, if you are lucky, but a third/fourth trial attempt? I don't think so...

Now in the PC version, the trial experience if very different, so here I am free to add a few more "easier" doodles in the early phase of the game.

And of course I also had to integrate these new doodles into the level select screen, which now looks like this:

YDAB! coming to the PC

2010-06-29T18:02:00.001+02:00

So what am I actually developing at the moment, what is this DevLog (currently) about?

If you follow my Twitter, you might remember that back in early May, I twittered that I had put my latest project "Bugs in Doodle Hell" on hold because of an exciting new opportunity that turned up for Your Doodles Are Bugged!.

Back then, I wasn't really able to talk about details, and unfortunately that's partially still the case, but you probably then also saw what I twittered in the following weeks, about playing YDAB! with a pen tablet, implementing mouse-clickable buttons, implementing text input via keyboard and creating new doodles and new art assets, including this one:

After all this, it therefore probably does not come as a surprise to you if I now officially announce an upcoming Windows PC version of Your Doodles Are Bugged!

And the good news is, that it also seems that I have found a very good partner for this, who will help me with publishing, distribution and marketing (in addition to other help). If everything goes as planned, I will soon be able to say more.

I will soon do a few posts with more details about some of the stuff that I changed and implemented for the PC version of YDAB!.

XNA and Crysis

2010-06-27T15:24:00.000+02:00

Every now and then someone comes into the XNA forums and asks a question like this:

XNA seems to be all right, but is it possible to create a top-quality game like Crysis with XNA?

This is a little bit like if a person walks into the local outdoor shop, takes a pair of trekking boots from the shelf and then asks the sales person: These boots seem to be all right, but is it possible to climb Mt. Everest with them?

(Not Mt. Everest!)

So what's wrong with that question then?

First of all, even though it surely is technically possible to climb Mt. Everest with standard hiking boots, the only possible answer that a responsible sales person could give is of course "Well, it is technically possible, but really, for this you need professional climbing/mountaineering-boots". Similarly with XNA: While technically you can do everything in XNA and managed C# that the Crysis devs do with whatever framework they are using and unmanaged C++, the only responsible answer would be "Well, it is technically possible, but for such a demanding game as Crysis, you really would want to avoid the limits of managed C#, at least for the current hardware generation".

But, what really is interesting about that question is, that the answer is totally irrelevant for any person who has to ask it in the first place!

Anyone with the actual skills and experience to climb Mt. Everest would never have to ask this question in an outdoor shop. He would already know this himself. And anyone who doesn't know this himself is most likely lacking the necessary skills for such an expedition anyway, so for him it is irrelevant if you can climb Mt. Everest in these boots or not. He will encounter his physical (and other) limits long before he gets high enough so that his boots would become a problem. And it is just the same with the question about XNA and Crysis.

So if you are about to get into game programming and this question about XNA is totally bugging you: Forget it and just get started on your first game. Rest assured, if or if not you can do something like Crysis with XNA won't be a problem for you for a long time!

The doctor is [ IN ] - Spyn Doctor Games DevLog started

2010-06-26T16:51:00.001+02:00

So there I was: Having been an indie games creator for a while, with three published Xbox LIVE Indie Games under my belt - but still no development blog. That is something that really had to be fixed! So here I go, starting my development blog.

But what do you write in such a first blog entry? How to open the devlog?

I think I'll just start with a short description of myself and what I do: Spyn Doctor Games is a one-man independent game studio with, as I guess "one-man" implies, one member: Myself. My name is Johannes Hubert and having the whole "studio" to myself, I relish being head-developer, lead game designer, overall-chief and high-king of Spyn Doctor Games all in one person. That's the joy and freedom (and burden some might say) of being "indie".
With Spyn Doctor Games, I currently create and publish games for the Xbox 360, available via the Xbox Live Indie Games channel. Check the "Games" box to the right to see my games.
I am located in the city of Fürth, in Bavaria, Germany (sister city of Nuremberg).
As "Spyn Doctor", I am quite active and well know in the XNA Creators Club Forums. You may also meet me in other forums under this nick. Or follow me on Twitter.

Or just keep watching this space - who knows, I might actually write something interesting now and then! ;-)