30 Dec

After playing the NagiQ demo…

Hello again! If you’ve followed the tutorial to learn how to play NagiQ, and then played the demo (freely available here,) most likely you already finished all the free levels included with such demo version. Now, by purchasing the full version of NagiQ you’ll get access to all the islands of the game:

screenshot_4

All of NagiQ’s islands can be unlocked in the full version of the game.

In the full version of the game each island will be immediately unlocked after you complete the previous one. Then you’ll be able to click on an island image to select a level to play. Notice that some levels introduce gameplay variants to keep the game fresh, fun and challenging!

Enjoy! And Happy New Year!

16 Dec

How to play NagiQ

This is a little tutorial explaining how to play our first game, the challenging word game NagiQ. Things will be easier if we start with a screenshot of the first level:

NagiQ-start

First level of NagiQ

Notice there’s a board, with some letters on it. Letter S and letter C. We refer to those starting letters as Mystic Letters.

How to play?

The rules are simple. Form a word (by typing it with your keyboard, or by clicking on the letters of the game’s permanent on-screen keyboard) and place it on the board with your mouse. For instance, type the word ‘star’ or ‘soap’… whatever. When you’re typing the word, the game will show a green verification mark to let you know that it will accept the word you’ve just typed.

NagiQ-soap

I’ve just typed the word ‘soap’. The green verification mark shows the word is accepted by the game.

OK, that’s it for forming words. Now you have to place such word on the board. And the word might be placed horizontally or vertically. Press the SPACE BAR on your keyboard to switch between horizontal and vertical style (alternatively, the on-screen keyboard has a special key for this task, if you prefer to use the mouse.)

NagiQ-horizontal

Horizontal style.

NagiQ-vertical-explanation

Vertical style.

Now that the word orientation is chosen, it’s time to place the word on the board. To do so, simply click on a board’s cell. However, there’s a very important rule:

Every new word you want to place on the board must include at least one of the letters ALREADY PLACED on the board.

That’s why our first word can be ‘star’ or ‘soap’, because such words include ‘s’, and our board already has a letter S. We could also start by forming the word ‘car’, because the board also has a letter C. We could also form the word ‘base’, because ‘base’ has an ‘s’. Or the word ‘case’, which has both ‘c’ and ‘s’. Whatever word you form, the important thing to remember is that such word must contain a letter already on the board.

Use your mouse to move your word around the board, and click to place it. You cannot place your word anywhere, though. You have to connect it to a letter already on the board. Simply move your word and ensure that a letter of your word overlaps a matching letter already on the board, e.g, if your word is ‘star’, ensure that the ‘s’ of ‘star’ overlaps the letter ‘S’ already on the board. When the word is well placed, the game will change the cells’ color to green. Then click to finally place your word on the board (Pro tip: you can press ENTER on your keyboard instead of a mouse click.)

And that’s all. Do you remember those Mystic Letters, S and C? Well, in order to win the level you’ll have to place your words properly, to ‘connect’ with ALL the Mystic Letters on the board.

Upcoming boards contain cookies to get hints, and each island of the game offers gameplay variants. But essentially, these are the core rules of NagiQ. Two little details:

  1. You cannot connect your new words directly to the Mystic Letters, except for the first word you place on a board. In other words, your first word might connect with any of the Mystic Letters S or C. But after you’ve placed your word, you next words must include letters of the words you’ve placed.
  2. Once you use a word, you cannot re-use it on the same board.

Let’s see a commented game to better understand the rules.

NagiQ-1

First level of NagiQ. Two Mystic Letters: ‘S’ and ‘C’.

NagiQ-2

We type a new word: ‘cases’. The green verification mark shows it’s a word accepted by the game.

NagiQ-3

By using the mouse we place our word ‘cases’ so that one ‘s’ of ‘cases’ overlaps the ‘S’ already on the board. If the placement of a word is OK, the tiles’ color changes from red to green.

NagiQ-4

Click or press ENTER to finally place the word ‘cases’ on the board. The color of the tiles changes to yellow after the word is placed on the board.

NagiQ-5

We form a new word: ‘rock’.

NagiQ-6

We want to place it vertically, so we press the SPACE BAR on the keyboard. We can achieve the same effect by clicking the special yellow button on the on-screen keyboard of the game.

NagiQ-7

We move our word and place it to match and overlap the letter ‘c’ of the word ‘cases’ we’ve just placed on the board.

NagiQ-8

