Stack Size

The game started to crash randomly before I noticed, it’s quite hard to debug, especially without the tools in Xcode or other IDEs provide. And it never crash in the simulator, so the debugging is quite awkward, a lot of guess, build, test-run going on.

When it crashed on iOS device, some information were provided, though full stack trace is not availabe, and the place of crash is not consistent. After 2 or 3 days and nights figihting with this bug, finally found out the root cause, which is very surprising.

It’s caused by stack overflow, since Marmalade is designed to support many different mobile devices, many of them are with limited hardware, the stack size is 32k by default, since I’m having a LUA layer, and also allocated some string buffer in stack for convinience, it got overflowed, so caused the random crash.

There is actually a forum thread mentioned this.

Since I only plan to support the modern devices (iPhone, iPad, maybe Android as well), gave it a much bigger setting fix the crash perfectly.

1
2

   [s3e]
   SysStackSize=4000000

Accelerate framework

I’m using libBass for the audio playpack, for some reason it require Accelarate frame under iOS to compile. so I add iphone-link-opts="-weak_framework Accelerate" into the mkf file.

For unknown reason, the Accelerate.framework stub in /Developer/Marmalade/6.2/s3e/deploy/plugins/iphone/sys_libs/System/Library/Frameworks/Accelerate.frameworks/Accelerate is not working, might be the nested frameworks inside it.

Not really understand how the stub frameworks work in Marmalade, seems a smart way to use the system’s SDK libraries, though a hacky solution make it compiled.

Current fix is to copy the framework from /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS6.1.sdk/System/Library/Frameworks/Accelerate.framework. Not sure whether there is side effects.

1

