Crea sito

Hide/show the banner

Desdemona / Desdemona Lite / Desdemona XL

8x8_0

8x8_0

What it is?

Basically, it's an enhanced Othello / Reversi-like board game, featuring:...

   
  • Classic Othello/Reversi gameplay on different boards sizes, including the standard 8x8 (if you don't like too much new challenges :-) )
  • Playable with 1 player, 2 players o no players at all (CPU vs CPU)
  • Different skill levels for each CPU player
  • A movable and zoomable game board (useful if you have a small screen)
  • Customizable game board colors
  • Hint move (the CPU player chooses for you)
  • Undo move (go back to your previous turn - repeatable, until you have moves left or you don't have to pass)
  • Force move (if want a CPU player to stop thinking - the best move found so far will be used)
  • A little bit of end-game statistics
  • Obnoxius voice effects [:-)] on game start and game over

There are currently 3 "flavors" of this App. A Full and a "Lite" (free) version, both aimed at old devices, plus an "XL"version, more performance-hungry, that should be able to run on all newer ARM-based devices, including Tablets with extra-large screen (with Android Honeycomb or newer systems).



Available right now from Android Market for Android 1.6 and up, here are the main differences:

Desdemona (full): all features, about 1MB in size, deeply optimized for OpenGL-ES 1.0-capable devices and older phones. Multi-save feature (a saved game for each possible combination of skill and board type); game board rotation in perspective (useful for larger boards, but if your device does not have a DPAD or a keyboard to move the cursor on the board, it may become impossible to select the correct coordinates touching the screen if the rotation is too much)

Desdemona Lite: about 0.7MB in size, no multi-save feature, less skill levels, board sizes and game board colors - but totally free.

Desdemona XL: more beefy (>2 MB), all features of the full version except the "perspective rotation"; free, but ad-supported.


Currently supported languages: English, Italian. Others, upon request.


Some screenshots from the Full and Lite versions:

6x8_1    6x8_2    5x10_1    8x8_1    10x10_1


Some screenshots from the XL version:

XL4x8    XL8x10_savemenu    XL8x10_thinking    XLbkgnd_select    XL_8x8    XL10x10_thinking    XL_6x8    XL_6x8_zoom   


How to play:

Wait, you don't even know what Othello or Reversi are?... Hurry up to the Wikipedia page for Reversi! ...Or you may read a brief description on how to play on the app itself, under the "help" menu.

More info

(Back to top)

Some brief history:

Desdemona (the “original version”), came to life in the second half of 1998, written in C++ Builder for Windows 95, as a spare time project which essentially aimed to fill a horrid void in the default games which shipped with the updated Windows OS: the good old Reversi from Windows 3.1 was missing! ...And so Desdemona was born.

It used a simple “brute force” approach, which was somehow adequate for a desktop PC with “pseudo multitasking” capability (at least, a little bit better than Windows 3.1). Mostly inadequate for real-time quick matches at the highest depth level of search, but OK for ongoing matches under you IDE compiling or your customary idle Excel spreadsheet – in case the boss was around. :-)

So the game itself had to be clearly re-written to be ported to Android.

This new incarnation of Desdemona uses a more refined evaluation function (to judge the “weight” of a move), more heuristics instead of brute force and several other optimizations which you can read about in the dedicated technical section - if you're keen to it.


So, where's version 1.0?

The actual first version of Desdemona for Android, dated Winter 2010, has only been “released internally” and uses a pure-Java engine. (Besides being funny, this euphemism simply means “never deployed to the Android Market”)

