Rough Sea Games

Hi! I’m Philipp, Lead Programmer of Rough Sea Games’ Research & Development department. And when I mention this, I often hear things like “R&D? Oh, you’re the Tools-Guy” … or … “Ah, so you do all the stuff nobody else likes to do”. Well, it seems to me as if there are some Clichés attached to the job as an R&D Programmer. And since “Myth-Busting” is the latest cool thing nowadays, I’ll totally jump onto that train! With this and the following blog posts I will try to show you what R&D is about “by example”. Maybe it will help you to decide if you want to be an R&D Programmer, or, if you should establish an R&D department in your company.

So, rumor has it that R&D is just about Tools. And indeed, the R&D of Rough Sea Games is responsible for the Gui-, Map-, and Asset-Editors, used by our Designers to create content for our game. Furthermore, we have created an Admintool to administer our game servers. Thomas will go into more detail about this in his blog posts. Anyhow, it seems as if the Clichés are true…these are all tools.

Well, but that’s only half of the story, it is the “Development” part of R&D. In the Research part, we are investigating into new render techniques, new frameworks, and as you might know from previous posts, into new platforms. The goal is to find new technologies that advance our workflows and products here at Rough Sea Games. And yes, that implies working on the engine and game framework.

But why do we need a whole department for that? Can’t we spread the research-tasks to everyone in the company, so everyone does “some” research. Well, of course we could. But most of the time, everyone else is far too busy doing game development, and in our opinion, research shouldn’t be done alongside other tasks. If you distribute the research tasks among the project workers, the tasks are in competition of priority with the project tasks. Usually, the research tasks will “loose” against the project tasks, and thereby they won’t get the recognition and resources they should have.

But of course, having an own R&D department can be expensive. If you can’t cover the costs through your project, you can’t effort an R&D. Right? – Wrong! It’s not an easy decision to make, but you could try to gain some profit out of your R&D if you develop your tools  in a way that they can be used as middleware, which could be licensed to other parties. We would like to try this with our Admintool. So far we can’t share any experience there, it is still work in progress. But we will let you know as soon as there is something to write about.

As you can see, R&D is most of the time about providing and maintaining technology, be it middleware or new engine technologies. And in some companies, this is even called the “Technology Group/Department”. If you like this term better, it’s fine with me. The important thing is that, in my opinion, a company will profit a lot from a group like that, to be well prepared for future things to come.

“Yeah yaeh, yabber yabber, technology, middleware….is this even Game Development anymore?” you might ask. I guess this question has the same taste as the beforementioned “Ah, so you do all the stuff nobody else likes to do”. But before I start writing about “what is Game development” or start a discussion about likes and dislikes, I will show you some examples of what we do here in R&D in my next blog posts, and you can judge for yourself.

Popularity: 5% [?]

The research field of human-computer interaction, which also includes explorations of the interaction with digital games, has put forth two main concepts which contribute to a user-centered design: Usability and User Experience. First of all, I would like to introduce you to the essential ideas that are concealed behind the term “Usability”:

Usability deals with the question whether a software can be intuitively and effectively used to accomplish the tasks it is designed for.

Usability is mainly a psychological issue. When evaluating the ease of use of an application this automatically means taking into account the user’s cognitive requirements, too: limits in human memory, perception and attention, the user’s expectation and his abilities all contribute to the way he interacts with the software. Too many information on a screen, for example, might overwhelm the user’s brain abilities as he is only capable of comprehending 7 +/- 2 pieces of information simultaneously.  Of course, this does not mean we can conclude that we can realize an optimum in accessibility for the user by simply always implying round about 7 items on each page. Human psychology is much more complex and so is the subject of Usability, thus it won’t really fit into this tiny blog post.

Still, you don’t have to be a psychologist to be able to explore the usability of your application. Fortunately, there are alreasy someone guidelines developed by experts that can support you. We can get started on this taking a look at the Usabilty principles defined by ISO 9241-10. They are less abstract than psychological constructs and therefore quite easy to understand:

• suitability for the task

(Can the application be used to carry out the tasks efficiently? Are all required functions needed to carry out the task implemented?)

• suitability for learning

