We’ll be releasing our game NagiQ on Steam 🙂 The release date is set for March 5:
NagiQ is a family-friendly, word game. It’s a great game to practice English vocabulary, and you’ll have to think a lot to complete all the 100+ boards of the game. Here’s a trailer with the basic gameplay:
Basic gameplay: Type words and connect the mystic letters.
We’ve added 10 Steam achievements to the game, corresponding to the trophies you get for completing the following actions:
Capture 2 mystic letters in a single play.
Capture more than 2 mystic letters in a single play.
Length of a word greater or equal to 15.
Complete a board with an amount of words lower or equal to the number of mystic letters on the board.
Complete a board in less than 10 seconds.
20 consecutive boards completed, without exit / reset.
15 consecutive boards completed, without using hints.
Score >= 20,000
Score >= 100,000
Score >= 200,000
Updating NagiQ on Steam
NagiQ is the first game we released, back in 2011. The game was created with Ren’Py, and in hindsight those were really fun development times. In order to integrate Steam achievements I updated the game to use the latest Ren’Py version. In short, these are the changes I had to make:
Since the launch of DragonScales 3 in May we’ve been very busy handling all the distribution process, replying to customer emails, attending the accounting side, etc. In short, we’ve been handling the business part of IKIGames. However, we also started tackling the design of our next title: DragonScales 4. Yet more, we’ve also worked on a few subtasks mostly related to updating several games of ours. Specifically, this is what we’ve been addressing:
Revamping of DragonScales internal engine.
Design of DragonScales 4.
Design of a special version of DragonScales for advanced players.
Localization of the original DragonScales into Japanese.
DragonScales 3 for Android (complete, but yet to be released.)
Production of a new build for The Rainbow Machine (German version.)
A new build for NagiQ 2 which fixed a few issues (already live here on our site.)
Yet another build for NagiQ 2 suitable for localization (this localization of NagiQ 2 is currently a work in progress.)
The original DragonScales in Japanese!
In the next weeks we’ll keep working on the first 3 tasks.
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!
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:
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.
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.)
Horizontal style.
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:
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.
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.
First level of NagiQ. Two Mystic Letters: ‘S’ and ‘C’.
We type a new word: ‘cases’. The green verification mark shows it’s a word accepted by the game.
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.
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.
We form a new word: ‘rock’.
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.
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.
A new word: ‘peer’. We place it to match and overlap the ‘r’ of ‘rock’.
Now we typed ‘really’. We switch it to horizontal style, and place it to match and overlap the first ‘e’ of ‘peer’.
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.
Well done. After placing ‘cool’, this level is completed.
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:
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]This single-step build has grown to be the Ren’Py feature I love the most.↩
December 16, 2013 – IKIGames 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.
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:
We cannot provide further details because of NDAs, but there are some DRM wrappers which don’t interact well with launch4j outputs.
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.
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.
Just for fun, our artist has created a new art inspired by the design of our home page (incidentally, also designed by her). Her new fantasy design features a huge whale, a recurrent and well-loved theme in our artist’s creations, as NagiQ fans out there know pretty well. Enjoy! 🙂