A new word: ‘peer’. We place it to match and overlap the ‘r’ of ‘rock’.

NagiQ-9

Now we typed ‘really’. We switch it to horizontal style, and place it to match and overlap the first ‘e’ of ‘peer’.

NagiQ-10

Finally, we type ‘cool’. We place it to match and overlap the second ‘l’ of ‘really’. A smart move, indeed: this word ‘cool’ allows us to also match and overlap the remaining, unconnected Mystic Letter C. Therefore, after playing ‘cool’ (pun intended) we will connect with Mystic Letter C, and there won’t be any unconnected Mystic Letter on the board. That way the board will be completed.

NagiQ-11

Well done. After placing ‘cool’, this level is completed.

Combinations are endless. Have fun :)

19 Aug

A weekend boxed inside a dylib

I’ve dedicated the entire weekend to heterogeneous yet related tasks. First, I started off by trying to build NagiQ, our first published game, on OS X Mavericks. By “build” I mean to produce a binary complying with the requirements of the Mac App Store. You know what I mean: well-formed directory hierarchies inside the .app, proper icons and .plists, code signing, etc. For the record, NagiQ is a word game created with Ren’Py, a visual novel engine which is, in turn, built with Python. At the time of release a lot of folks shared their thought regarding our election of Ren’Py to create our word game: it was, to say the least, an unorthodox choice. However, almost 3 years after its initial release, NagiQ is still running fairly well on Windows, Mac and Linux, thanks to the wonderful capabilities of Ren’Py for multi-platform deployment.

Building NagiQ on Mavericks is easy, it amounts to just a single click on a Ren’Py option[1]. However, turning the generated .app into a binary suitable for the Mac App Store has proven to be a daunting task. You have to organize the directory structure of the Python Framework distributed with the game. You have to circumvent the writing of Python .o files in the .app directory, a big no-no for sandboxed apps. You have to retrieve the proper directory to save user and game data (~/Library/Application Support/NagiQ is not allowed). Etcetera. Right on the middle of such etcetera lies the requirement of communication with a few dynamic libraries needed by NagiQ to satisfy several functional demands.

As you surely know, dynamic libraries = dylibs on Mac. Taking into account that Ren’Py is a citizen of the Python world, we use the ctypes library to communicate with our dylibs from inside the game. An important lesson I learned during this weekend is that you have to be very careful when dealing with dylibs and ctypes. First, you have to verify that your dylib and the Python version you’re running are compatible. Is your dylib a 32 or a 64-bits binary? Your Python instance must be apt to properly load and call functions of your dylib, or you will spend a lot of time trying to sort out segmentation faults.

Typing python on a terminal of my Mac launches the 64-bit version of the interpreter by default. If you want to execute the 32-bit version, run this in your shell before launching python:

export VERSIONER_PYTHON_PREFER_32_BIT=Yes

After you have launched the proper version of Python, you can import ctypes to load and communicate with your dylib. However, don’t take this communication lightly. Pay special attention to the type of the arguments and return values of your functions. For instance, if you’re invoking a function of your dylib which requires a char* value, then you have to wrap your argument in the type c_char_p. Let’s see another example. Suppose you want to get the proper location to save the data of your game. Of course, as a good programmer, you don’t want to hardcode such path. Instead, you’ll be asking the operating system for it, the right way. Let’s create a tiny, demonstrative Objective-C library (demolib.m) for this:

#import <Foundation/Foundation.h>
const char* findAppDir()
{
    NSArray *paths = NSSearchPathForDirectoriesInDomains(
        NSApplicationSupportDirectory,
        NSUserDomainMask, YES);
    NSString *basePath = [paths objectAtIndex:0];
    const char *convertedPath = [basePath UTF8String];

    return convertedPath;
}

Compile with:

clang -dynamiclib -framework Foundation demolib.m -o demolib.dylib

Then you can call your function from Python:

Python 2.7.5 (default, Mar  9 2014, 22:15:05)
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import ctypes
>>> lib = ctypes.cdll.LoadLibrary("demolib.dylib")
>>> findAppDir = lib.findAppDir
>>> findAppDir.restype = ctypes.c_char_p
>>> findAppDir()
'/Users/yourusername/Library/Application Support'
>>>

This little function will prove useful later, when I resume the building of NagiQ. However, the weekend is already over and I have yet to implement several adjustments for DragonScales, our next game soon to be released. The delight of working with dylibs, sandboxes, etc., will surely be the subject of future happy weekends.

  1. [1] This single-step build has grown to be the Ren’Py feature I love the most.