(Does the application offer the user a step by step acquisition of these functions? Can the user deal with the complexity of the application?

• suitability for individualization

(Can the application be adjusted to different user needs?)

• conformity with user expectations

(Is the usage of the application comparable to similar applications?)

• self descriptiveness

(Can the user comprehend the application intuitively? Are there help functions implemented?)

• controllability

(Can the application be adjusted to the work flow, different task assignments and time periods?)

• error tolerance

(Does the application offer a smooth error-handling?)

So start your usability evaluation of your application with checking the points mentioned above and you will have quite a good basis for further investigations in this research field.

More secrets about Usability, User Experience and how to measure them concerning your game will be revealed in my next blog post!

Popularity: 6% [?]

Hello everyone,

usually network administrators are predestined to write about  security related to computer systems and networks  .  Guess what  – i decided to do so !

I know a lot of  “users” will yawn now and can`t wait to meet the sandman! But believe me , it does not have to end up in this way.
Users are an important part of security. So it`s always wise to stick your nose into security related topics. You can actively support your administrator or for instance kick the admin`s butt for showing what he/she did wrong !

Therfore for all interested users or those who want to take revenge for endless arrogant dialogs with your local administrator.

READ THE POST !

Here we go ……

Network security the HOLY GRAIL for every Network Indiana Jones out there !

Network security the cream on  the IT pie

Network security the Bonny of every Klyde administrator.

Network security the James T. Kirk for every “Enterprise” administrator .

Network security the … ok ok … i think you got my point !

Anyway, it`s time to become a little more serious.

The todays post will give u a small introduction what will follow in future posts.

I decided to break down this topic to a whole series of posts , because of the complexity of the topic.

Part 1 :  General thoughts about network security for small businesses  – Plan your network ! (The theory)

Part 2:  Security Gateways need a easy setup ! (Gives a small overview of open and closes-source security gateways solution / Mini-Howto for Endian )

Part 3:  Firewalls & Proxies

Part 4: Antivirus and Emailgatesways

Part 5: OpenVPN vs. IPSec

Part 6: My experiences

So stay tuned for part 1  !

Popularity: 12% [?]

Hi guys,

today we want to introduce you to what it means to be a game-tester. Being a tester doesn’t mean playing games all the time, but rather exploring every possible constellation in which a bug could appear.

Maybe you have been asking yourself already: “How is it possible that some games are full of bugs?” We have the answer! Some testers just don’t apply the right methods for their bug tracking.

This is why we would like to introduce you our favorite ways of testing now.

The first way is the “Switch off your brain”-method.

You just follow the instructions of the test-cases and note your results. If the test-plan is well-organized, this is an effective, but less creative method. And as no test-plan can cover all bugs, you need an additional, less structured method of tracking bugs!

Therefore, here comes our second option, which is: “Simply playing the game.”

You play the game without any evil bug tracking intentions – as if you bought it for your personal pleasure. The benefit of this way of testing is, that you have more freedom while playing the game. On the other hand, bug tracking is quite random in this case, which is a disadvantage and makes a further option necessary.

So, in total, our advice is our third approach to bug tracking. It’s the combination of testing method number one and two and corresponds to the following rule: “As structured as necessary, but at the same time as creative as possible”.

You have to test every state in every possible order. For example: The test-plan requests you to change the display resolution. In practice, there are two ways of doing so: You can either change the display resolution by using the main menu; but it is also possible in the course of the game. This means you have to think yourself. We have to admit, this example is not the best one, but the more complex a game is, more states in which bugs can occur will be given.

Next time we will reveal our secrets of how to raise the effectivity of your testing skills.

Thx 4 reading our first blog entry.

To be continued…

Popularity: 13% [?]

Singletons the curse and blessing of many coding projects. Among other pitfalls, you’ll basically introduce a global variable in your system, making UnitTests much harder.

Why Singletons?

Despite the possible problems they can present, they are just so darn handy sometimes. If there is some part of your code that needs to be accessed from almost anywhere in the system (like the sound system, or a global error text console and such) there is hardly a better way to achieve that.

Alternatives?
A global messages system to communicate between objects can achieve the same effect. We used to make heavy use of such a system system. However, according to our experience, maintaining that system is fairly time consuming for it gets more and more complicated over time. Besides, if a messaging system allows queing, you’ll never really now where and why a message was sent because you loose the stacktrace. So, right know we are reducing the work-load done by the message system, handing it over to direct singletons access. By this, we increased debugability and clearity of data transfer. Besides, using singleton access is much faster than routing it through our messaging system.

How to Do It?
The web already offers a bunch of solutions (1). Most of them boil down to implement the singleton code over and over again in each singleton. We didn’t like that and tried to come up with a better solution. When we define a singleton it looks like that:

/**
* Accesing this class somewhere in the code looks like this:
* cSomeController.GetInstance().DoSomething();
*/

public class cSomeController extends cSingleton
{
    public static function GetInstance():cSomeController
    {
        return cSingleton.GetInstance(cSomeController);
    }

    public function DoSomething()
    {
        trace("Yes, I can.")
    }
}

That is much simpler than copying&pasting the complete singleton code over and over. The corresponsing cSingleton-class looks like that:

package rsengine.patterns
{
    import flash.utils.Dictionary;

    /**
    * Singleton base class
    */

    public class cSingleton
    {
        private static var m_instances:Dictionary = new Dictionary();
        private static var m_unlockConstructor:Boolean = false;            

        public function cSingleton()
        {
          if (m_unlockConstructor == false)

          throw Error("You cannot create an instance of a singleton."
          + "Use GetInstance instead!");
        }

    /**
    * Returns an instance of the specified class
    * @param _class class
    * @return instance of specified class
    */

    public static function GetInstance(_class:Class) : *
    {
      if (m_instances[_class] == null)
      {
        m_unlockConstructor = true;
        m_instances[_class] = new _class();
        m_unlockConstructor = false;
      }
      return m_instances[_class] ;
    }
  }
}

Our singleton implementation significantly reduced the amount of code you have to copy&paste compared to the other singleton implementations out there on the net. We do know that our implementation of GetInstance() is a little slower (because of the Dictionary look up). Since you shouldn’t have too many calls to the GetInstance method this is probably nothing to worry about too much. Nevertheless, you could cache the result of GetInstance() if you do need to access the singleton more than once (e.g. in a loop).

Have fun and happy coding
Manuel

AS3: Singletons, ActionScript 3 Singleton Redux, google

Popularity: 17% [?]

Hello,

this posting is about InnoDB’s limitation of lower / upper cases and the resulting problems of
InnoDB database migrations to different operating systems.

THE TASK:

Import an InnoDB database from Mac OS  MySQL  5.x to Linux MySQL 5.x (in our case Rhel 5 ).

No big deal, I thought.

Made a mysql dump and imported the dump to Linux.   5 minutes work, just the way  admins love it !

THE CHALLENGE:

Imported the dump. I am done! That’s what I thought. Just let’s check the app that accesses the freshly imported DB.

Running the app brought me exceptions. Some tables couldn’t be found… URGH! Checked the tables… everything was fine. The dump was fine… the tables were present. WTF!!!!!

THE SOLUTION:

After 10 hours of pain, we found the solution.

MySQL and especially the storage engine InnoDB depends on the case sensitivity of the operating system. Windows and Mac OS (by default) are not case-sensitive.  So if you are importing a Mac or Win DB-dump to a case-sensitive operating system (like Linux), the DB will be handled case sensitively, although the dump is not a case-sensitive one. I think this problem should be fixed. I know fixing this problem is nearly impossible because the OS has to be capable of doing this. But giving some sort of warning while importing a non-case-sensitive DB to a case-sensitive DB-Server… that can’t be so difficult !

How to fix our specific problem:

Add the following line to your MySQL Server Config:

lower_case_table_names=1

By default Windows MySQL uses lower_case_table_names=0 and MacOS MySQL lower_case_table_names=2

The MySQL documentation advises setting lower_case_table_names=1 for InnoDB. For more information, please read the MySQL documentation.

Popularity: 18% [?]

Something I really missed in Actionscript 3 were enums. If you need ascending unique numeric ids ( e.g. for naming array indexes ), enums are your friend.

For our current project we programmed a messaging system. The system uses unique numeric ids for message types and message channels. The list of messages and channels grew over time and right now each list contains more than a hundred entries. In the beginning we did the numbering ourselves like that:

    public static const MSG_OPEN_WINDOW:int = 0;
    public static const MSG_CLOSE_WINDOW:int = 1;
    public static const MSG_REGISTER_TIMER:int = 2;
    // .. and so on

For code beauty we were always trying to group related message ids, which often meant to re-index dozens of entries if we inserted an id somewhere in between. This was a pain!

The net already has assembled quiet some wisdom about “fake enums ins as3″¹, which do fit different needs (like some have type safety) but unfortunately not ours. Most of them are String based, which is what we did not want. So after putting in some thought we came up with a solution that worked for us. Now we can define our enums like this:

    public static const MSG_OPEN_WINDOW:int = cEnum.Enum(0);
    public static const MSG_CLOSE_WINDOW:int = cEnum.inc;
    public static const MSG_REGISTER_TIMER:int = cEnum.inc;
    // .. and so on

Now, by using static methods and a static counter we can create an arbitrary amount of coherent numeric values, which comes in very handy from time to time! Re-indexing is in the past now!

We want to share our little enum class with the web, so here it comes:

public class cEnum
{
	private static var m_currentIncrement:int = 0;

	/**
	 * Adds an enum value to the collection
	 */

	public static function Enum(_v:int) : int
	{
		m_currentIncrement = _v;
		return m_currentIncrement;
	}

	/**
	 * returns the next increment
	 */

	public static function get inc():int
	{
		return ++m_currentIncrement;
	}
}

Bottom line, if you need a neat way to maintain a list of static coherent numeric entries while type safety is not a big issue … this is an fairly easy way to do it. May this help you out there as much as it helped us.

Have fun and happy coding
Manuel

¹ Further readings on AS3 enums can be found here: e.g. http://www.herrodius.com/blog/87,
http://scottbilas.com/blog/faking-enums-in-as3/
or http://blog.petermolgaard.com/2008/11/02/actionscript-3-enums/

Popularity: 29% [?]

The Rough Sea Games team wishes you a Happy Halloween 2009!

Popularity: 57% [?]

I have finished the last part of the BadAss Rabbit graphics workshop (part 4 of a series) for the German game developer magazine ‘Making Games‘. In this series I created a 3D lowpoly game character model. You can find the workshop in Making Games 04/09, which is out now. Here you can see a test animation from the workshop:
Bad Ass Rabbit – Testanimation

Chris

Popularity: 61% [?]

Automatization of repeated work is one of the keys to productive development. Another is abstraction of common problems to allow concentration on project specific work. Localization is one of the problems you have in nearly every project, especially in iPhone projects. The iPhone SDK brings interesting solutions that abstract many parts of the localization process.

The tool ibtool, for example, extracts strings from an interface automatically. The strings are placed in a .strings file, a textfile with key/value pairs. To localize an interface, you have to translate .strings and merge the strings back into the interface again. Because you have individual interfaces for every localization, it’s possible to adjust widgets individually for each one.

genstrings is another tool inside the iPhone SDK. It extracts textIDs from the source code and write them into a .strings file. You may ask how the tool knows which texts need localization and which do not. The solution is the macro NSLocalizedString, which will be replaced by a .strings file lookup method by the preprocessor, but also searched for by the genstrings tool to create the files.

Both tools help you to create a localized application without paying much attention to localization itself. But you cannot expect the localization department to search for .strings files inside your project and create localized versions of them. Of course this would be possible, but not very convenient, because you have to migrate the translated texts back into the interfaces using ibtool. Another reason for us at Rough Sea is that we use a localization interface from our publisher. This interface is well known to the localization department and the content is placed in a centralized database on a server.

So we have the great tools from Apple that help us to separate texts from the project and we have the great tool from our publisher that handles the whole translation and reviewing process. Now we need something to tie those tools together, because we do not want to insert new texts from the .strings file into the publisher’s localization tool manually or vice versa. This glue tool has to execute the Apple tools, extract the texts from the .strings files and insert them into the publisher’s loca tool. On the other hand, it has to check for new localized texts from the publisher’s loca tool, build the required .strings files from the results and merge them back into the interfaces. Sounds quite easy, but of course there are some obstacles to get there. You have to handle other things, like the deletion of a text entry or changes to an already translated interface. So you have to know what has changed since the last update and stuff like that.

It turns out that you only have to integrate this glue tool into the build process of your build server. The tool will update the localization database whenever the code or the interface changes and it will update the localized versions when the database changes. As a coder you only need to remember to use the text macro around your text id. You don’t have to add this text id in a file or anything else. As you commit your changes, the build server will do this for you. As an interface designer it’s the same: just create your interfaces in the primary language and commit it. After the localization department finishes localizing those texts, they will be inserted into the localized versions automatically. Of course you have to make adjustments to the interface if there are loca bugs like labels that are to small to hold the translated text.

As you can see those localization tools are a big black box for coders, interface designers and translators. The coders only have to write code, the interface designers design interfaces and the translators translate texts. At the end there will be a localized product.

Popularity: 66% [?]