The second version, currently on Market (starting from rel. 2.00.67), uses a completely re-written C-engine which translates to native code almost the same search algorithms of the pure-Java version. Currently, only ARMs processors are supported by the native code compiler; so, if your device is a fancy tablet with a newer or different CPU (I'm thinking of x86, for instance), you'll obviously have to wait for future releases.


Features in detail (for the Full version):

  • 15 custom board colors, for the fancy-pants lovers out there! (the Lite version has only 3)

  • 20 custom board sizes (the Lite version has only 5)
    The original Desdemona sported really huge board sizes, but we had to cut them out for obvious memory constraints. I mean: who's gonna ever want to play on 16x16 board, besides being able to zoom-in/out to see whole thing on a small screen? ;-) For what we have seen, 10x10 is big enough for older devices.

  • Undo move
    This allows the current player to go back to his/hers previous move. This actually translates as undoing 2 moves (the last move of your adversary and your previous), since you actually have to go back by 2 gameplay turns (a.k.a "plys").
    This can be repeated almost endlessly, until there are "possible moves" in the previous player ply: that is, if on your previous ply you had to pass, you won't be able to undo any more moves (unless you have saved your game). So, be careful.

  • Hint move
    The CPU plays your current turn, using the current adversary depth setting, but starting from level 3. So, if you're playing against a level 2 CPU, and you ask for a hint, you're given a big advantage! But this is actually useful if you're playing against a human friend (humans are counted as "level 0" - even if they are smarter than Desdemona...)

  • Auto-save feature on back/exit
    Allows you to continue your game even if interrupted by a phone call, for instance.

  • Save/load any game progress, one for each board size/skill level combination (the Lite version has only the Auto-save feature to rely on)
    This means, for example, that you could play a game at a certain level of difficulty, let's say on a 5x7 board, for as long as you might, then save it, change the type/difficulty of the players involved, change the board type (for example, this time on a 6x6 board for a match against a friend of yours), play it, then (let's assume your friend had to go) save the new game, and finally restore your previous game just loading back the correct filename. Neato!

  • 7 difficulty levels (the Lite version has only 4)
    Each difficulty level is directly proportional to the search depth used to find the best move, depth which actually varies a bit according to the game progress and board size.

  • Force move
    Obviously useful if you think the CPU is taking too long to decide - and this will happen indeed on large boards with high depth level of search. Don't worry: Desdemona will be smart enough to choose among the best moves that it has found so far.

  • End of game statistics
    These are simple stats displayed at the end of each game; something like the total number of turns played, the medium time used for a decision and so on.

  • Overall game usage statistics summary
    Similarly, all the statistics from each game played is summarized and divided by CPU difficulty level/type and board size.

  • Physical cached memory of the games played
    What this mumbo-jumbo means, is that Desdemona actually remembers the choices made for each turn and may choose differently a specific move if played consecutively at the same difficulty and board size options. Or, moreover, if you undo a move you obviously get a second chance to think about it, but also Desdemona does. Funny!

  • Zoom & Pan the game board
    By touching near the center of the screen and keeping it pressed, after you feel a small vibrating feedback, and then sliding your finger up or down, you may zoom in or out on the game board. Similarly, by just touching the screen and sliding the finger around before the vibration starts, you can pan the board in the direction of the movement to reveal any areas hidden by the zoom. (The duration of the touch before the movement of the finger starts, lets you choose among panning or zooming.)

  • Rotate the game board ('Still experimental but fully working - not available on the XL version)
    If you have enabled the "perspective rotation" engine feature, you can rotate up & down (actually, on the X and Y axis) the whole board: touch and keep pressed either the left or the top borders of the screen; as soon as you feel the short vibrating feedback, instead of zooming the board, you will be rotating it. If the board is still zooming, either you're not close enough to the top or left borders, or you have the rotation disabled (which is the default, BTW).


Permissions, explained:

  • WAKE LOCK: used to control/avoid the locking of the screen

  • VIBRATION: for some vibrating effects (duh!)

  • WRITE TO EXTERNAL STORAGE: Desdemona uses the external storage for caching support. The "memory" file stored on the SD root folder can be freely deleted on occurrence (since it can be recreated if missing); doing so Desdemona will "forget" the most recent games played, though (where the quantity of "most" depends upon the board size, since the cache file is fixed in size and does not grow).

  • NETWORK STATE and INTERNET ACCESS: these are just used by Desdemona XL, since it's Ad-supported, to retrieve the ads from the net (when connected).


Known issues:

  • For the Full and Lite versions, on some exotic hardware implementations of the OpenGL/ES standard, the reported available memory size of the hardware buffers may lead to wrong results when detecting the maximum allocable size, resulting in a force-close at application start. The XL version does not have this issue and can be used instead (until this can be fixed).

  • For the Full and Lite versions, the perspective rotation engine has still severe limitations on the touch-picking algorithm which, essentially, renders the cursor positioning by touch unfeasible due to gross approximations.
    If it really does bother you, the feature can be toggled off in the options.

    (For the technical savvy: to speed up the computation, each board cell is still considered “squared” instead of a generic rhomboidal figure. Needless to say, the greater the rotation, the greater the distortion.)

    So, for the moment, unless your device has a DPAD or some cursor keys for the positioning of the cursor, you should consider the “rotation toggle” feature as just a toy. :-)

  • For Desdemona XL, on multi-core systems, the rendering cycle of the layer used for the game board may be interrupted in the middle by any system-drawing activity, resulting sometimes in a relatively large area of the board rendered as a "white zone" when the user presses the menu button or the volume button while the rendering loop is still working. This does not stops or affect the game in anyway, but is simply too ugly to be ignored.

    (So far I've been able to reproduce this only on the Samsung Galaxy Tab 10.1, which - I'm told - uses a peculiar threading model.) In future releases the layer rendering will be changed to avoid completely this graphic issue.