16 Dec

NagiQ 2 Treasure Hunt: Press Release

December 16, 2013IKIGames releases NagiQ 2: Treasure Hunt, an original word game available for PC, Mac, Android tablets and iOS (iPad). Gameplay is based on forming words and combining them on a board to win coins, defeat an evil pirate, win prizes, punch evil skulls, explode monsters, and trim mustache guys. The player will have to solve 75 boards and also collect all of the game’s treasures!

Key features of NagiQ 2 Treasure Hunt:

  • Rich and original gameplay! Each island has its unique challenge and enemies! The Iron Hand Pirate, evil skulls, monsters, mustache guys, and multi-letter tiles!
  • Form words to capture gift boxes. You could win coins or special Lorin letters which will help you to form words!
  • Rise your score to unlock letters! The more letters you unlock the more your chances to succeed!
  • Receive all of the game’s treasures by conquering islands and for your achievements.
  • Support for English and Spanish languages!

NagiQ 2: Treasure Hunt is available in English and Spanish languages. The game is priced at USD 7.99 for PC (on the game’s website), USD 4.99 for Mac (via Mac App Store), USD 0.99 for Android (on Amazon) and USD 0.99 for iPad (on the App Store). Further information and review copies of “NagiQ 2: Treasure Hunt” can be obtained by contacting IKIGames (@superikigames).

IKIGames is an indie game company focused on development of educational, thought-provoking and family-friendly games for desktop and mobile devices.

Release Date: December 13, 2013
Platforms: PC, Mac, Linux, Android (tablets), iOS (iPad)
Available: via IKIGames’s website (PC), Mac App Store (Mac), App Store (iPad), and Amazon (Android).
Press Kit: NagiQ 2’s Press Kit.
Video: NagiQ 2: Treasure Hunt Video

09 Mar

In regard to the discussion on the JVM being a viable platform for mobile games

The author of LibGDX has just published an excellent and reflective post: THE JVM – A VIABLE PLATFORM FOR (MOBILE) GAMES?. A thought-provoking reading. Our humble answer to this question is yes. But things could be better, much better. For instance, as we all know, the approach to port your LibGDX game to iOS, albeit effective and a victory of cleverness, is notoriously contrived. It feels like we are working with fine porcelain which could break anytime, anywhere. Even for the desktop, Java game development and distribution can pose unexpected challenges. For instance, bundling your jar for distribution on Windows can face surprising hurdles:

  1. We cannot provide further details because of NDAs, but there are some DRM wrappers which don’t interact well with launch4j outputs.
  2. Bundling has to take special care to handle the “Missing msvcr71.dll” problem (Java 6. For Java7 your problem will be msvcr100.dll). Take a look at this.

On Mac OS X, things might get even harder. You’ll have to use the AppBundler, work through several configuration files, and even compile your own JRE.

Regarding mobile deployment, well, if you’re using LibGDX, Android is your most natural mobile target. iOS is possible too, but it’s not that natural mostly because Java is not a first-class citizen there. Blackberry devices, which allow for Java development, are not possible at the moment with LibGDX because BB has no JNI support. For Bada you’d use C++. For Firefox OS you’d use HTML 5. Tizen is based on HTML5 (may support Java too). Play Station Mobile requires C#. Windows Phone 8 allows C++, C# and Visual Basic, I think.

That said, we’re not big Java fans. Honestly, we’d rather work on C++, or Python, or C#, or even PROLOG, and we really don’t care that much for the other languages that target the JVM. We’d rather work on Vim with a bunch of makefiles. However, after completing our first game, NagiQ, a word game for desktop, we wanted to be able to deploy our next titles on mobile devices, specifically, Android devices. As Google insists on Java as your first language of choice, we followed the Java/LibGDX route. The great part here was LibGDX. Java is a good language, but what we really enjoyed was using LibGDX: its design is very, very good. What we want from a framework/SDK/library is good abstraction layers and cross-platform capabilities, and LibGDX excels at offering both. Furthermore, you can go lower level if needed, and you can browse and alter the source code if needed. That’s wonderful. We are much less interested on tools. Our dream: LibGDX in C++, coding with Vim, having a set of makefiles for automagically creating versions of our games for desktop and several mobile targets (Android, iOS, BB, PSM, etc). A dream. Just a dream.