cp -r /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS6.1.sdk/System/Library/Frameworks/Accelerate.framework/* /Developer/Marmalade/6.2/s3e/deploy/plugins/iphone/sys_libs/System/Library/Frameworks/Accelerate.framework/

iOS device crash report

This page explains how to read the crash report nicely, also don’t forget to save the mapping file of the version you submitted to app store, otherwise you will have no idea to debug when get crash logs from Apple.

How to map iPhone crash log addressed to your code

Some mkb settings

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

deployments
{
    name="Slingshot"
    version=1.0

    ["Default"]
    iphone-provisioning-profile="data/provisions/DayDayBirdsDev.mobileprovision"
    iphone-enable-4inch-retina=1
    iphone-no-splash=1
    iphone-prerendered-icon=1
    iphone-icon="data/icon/Icon.png"
    iphone-icon-high-res="data/icon/Icon@2x.png"
    iphone-icon-ipad="data/icon/Icon-72.png"
    iphone-icon-ipad-high-res="data/icon/Icon-72@2x.png"
    iphone-icon-ipad-search="data/icon/Icon-Small-50.png"
    iphone-icon-ipad-search-high-res="data/icon/Icon-Small-50@2x.png"
    iphone-icon-settings="data/icon/Icon-Small.png"
    iphone-icon-settings-high-res="data/icon/Icon-Small@2x.png"
    
    #Android
    android-icon="data/android/icon/icon_48.png"
    android-icon-gallery="data/android/icon/icon_170.png"
    android-icon-hdpi="data/android/icon/icon_72.png"
    android-icon-ldpi="data/android/icon/icon_36.png"
    android-icon-mdpi="data/android/icon/icon_48.png"
}

iphone-enable-4inch-retina=1 enabled the iPhone 5 wide screen mode.

Some app.icf settings

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

DispFixRot="Landscape"
IOSDispScaleFactor=200

{ID=IPHONE "iPad1,1"}
[s3e]
memSize = 30000000
SysStackSize=1000000
{ID=IPHONE "iPad2,1","iPad2,2","iPad2,3","iPad2,4","iPad2,5","iPad2,6","iPad2,7"}
[s3e]
memSize = 64000000
{ID=IPHONE "iPod1,1","iPod2,1","iPod3,1","iPod4,1","iPhone1,1","iPhone1,2","iPhone2,1"}
[s3e]
memSize = 34000000
SysStackSize=1000000
{ID=IPHONE "iPod5,1","iPhone3,1","iPhone3,2","iPhone4,1","iPhone4,2"}
[s3e]
memSize = 64000000
{OS=ANDROID}
[s3e]
memSize = 80000000
{OS=OSX}
[s3e]
memSize = 256000000
{}

DispFixRot="Landscape" is to lock the screen rotation to be landscape only, I’ve met quite some problem with landscape, probably will write another post about it.

IOSDispScaleFactor=200 is used to activate the retina screen support, so the resolution of retina iPad will be 2048 x 1536,

It took me quite some efforts to learn how to do the device-specific settings in app.icf, the syntax is quite complex, the marmalade documents actually cover this, though lacking good samples.

There are quite some libraries to support xm playback, though I can’t find any Marmalade extensions on the web, in the forum someone mentioned that they made use of FMOD in their game, though there is no code shared, and FMOD is quite expansive.

After some search, I decided to use BASS audio engine, which is quite powerful, with well designed API, not bad documentation and sample, and a reasonable price for small projects (the shareware license can cover product with small price).

Now I’ve got a working extension(though the only test I did was to play a xm file on OSX, iOS and Android), think other people maybe interesting in the extension or how to create similar extensions, so I’m going to share the extension and some experiences I’ve learn from the process(not in this post).

Quick Note about Implementation

BASS itself support many platform, the platforms I need are: OSX, iOS, Android. It’s pure C, so it shouldn’t be too hard to make it work with Marmalade. Though it took me quite a while to get some basic idea about the Marmalade extension system.

Most documentation from Marmalade about extensions seems focusing on writing platform specific codes in custom extension, in this case, it’s actually much more easier since BASS is already platform independent, all we need is to make it work with Marmalade’s build system.

Will write more about how to wrap C libraries into Marmalade extension in other posts later.

Code of the Extension

Since basically I have no idea about how to use BASS now, I just tried to use some codes from the BASS examples, it works pretty good, the xm files sounds quite good.

Think I will write some wrapper layer around the C function calls to expose audio functionalities to C++, XML and Lua codes. Guess I will have much better idea about it in a couple of months after our first game get done.

I’ve put the codes at Github, feel free to clone it, and give it a try. see the github pages for more details about it.

There are quite some tools to generate such font images, I’m using bmGlyph as the font generator, it can publish the popular “Cocos2d / BMFont” format, though it’s not directly usable in Marmalade.

Marmalade is using its own font format, and provide a font generator in the SDK, though it only support plain color, and when I feed it with some Chinese characators, they are not included in the generated files. I’m using the OS X version of the font builder, not sure about how the Windows version works.

My first thought was to add function to use the BMFont generated, though it’s not an easy task, also I want to use IwGame’s label components, which are based on Marmalade’s GxFont and Truetype support.

After reading GxFont Reference, turns out it’s using a fairly simple format, so I decided to write a converter to create gxfont files.

Code of the Converter

I’ve put the codes at Github, feel free to clone it, and try to run it. see the github pages for more details about it.

The converter support UTF-8 characters with no problem, the size of the tga files is a bit big comparing to the Cocos2d version, since more empty spaces are needed for GxFont format.

It’s kind of a straight-forward implementation, and probably there are ways to make it better, especially if the bmGlyph’s console support is out (in the coming feature list now), the whole process of extracting characters from data file, create Cocos2d font, convert to GxFont can be fully automatied.

Just read the code if you’re interested in the implementation details. :)

Here is a screenshot of the level editor:

Updates about Original Post

Before talking about the level editor, first I want to share some updates about Marmalade and IwGame in the last month.

First, Marmalade 6.1 was released, it’s great for me, the 2 most useful feature for me are: Open GL ES 2.0 shader support in simulator, easy to debug shader now, and OSX deployment to send game/editor as running application to Graphic Artists.

Second, DrMop commented in the original post, assure that IwGame is very actively developed and version 0.40 is about to be released.

Quick test with Chinese characters in CIwGameActorText, it works out of box, just specify a truetype font, write the text in UTF-8, then it’s done. I guess there is no need for CIwGameString to support unicode, since it can pass the bytes to Marmalade correctly.

Current Features

Now back to the level editor, it support image objects with layer(display order), depth(for parallel perspective), users can add/remove/copy/group objects, and can change position/size/scale/angle/origin with mouse, zoom in/out and move the camera around. Also I’ve integrated a Box2D debug view, and you can edit simple shape in it too (boxes and circles).

Actually it’s a bit easier than I thought to implement it, caused me about 5 weeks so far, worked quite hared during the time, but also had a basic animation editor and a game prototype at the same time, so the pure time on it was about 3 weeks.

Our graphic artists have already used the editor to build a few nice scenes and they are getting more productively with it day by day, It’s just what I wished it to be: a tool to make developer and other roles to collaborative more effectively, think it’s at the right direction.

Also it’s extremely useful for prototyping and debugging, the way I did it is to add a few tools around the objects, so when you’re running your game, you can switch to editor mode at any time (by tapping the tab key), then you can check the scene to see what’s going on, or adjust the objects right in the editor, then you can switch back to game mode. It feels like you can freeze time in game at any time, then make changes, then go back, very cool, and very useful.

To make it clear, here is a screenshot of our game prototype:

After I switch to editor mode, and zoom out a bit, I can get the screen as the first screenshot, then I can adjust the level, and switch back to keep playing. Our graphic artist feels very happy with this in game editing ability, they can see their changes instantly, which make the whole process very efficiently.

Another very useful feature is the Box2D shape editor and debug view, we can create boxes and circles right through the level editor, they will be effective instantly, so for a game based on Box2D, it’s very easy to create the levels by non-programmers.

Here is the same game prototype with Box2D debug view enabled:

As you can see, we use boxes and circles to create a rather complicate level. Also it’s very helpful to debug the collisions between objects, e.g. when I was implementing the effect of arrows hitting targets.

What’s Missing

As a basic level editor with advanced features (particle, animations…), I think it’s quite complete and usable, we’ve got quite some prototype scenes with it till now, and the artists feel happy with it most of the time.

The biggest missed feature is undo/redo, only deleting have a quick undo since it can cause big trouble when touch wrong key accidentally. To make it better, all version of saved files are kept on disk, so if you made big mistakes, then it’s recoverable by hand. It’s non trivial to implement a good undo/redo system, so probably this feature will only be added in a much later stage.

Also there is on gui at all, all functions are done by keyboard shortcut and mouse movement, so there is a learning curve, and you’ll feel a bit awkward at first. Though this is the quickest way for implementation and also for actually using IMO, after a few days using it, both of our graphic artists can use it with no big problem, and they said that it’s a bit geeky feeling when using it. :)

And manual works required to create a skeleton scene and import images to it, it’s not hard, just running some python scripts, but it’s still not so simple for non-programmers.

What’s Next

Guess I’ll keep improving it, fixing bugs first, now the focus is character animation editor, and the game prototype. After that, I’ll add particle feature to the level editor.

I feel quite happy doing this kind of tool works, and actually it’s not hard to make it usable as a standalone project and let other people to use it. e.g. I can make a converter to generate cocos builder format, then it can be used in cocos2d projects. Or if I make my animation editor to export spriter’s xml syntax, it can be used in many other projects too.

And at least for myself and our graphic artists, we think that our homebrew tools are much easier to use and feature complete (for just our needs) comparing to the tools we’ve tried. e.g. cocos builder, sprite helper, and spriter. Not saying that my editors are better products, just they are tailored by exactly our need and my design approach, and since it’s integrated in the exact game process, the workflow is much better comparing to a 3rd party tools. Also our level is pretty big(currently the demo scene is about 20000 pixel wide, and the engine/editor can support much bigger usage), I can’t find a proper tool to handle such big scene.

Though making a generic tool will involve many not so interesting works, and it’s very hard to make it works for more people, and probably my tools are just too tailored to our need, so I think I will keep focusing on our games in the near future.

But anyway, I already have some demo scene editor running as OS X application, will make it downloadable in next few days, after I wrote a very basic manual about it. like Jakub commented in the original post, even if I decided to keep it private, it can still help others a bit, and maybe by using it in a experimental way, people can get some ideas about improving their own tools.

If you are interested to see more information about the editor, please leave comments, thanks.

I’ll try to post more about technical details about some aspects of the editors, some hacks I used, and some mistakes I’ve overcomed.

I decided to only support Open GL 2.0 Shaders in our games, most current devices support it, and as a small team, supporting older devices is a bit hard since we don’t have testers for now, also the architect of 2.0 is simpler and cleaner.

The sample shader’s function is to replace non-transparent part of the image to a given color, then the color can be changed programmingly (also by xml thanks to IwGame). Basically the images will be just working as masks, the actually color to be rendered are controlled by the shader.

I will not cover the basics about Open GL Shaders, there are plenty of information on the web about that, also a PDF doc is included in Marmalade installation, it’s a good start point to me, you should read it first to get the concepts.

Marmalade Rendering with Custom Shader

Marmalade support shader very well by the CIwGxShaderTechnique class, to use it, you need to set it to material, here is the snnipet for that:

1
2
3
4

CIwMaterial* mat = IW_GX_ALLOC_MATERIAL();
mat->SetTexture(image->getImage2D()->GetMaterial()->GetTexture());
mat->SetShaderTechnique(shader);
IwGxSetMaterial(mat);

The shader here is a pointer to CIwGxShaderTechnique, and the image is a pointer to CIwGameImage (part of IwGame), if you are not using IwGame, you can use Iw2d, or IwGx directly.

The following function can load a shader from a resource group.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

CIwGxShaderTechnique* getShader(const char* shaderName) {
    CIwGxShaderTechnique* shaderTemplate = (CIwGxShaderTechnique*)IwGetResManager()->GetResNamed(shaderName, "CIwGxShaderTechnique");

    if (shaderTemplate == NULL) {
        return false;
    }

    shader = new CIwGxShaderTechnique();
    IwSerialiseOpen("shader-Duplicate.bin", false);
    shaderTemplate->Serialise();
    IwSerialiseClose();

    IwSerialiseOpen("shader-Duplicate.bin", true);
    shader->Serialise();
    IwSerialiseClose();
    return shader;
}

Note: since I need multiple instance of the shader for diffrent images with differnt colors, here I use a quick solution with marmalade’s serialization, which is NOT thread safe due to the hard code file name.

Load the resource group as this:

1

IwGetResManager()->LoadGroup("effect/Shaders.group");

Files Used

You need to include the shader files in the asset section of the mkb/mkf file, like this

1
2
3
4
5
6
7
8
9
10
11
12

files
{
    [Data]
    (data)
    effect/Shaders.group
}

assets
{
    (data-ram/data-gles1)
    effect/Shaders.group.bin
}

Please refer to Marmalade’s documents if you are not familiar with the resource compiling process and mkb syntaxes.

Here is data/effect/Shaders.group

1
2
3
4
5
6
7

CIwResGroup
{
    name "PettyFun Environment Shaders"
    shared true

    "./PfMaskEffectShader.itx"
}

The content of data/effect/PfMaskEffectShader.itx

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

CIwGxShaderTechnique
{
    name "PfMaskEffectShader"

    param "p_Color" vec4 1 {0.0, 0.0, 1.0, 1.0}

    shader "vertex"
    {
        attribute highp vec4 inVert;
        attribute mediump vec2 inUV0;

        uniform highp mat4 inPMVMat;
        uniform mediump vec2 inUVOffset;
        uniform mediump vec2 inUVScale;

        varying mediump vec2 v_UV0;

        void main(void)
        {
            gl_Position = inPMVMat * inVert;

            v_UV0 = inUV0 * inUVScale + inUVOffset;
        }
    }
    shader "fragment"
    {
        uniform sampler2D inSampler0;
        varying mediump vec2 v_UV0;
        uniform mediump vec4 p_Color;

        void main(void)
        {
            mediump vec4 c = texture2D(inSampler0, v_UV0);
            if (c.a < 0.1) {
                gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
            } else {
                gl_FragColor = p_Color;
            }
        }
    }
}

Please read IwGxShaderTechnique Reference for the list of the attributes that you can use. It took me quite a while to find this document since this is no links to this page on the class reference page. This is VERY useful for writing shaders in Marmalade.

Update Params By Code and XML

the param in the shader is for the parameters from your code, change it’s value like this.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

void PfShaderEffect::SetShaderParam(const char *paramName, CIwGxShaderUniform::CIwGxShaderUniformType type, const void* value) {
    if (Shader == NULL) return;

    CIwGxShaderUniform* param = Shader->GetParam(paramName);
    if( param ) {
        param->Set(type, 0, value);
    } else {
        PfTrace("Shader Param Not Exist: %s", paramName);
    }
}

void PfShaderEffect::SetShaderParamAsInt(const char *paramName, int value) {
    SetShaderParam(paramName, CIwGxShaderUniform::INT, &value);
}


void PfShaderEffect::SetShaderParamAsFloat(const char *paramName, float value) {
    SetShaderParam(paramName, CIwGxShaderUniform::FLOAT, &value);
}

void PfShaderEffect::SetShaderParamAsColor(const char *paramName, CIwColour value) {
    float color[4];
    color[0] = 1.0f * value.r / 0xff;
    color[1] = 1.0f * value.g / 0xff;
    color[2] = 1.0f * value.b / 0xff;
    color[3] = 1.0f * value.a / 0xff;
    SetShaderParam(paramName, CIwGxShaderUniform::VEC4, color);
}

void PfShaderEffect::UpdateColorFromAnimation(CIwColour* color, CIwGameAnimInstance *animation) {
    CIwGameAnimFrameVec4* value = (CIwGameAnimFrameVec4*)animation->getCurrentData();
    color->r = value->data.x;
    color->g = value->data.y;
    color->b = value->data.z;
    color->a = value->data.w;
}

Since I’m using IwGame, it’s very easy to make the color controlled by the XOML animation, all I need to do is to override the UpdateFromAnimation method of CIwGameActor, and handle the color value from it.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

bool PfMaskEffect::UpdateFromAnimation(CIwGameAnimInstance *animation) {
    if (PfShaderEffect::UpdateFromAnimation(animation))
        return true;

    bool delta = animation->isDelta();

    unsigned int element_name = animation->getTargetPropertyHash();

    if (element_name == PfHash("Color")) {
        UpdateColorFromAnimation(&Color, animation);
        SetShaderParamAsColor("p_Color", Color);
    } else {
        return false;
    }
        return true;
}

Then you can generate smooth color switch animation by pure XML as normal IwGame Animation.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<Template Name="MaskColorTimelineTemplate">
    <Animation Name="MaskColorAnim$name$" Duration="$duration$" Type="vec4">
        <Frame Value="$startcolor$" Time="0" />
        <Frame Value="$endcolor$" Time="$duration$" />
    </Animation>
    <Timeline Name="MaskColorTimeline$name$" AutoPlay="true">
        <Animation Anim="MaskColorAnim$name$" Target="Color" Repeat="1" StartAtTime="0"/>
    </Timeline>
</Template>

<Actor ...>
    <FromTemplate Template="MaskColorTimelineTemplate" name="ColorChange" duration="2"
        startcolor="180, 220, 251, 255" endcolor="255, 0, 0, 255" />
</Actor>

This is very flexible and powerful, no need to recompile, just updating plain XML files.

Our games will be mostly 2D games, might with some 3D charactors, though the scenes or levels will be 2D, I think that’s better for the team and the graphic quality of the games.

After quite some readings and experiments, I finally have a clear idea about how we gonna build these games, We will create our small game engine, on top of Marmalade and IwGame.

Why choose Marmalade?

I did have quite some experience on cocos2d, though it’s been ruled out pretty quickly. I want our game to work on multiple platforms, since we don’t use much platform-specific features, we don’t get much with objective-c. Also personally I am not really a big fan of cocos2d, it’s kind of a simple framework with good quality, though missing some of the features I want with a solid framework, e.g. Tool or Markup for graphic scene editor, I’ve tried Cocos Builder and Level Helper very breifly, might be just me, but I don’t like neither one. A similar option is to go with cocos2d-x, which is cross platform, but because of similar reason, I didn’t dig into it deeply.

The second option is Unity3d, I’ve used it for about 3 months before, It’s pretty good, easy to use, and have a hugh community with tons of good plugins. My biggest concern about it is the binary format of the prefebs, it’s a bit like the xib file in App development, hard to change and track, as a developer, I want a text based format. Also don’t really think the .Net virtual machine is the best way for our rather small games. My feeling is that it’s more like a tool for game designers and graphic designers, as developers, we gave up full control in exchange with a full-feature game development environment. And also it’s mostly 3D centric, 2D works are possible, but a bit awkard, since we don’t need the 3D power and I want more control with my codes, I did not take this path either.

For good performance and graphic effects, I didn’t investigate the fast development tools, most of them are HTML based or LUA based, more like quick prototype tools for me.

I’ve played with Airplay for a couple of days 2 years ago, technically it was very good, though with a rather steep learning curve, and lack of tutorials and blog post, so I didn’t really learn it as a hobby. Now it’s renamed to Marmalade, been updated pretty often, and having a much bigger user base and many successful games are based on it, like Draw Something or Cut The Rope. Since I will use the chosen platform for at least 1 or 2 years, I spend a week to really try to learn it this time.

The first impression was kind of negative, the OSX support seems to be much weaker than the windows one, a bunch of small problems were met, which almost make me give it up. Now I’ve been using it for about 1 month, still got some problem, though I think I start to feel comfortable with it.

There are still very few technical information about marmalade other than the official documents and forum, the only helpful tutorial I can find is the DrMop tutorials. It’s very helpful to provide basic ideas for new Marmalade users.

The API documents of Marmalade is actually quite good after you get the basic ideas about it. Also the examples included are good learning source.

My current feeling about Marmalade is quite positive, it has nice features and solid quality, provide full control, has native bridge for potential platform-specific development.

The things I wish to be better:

• 1st class OSX support, add the missing features of the simulator, fix the broken “mkb –iphone” device building (only trid on 10.8 + Xcode 4.4, not sure about other environments). (Update: –iphone is fixed in 6.1, simulator seems not updated)
• Release to osx ability, then I can create desktop tools such as customized level editor instead of let my graphic designers to use the simulator to run them. (Update: Added in 6.1)
• Float data types in IwGx, it’s said to be included in 6.1 release which should be out soon, much simpler and less error-prone, we’ll target on OpenGL ES 2.0 devices only (iOS devices first) to make our life easier since we can’t afford dedicated tester anyway. (Update: Float added in 6.1 and works great, though we probably will not change IwGame to use float)
• High level document besides API reference, and generally more documentations.
• Better community and 3rd party components, it’s quite unpopular in stackoverflow, very few blogs, and the github community projects are not very active and organized.

What is IwGame, and Why it is Helpful

Marmalade is very low level, its design priciple is that people can make their engine working on it rather easily, but we don’t have any game engine yet, so either I need to write a 2D engine from scratch, or choose a C/C++ engine to work with. Cocos2d-X works on Marmalade, though I want something more powerful. Many 3D engine works on it too, but they are too complex to me, I probably will choose Unity3D if I want a 3D engine.

According to the website, IwGame is a “Free Open Source Cross Platform Mobile Game Engine for Smart Phones and Tablets”, it’s a quite ambitious project, already has a long feature list with many future features, though still in an rather early stage.

The main reasons I chose it:

• Open source, I can tweak the codes to suit my needs better, and even if its development stopped, we can still improve it by ourselves.
• XML file format, it’s very powerful, e.g. make simple animations easily without coding. Also it’s very easy to extend the system to add our own extensions. This is a hugh advantage to me.
• Complete 2D framework, including sprite, scene, particle, physics, UI… No need to reimplement the basic things from the scratch, we can focus on more interesting stuffs.
• Support 2D and 3D rendering, since the rendering codes are based on IwGx now, even for 2D games, some part of 3D elements can be very useful, so I think this flexibility is very good.
• Good document and a full game source included, there are quite some typos in the included PDF document, though it provide most information I need to get started, plus reading the source code, It’s kind of easy to learn (though still much harder comparing to cocos2d family).
• Good code quality, easy to read and not hard to expand.

Some worries about base our codes on it:

• It’s a big project, and seems most code and docs are written by DrMop in several monthes. He did very great so far, though he has too many works ahead him, I am not sure where this project will be after 1 year, what if it’s dead? also it’s been a while since the last update.
• On the other hand, if it’s been developed rapidly, since it’s not finished yet, we will need to expand it by ourself, it can be a problem to keep update with the future updates. I don’t want to make a fork since many good features are on the list, though we can’t wait for they to appear, We will be careful with out changes to make them easy to merge, but what if the owner decide to change the API interface drasticly?
• The core string class (CIwGameString) is not unicode compatible, and the author didn’t have plan to support it soon. This can be a big problem for us to support multiple language, especially the asian languages. I want to find a clean solution for this, though haven’t started working on it yet.
• There is no unit tests yet, so it might introduce its own bugs, especially if it’s been update quickly.

My Plan on The Game Engine

Now I feel OK working with Marmalade and IwGame, the next steps will be creating the features/tools we need for our games, i.e. create a game engine for our requirements.

Here is the current list of works to be done:

• Basic level editing, to arrange 2D sprites on screen, supporting basic operations such as moving, scaling, rotating, etc. Our level/scene will be 2D non-tile with multiple layers, something similar to this
• Complex charactor editing, 2D or 3D charactors with body parts, movement and animations.
• Advanced level editing, particles, visual effects, events, etc.
• UI editing.

All these editors will base on the XOML markup system of IwGame.

These are still quite some works, might be over engineering for our first game, though as a developer, I don’t want to just do things in the quick and dirty way, I want to do it in a proper way. And I think a proper engine can make future games easier to develop, so in the long run, it will worth the efforts.

Think I will start to write more about Marmalade and IwGame in the future, both help myself to understand them better, and hopefully might help some other developers too.

之前工作的公司是做外包的，因为环境和人都不错，在那里工作了好几年。渐渐的由一个独自写代码的程序员，认识了很多同行，接触了开源技术，开始做技术管理，和不少面试培训的工作。过程中学到了很多，也对自己能做些什么，有那些长处开始有了信心。

外包的好处是比较清闲，压力并不大，在技术和流程上做的相对比较完善，然而外包最大的问题是实质上是不鼓励程序员有太高的效率的。由于技术难度和工作效率的难以衡量，很难判断是效率高低还是项目难易的关系导致的工作时间的变化。虽然业内都会同意好的程序员和差的程序员的生产率会有数十倍的差距，然而外包的很大出发点就是节约成本，想给好的程序员提供有吸引力的条件是很难的。

我们做的是个长期项目，基本是按人数计算收入的，也就是说在客户关系正常的情况下，项目组的人数越多，公司得到的收入也就越多。因此，运作的模式基本是比较好的程序员倾向于成为技术组长，把大量的时间花在如何让其他能力不够强的程序员正常工作上，具体说来就是大量的代码审查。

读别人的代码，并提出意见，最终改善的过程，对于程序员来说是个很好的学习提高的过程，我也做了很久。但是工作的内容往往技术含量并不高，受到扩大规模的压力，进人的标准也渐渐放低，感觉自己做的事越来越没有意思，虽然通过业余时间做了些纯技术的学习，然而已经感觉在工作中没有热情了。

公司在iPhone刚出来不久就开始了产品开发的尝试，选择的方向是游戏，做了两款小型游戏，有些进展，然而收入不够理想，老板把方向调整为社交相关的方向，不过产品开发过程有点纠结，花了相当长的时间做了一款相对比较大的产品。（最终结果还是很好，产品有自己的创意，相当成功）

一直和我的上司说着想到产品部门工作，但不知为什么，一直也没能过去，可能是成本问题，不过自认为从工作效率来看，让一些能力还不够强的程序员开发产品，可以说是事半功倍，走了很多弯路。

2010年3月的时候，公司给了我一个月的时间，在产品组工作，让我找到了久违的兴奋感。用了1周的时间熟悉了 Objective C, Xcode, iOS 基本知识，然后用了3个星期的时间，学习 Cocos 2D，Box 2D，开发了一个小小的游戏，iPad上面 4 个人同时对战的碰碰车游戏，成功通过审核，App store 上线了，自己还是很自豪在短短的一个月中所取得的成果。

策划与执行的冲突

而在这一个月中的后两周，其实相当不顺利，原型已经有了点样子，这时老板作为 Product Owner （SCRUM 中的术语，基本上相当于产品经理，对产品的方向和细节拥有决定权的角色）介入了，开始定义 Milestone，给需求排优先级，并对任务是否完成做出判断。

老板是个典型的产品人，极度自信，又追求细节，同时又是个程序员出身，有时也会流露出 “这不是很简单么” 的态度，不是个容易合作的，不少同事也警告过我。

我在开始之前想得还是比较简单，一个是项目太小了，除了我自己，恐怕也没人真正相信能做出一个可发布的东西，再一个是老板很忙，没理由花太多时间在这么一个小小的项目上，Product Owner 应该是挂名的。

事实证明我错了，还相当彻底，老板极其认真的行使了 PO 的权力，让我又一次切身体会到了策划与执行的角色冲突。

冲突的关键在于两点，物理与操控，物理相对抽象，老板想要好的车的 “感觉”，参考游戏是 Wii 上面 Rayman 里面的碰碰车小游戏，问题是它是3D的，大屏幕的视觉感和 iPad 不一样，节奏相当快。我对 Box2D 了解的又很浅，几次尝试也没能得到很理想的结果。

操控是个更大的问题，iPad 的 4 人同时操作，意味着每人只有很小的一点屏幕面积可供使用，而且触摸屏意味着反馈的基本缺失。我的一个想法是提供基本操控，同时提供手机连接，使用加速度仪来实现近似 Wii Remote 的操控。基本代码用了两天，然而老板很生气，说我没有按照优先级，联网功能完全不在计划中，说我浪费了两天时间。最后的结果是，我先后实现了模拟摇杆，两个按钮，三个按钮，油门、方向，的多种操控方式，也没能得到他想要的效果，一起调了几次参数，当时 OK，过一两天就又要再改。

累一点我没问题，不过我觉的自己在浪费时间，还剩下 1 周多点，除了加上美术的图片，和之前的原型没有本质的区别，是不是完不成了？

于是渐渐摩擦开始了，我想先把一些必须的功能做上，像是计分功能，在尝试些可能的方向，像是手机操控、甚至联网游戏，而老板坚持必须把操控调好，其他的都要推后（最后的版本并没有计分功能，也是玩家抱怨所集中的一点）。问题是他只能说出什么不好，而不能告诉我该怎么做，进度上直接的结果就是做不完，又拒绝采用渐进的方式、在今后再做改进。

从他的方面可能感觉就是我开始不听话了，作为一个程序员，不应该坚持自己的想法，应该无条件服从 PO 的安排，为了项目的整体考虑。

于是矛盾慢慢积累，终于爆发了，在一次对操控的反复之后，我们比较激烈的吵了起来，他没有能从道理上说服我，而试图用 PO 的身份来解决问题，让我服从，潜台词是我过于情绪化，没有用专业的方式处理冲突。

不再觉的这是自己的产品了

我觉得他也有一定的道理，毕竟不可能大家想法都一致，PO 的设置也是要在有冲突的时候加以解决，所以又试着更听话一点，再试试，也许真的能找到理想的操控方式。

和之前与客户的冲突不太一样，以前也会试图坚持自己的想法，发上一两封信，说出自己的想法，好像就可以了，一般客户都会坚持自己的，我也会尽量的照他们的做，尽管暗暗认为在做错误的事，反正客户有权利选择错误。而这次似乎有些不同，怎么也无法集中精力来做，进入不了状态。

其实这就是对待自己的产品和别人的产品的区别，虽然小，但这原本是我自己的产品，当其他人用身份、职务来试图控制它时，我才会愤怒，想要继续把它当成自己的产品，如果失败了，我便无法用同样的热情来继续下去了，原本很有意思的编程似乎也变了味道，晚上回家也会玩玩游戏，上上网，无法再每天十几个小时的投入到开发中去了。

后面一个多星期的时间好像过的比较快，我写信又做了一次努力，想成为 PO ，老板不同意，不过也没在项目上继续之前的纠缠，匆匆做了些调整，加了声音，画面继续润色，最终在一个月到期的时候成功提交，一周后通过审核，收入么也只有一点点而已。

从中学到了些什么？

首先技术上学了不少，Objective C，Xcode， iOS API，Cocos2d，Box 2d，iOS开发流程。

游戏的润色很重要，代码上的原型和产品的差距远远没有美术上的大，好的美术设计对游戏来说太重要了。

产品人的权利很大，但很容易把项目变成“一个人的产品”，把其他的参与者变成纯粹的“打工者”，这对开发效率的影响是非常大的。

最重要的是，我不希望一辈子只做程序员，希望能有机会做自己的产品，或是找到合适的方式，让一组人都发挥各自的最大能量，从管理的角度把产品做好。

后来

之后又回到了外包团队，继续之前的工作，很快就离开了，去了一个台资的手机芯片公司，想做些 Android 平台方面的事，也学习一下大公司里面是如何进行管理的。

没做几个月，刚刚开始有点进展，以前公司的同事拉我加入他们公司，一个移动游戏公司，刚刚出了一个成功的产品，投资刚刚进来，形势不错。

当时想了一下，还是加入了，原因一个是台资公司确实累，技术之外的因素也有点多，再一个对公司的运转有了一定的了解，要取得进一步的信息恐怕至少要个三年五载的，主要是这家公司能给我一些机会尝试自己想做的事，可以试试自己的想法是否有效。

当然事情进展的不够顺利，不然也不会再加入以后短短八个月就又一次离职，也不会有工作室的成立了，具体原因就不多写了。

为什么要做休闲游戏？

离职后面临选择，再找一个公司，希望碰到合适的人、合适的环境。或是 SOHO，自由职业，成立工作室并不是当时的第一反应。

先是想着在家歇歇，慢慢找找有没有合适的工作。对我来说，找一个开发，或是技术管理的工作应该说非常容易，我也有足够的信心能胜任大部分的开发工作，做一个好的程序员。

之前的经历告诉我在不能对公司有决定权的情况下，只从管理的角度想要把产品做好，是很难的一件事。而在没有实质的经验的情况下，想要直接得到产品经理的职位，也是近乎不可能的事了。

于是想做自由职业了，毕竟我会写代码，写的还相当不错，之前用业余时间做的小软件(Movable Write) 也上线一年多了，赚一点小钱，自已也喜欢这样的方式。

就是做软件一个人很累，或者用户群相对较小，或者竞争相当激烈。好的产品需要长时间的改善，打磨，对于我这样一个没什么积蓄的人来说，有点难。

之前在两家公司时，都建议他们加大些休闲游戏开发的力度，不过老板们都没有采纳。我个人还是非常相信这个方向的。

于是基本确定了个人的方向，制作休闲小游戏，不求发财，能收回成本，养家即可，自由的工作方式，和自己控制的工作内容对我来说就足够了。

为什么要做工作室？

后来有朋友主动提出给我投点钱，还是别用纯个人的方式，那样限制太多，一个人的力量太小，移动游戏的前景能提供足够的空间，只要把自己的事做好，风险并不是太大的一件事，他也愿意和我一起承担。

和一些前同事、朋友聊过，也看了不少有关创新的书，如果能处理好的话，一个十人以下的小团队的能量是很大的。我以前也有过身处一个好团队中，集体大于个人，大家互相照应，相互鼓励的经历。

于是认真的计算了一下成本，最后还是决定了做一个自己的工作室。

然后开始拉团队，并不是很容易的一件事，有风险（在赚钱之前，大家都要减少收入的），我并没有带产品的成功经验，游戏策划也并非我的专长。

团队

目前的人员是两个程序，两个美术，经验都算是比较丰富的，平均年龄也过三十岁了，其实并不是一个典型的创业团队。

我们的优势在于团队中的成员都是做事非常认真的，即便是在自己不喜欢、不认可的情况下，也会出于职业道德尽力完成工作。可能给人感觉创业的激情不够，不过我觉得如果能把这样的人的积极性调动起来，让我们做自己喜欢、认可的工作，我们的能量会是非常大的。

我会学着做一个合格的游戏策划，不过我们的产品一定要是大家的成果，如果把产品做成我自己“一个人的产品”，对我来说将是个巨大的失败。我们都证实是好的员工，但一起创业，其实都是不满足于简单的作为一个执行者，仅仅去实现其他人的想法。

最让我感动的是，所有的团队成员在谈到风险时，担心的都不是自己会少挣多少钱，而是自己的能力够不够，会不会误了大家的事。这种无形的压力会带来前进的动力，让我更有信心面对前面的困难。

坚持原创休闲游戏

大家都同意我对工作室的定位，和想做的产品方向。

手机对游戏行业的冲击其实不仅仅是在于载体上，更重要的是在游戏方式上，休闲游戏的目标并不是和沉浸式的游戏体验相竞争，而是提供碎片化，相对浅层的游戏体验。而休闲游戏的主流玩家其实恰恰是传统意义上的非玩家，视觉效果上的吸引力对于游戏的成功与否是至关重要的。

关于山寨，不否认Copy是更容易的方式，但我想这种方式也容易让人落入很多容易忽视的陷阱，例如失去对目标人群的定位、压制正常合理的争论，导致产品没有灵魂。而且Copy模式隐含的目标就是盈利为第一目标，很容易一步一步把一个有意思的事变成一个没意思的事，人们总习惯说先挣钱，有钱了以后再怎样怎样，然而恰恰是能不能在没钱时坚持做自己喜欢的事才能证明是真正的喜欢。

游戏的内容应该是比较健康的，那种利用人性中比较阴暗的部分的我个人很不喜欢，而且所谓面向高端用户（利用玩家的重度沉迷从玩家身上尽可能的榨取利益）的做法也是我不能接受的。从每个用户身上能拿到1～2美元我认为对于休闲小游戏就已经足够好了，用户基数已经足够大了，就看我们能不能把自己的产品做好。

我们会用相对较长的时间一起讨论游戏的概念、细节、美术风格、技术难点，争取在项目正式开始时大家达到共识，也对开发的难度有所了解。半年内，第一款产品应能上线，根据带来的收入情况再确定下一步的具体计划。

PlantUML is a component that allows to quickly write:

• sequence diagram,
• use case diagram,
• class diagram,
• activity diagram,
• component diagram,
• state diagram
• object diagram

I really like the idea of writing UML diagram with plain text. Since it’s totally plaintext, it’s very easy to do diff and version track, also you don’t need to do anything about the layout (the text itself looks pretty good too).

Also the syntax of it is very well designed, and the generated diagrams looks really nice, so I use PlantUML for technical documentation with trac and sphinx.

The Plugin

After switching Octopress to my blog platform, I was looking for a way to integrate PlantUML within it, though I can’t find one, so I wrote this very simple jekyll plugin (Octopress is based on Jekyll).

jekyll-plantuml

Configuration

You need to download the plantuml.jar file from http://plantuml.sourceforge.net/download.html

In your _config.xml, setup plantuml_jar to the downloaded jar file, e.g.

1
2

plantuml_jar: ../_lib/plantuml.jar
plantuml_background_color: "#f8f8f8"

The plantuml_background_color is optional, which will change the background of the generated diagram.

Usage

Just wrap the diagram text in “plantuml” block, e.g.

1
2
3
4
5
6
7
8
9

{% plantuml %}
Alice -> Bob: Authentication Request
Bob --> Alice: Authentication Response

Alice -> Bob: Another authentication Request
Alice <-- Bob: another authentication Response
{% endplantuml %}

An Example

Back in 2010, I already had some experiences on iOS development. Did wrote some very simple application to fetch information over HTTP-RPC to a trac instance, and wrote a very simple game with Cocos2D and Box2D. Did spend some time to catch up with the versions or iOS updates and read about the new APIs.

But my feeling was that by only spend small amount of time like it, I can never learn enough to have real experience on it, and I’ve been working on Web development for a few years. So I decided to work part-time in the company, and use the other half time to develop a real application, by real I mean with proper quality and released at app-store.

I just got a iPad1 as development device, and tried a few apps, I liked note plus a lot, it’s very powerful, but a bit too powerful for my need, I want to write words most of the time, and I want to write largely, but view the written lines small.

So I decided to write a note taking app for myself, after 3 months, Movable Write was released at app store.

• App store link
• A nice introduction from wolfewithane.com
• Another nice introduction from iapp.com.tw (in Chinese)

What is missed

I did implement support for USB transfer for backup/restore, though didn’t write document about this feature, the plan was to implement synchronization for it, Dropbox and/or iCloud, though didn’t get time for it.

Another interesting possibility is Evernote integration, the code should be very easy to be runnable on OSX, also can be added as image or pdf.

A bigger change is adding bigger element into page, e.g. a photo then wrap the lines around it. I’ve done some experiments about bigger writing area, it’s not easy to put it into the current structure though.

Another bigger one is OCR for the written words, there are open-source libraries, though not sure how mature they are, all the original writing information are saved in file, it might be easy to add this feature.

A small one is to replay the writing process of the note, since all the timing infomation was saved too, this is not hard to implement.

…

Why open sourced

It’s sadly that I can’t put more dedicated time into it, since it didn’t bring much money as a product for a small group of people, though I get quite some very good comments from some users.

I feel very happy that some people found it useful and use it frequently, so in case any of them are programmer, I decided to put all the source codes at github, please fork it if you’re interesting.

• Movable Write at Github

Might write more about the technical side of the project later, what I’ve learned, and how to extend it.