Contribute / Localize

'Want to contribute? Would You like to localize this game in your own language?

The task is quite easy: assuming you can understand English, you will be given the resource english text list file used inside Desdemona that you can directly translate into your own tongue.

If You're interested, write to us using the contact form. If You manage to translate the file, You will be listed forever in the credits! Ah, such glory!


Near Future Developments

  • Allow the Full and Lite versions to run even on most of the newer hardware, by adjusting some of the tricks that make them run at 40 fps on old devices but crash on some others (mainly due to OpenGL hardware buffer memory usage).

  • Custom board setup before game start, from the emptiness of Reversi (which does not use the initial 4 tile setup) to almost any custom layout you may think of. Nice!

  • Various speed ups in the graphic engine

  • Support for Othello Players Rankings

  • OpenFeint support

  • A working touch-picking in perspective mode (for the DPAD-missing buddies)


Far-fetched Future Developments

  • Network play, using dedicated game servers

  • A dedicated game server (duh!) for local and remote netplay, freely downloadable

  • Clients for other platforms


More tech-stuff

(Back to top)

Desdemona currently uses a custom implementation (in the C language) of the MTD(f) algorithm, together with a customized “Alpha-Beta with Memory”-search for scanning the tree of possible moves.

Read all about the MTD(f) algorithm directly from its creator (Aske Plaat): http://people.csail.mit.edu/plaat/mtdf.html

...Or from its dedicated Wikipedia page: http://en.wikipedia.org/wiki/MTD-f


The single-touch approach has been mutuated from an old open-source Sony-Ericsson demo/tutorial for developers working on phones that do not support multi-touch. The whole shebang obviously had to be rewritten to work properly under OpenGL/ES 1.0, but the interface ideas are there.

Sadly, the link I had isn't there anymore, but if you're a developer too and are interested in this, maybe searching on their new site may help you anyway.


While the Full and Lite versions are deeply tweeked to get the most out of every rendered graphical frame, for the graphic part, Desdemona XL has been partially re-wrote and adapted to use the widely popular AndEngine software library.

On the same hardware, comparing the execution of XL versus Lite (or Full, for the matter) the resulting AI performance seems to be a little bit faster for the XL version, probably because the library renderer manages to give more frame-time than I did to the rest of the ongoing tasks, including the AI-thinking. On an old Samsung phone I7500 running Android 1.6 (quite dated for these days), the XL (while being faster on the thinking side) rarely tops 5 graphic frames rendered per second while the Lite and the Full average around 30 fps - but this graphic overload is due to the generic nature of the library used.

Besides lacking Javadoc guides (almost totally, as of this writing, in Semptember 2011), the AndEngine class framework is a free, good and a very complete 2D-gaming engine. For any developer who's not afraid of reading a lot of source code, I definetely would recommend it. For more generic stuff, I'd rather go with LibGDX. If you seek performance, stick with your own implementations. ...But that's just my opinion. :-)