Our feeling is that the JVM is getting behind. C# is becoming the preferred managed solution out there on mobile devices. For the time being, our plan is to stick to LibGDX. And as LibGDX is based on Java, we’ll keep using Java.

25 Feb

RenPy: Games, Rationale and The Power of a Well-Crafted Engine

More than 1 year after releasing NagiQ, I’d like to share a few bits of our experience with NagiQ, and of course, with the engine we used to build it: RenPy. First, we want to express our gratitude to RenPy’s author, PyTom, and to all of the RenPy contributors, including the kind people of the RenPy forums, who are always ready to provide useful feedback and answer our questions.

RenPy is a wonderful engine. What I like the most about RenPy is its robustness and cross-platform wonders. It feels like it might run anywhere and without ever crumbling. In fact, we released NagiQ for Windows, Mac and Linux, and deployment was incredibly easy: RenPy smoothly abstracted the differences among operating systems, and the game runs and behaves exactly the same way on all these 3 platforms. Besides, I think that several games built with RenPy have found their way into Steam and Google Play. I especially recommend RenPy for people creating its first game (NagiQ, developed in 2011, was our first title), because RenPy allows you to focus on what really matters for your game (gameplay, spaces, visuals and story.) As suggested, abstraction is a key concept for RenPy: abstraction is everywhere, it’s high-level and indeed powerful. For instance, right now I’m thinking of RenPy’s ATL, which is a very powerful way for showing displayables and applying several visual transformations (rotation, zoom, etc.) to them. And that’s sweet, really sweet. More so if you’re submitting games to publishers for the first time.

I don’t know of an engine better than RenPy for creating visual novels, and generally speaking, games in which pairs (image, text) are first-class citizens for scene design. NagiQ isn’t a visual novel, but a word game. As a word game, NagiQ is mostly based on simple images and strings. Handling images and strings with RenPy is a breeze. And not just strings. In RenPy you can show images and play music with a single line of code. A single line. You work fast, and you work safe. Further on, you might apply a tiny bit of ATL for achieving a richer presentation.

As RenPy is open-source, you can browse and study its code. You’ll end up learning quite a lot. Furthermore, knowing how things are done internally will allow you to find pathways for implementing any specific feature you might need. For example, several publishers require special handling of the quit message (Alt+F4 on Windows, CMD+Q on Mac OS X.) By knowing RenPy internals you’ll be able to handle this message as needed.

Overall, organizing your game’s scenes in RenPy is pretty straightforward. And you can even use neat transitions between scenes with a single line of code too. Normally, you’ll want a splash scene, a main menu scene, a level selection scene, and of course, the scenes implementing your main gameplay. Several of these scenes might require a lot of UI components whose creation is a piece of cake with RenPy. You’ll have the valuable help of Screens and Screen Language, which will simplify implementation and handling of your game’s screens.

RenPy is extensible. For the levels of NagiQ we required boards made of clickable cells. For doing that, we created a custom Board class in Python. And, again, RenPy proved golden: you can extend RenPy as you wish. We coded our Python class and integrated it to a RenPy scene pretty easily.

Summarizing, RenPy promotes creativity. It’s a very flexible and dynamic system, which doesn’t impose tight restrictions on the way you show and structure your content. The powerful ATL and the Screen Language are dreamy features, an outstanding support for unbounded creativity.

In retrospective, RenPy was indeed the best choice for building NagiQ: it was such a fun experience. And that’s what really matters. Long life to RenPy.

04 Jan

Happy New Year!

Happy New Year everyone! We wish you a happy, healthy and prosperous new year! Our best wishes to all! 2012 was such a great year for @superikigames. Our first game, NagiQ, reached more than 100 distribution channels worldwide! And our second title, The Rainbow Machine, was also released in 2012. Oh, and we also changed our web site from the ground up :-)

This year we’re planning to release the following:

  • iOS and HTML5 versions of The Rainbow Machine
  • Translations of the android version of The Rainbow Machine into French and Spanish
  • NagiQ 2

That’s a ton of work! So we’d better start working right now! Again, happy new year 2013! See you on Twitter, FB and Google+.

02 Jul

NagiQ released!

Thinking of words, connecting them, conquering tiles, having fun! NagiQ is our newest project, a family-friendly word game suited for brain fitness. NagiQ is full of cartoon graphics and challenging levels. Here are a few screenshots of the game:

For more information about this new game, please take a look at NagiQ’s page.