It is a hard way to make the game you want without a big budget. There are a lot of steps like technical design document, game design document, programming skills, long time motivation. . . Each one of this tasks doesn’t only make the indies headache

Like we know, every project is based on time, money and quality. These are the next steps to conquer.

Despite everything, the are a lot of different solutions. We take it our way and call it “production drops”. The idea is to split one big project into many little projects ( I thing this is the point where everyone starts to laugh). But the clou of this idea is to finish all sub projects (production drop or PD) as a single project. That means, we put into every PD some key features of our big project. Each of this application is fin and can be thrown on the market.

This is our goal to be highly motivated over long time, because we make little project at a short time. In addition to this, we can test some big project features directly on the market without losing time and alter them for our aim. During this time we have all time we need for the documentation stuff. More over, it is possible to source out PDs on 3th party developers.

This workaround must be based on a very modular project library/source code. And that is the first logical step for the whole production. We are not sure how long it will take to work on this pipeline. But one thing is sure, the only parameter which will rise is time. Other problems like money and quality will be fixed by the production drops.

The first production drop will be released soon.

Bookmark It

I write this post to make the transfer between C++ or Java to ObjC (Objective-C) a little bit easier.

One of the biggest differences between ObjC (Objective-C) and C++ or Java is the philosophy behind functioncalls. While you speak about methodcalls in context of Java or C++, in ObjC its called messages to objects.

With a methodcall under C++ or Java the method is binded before the programm starts. This means that the objects method must exist, otherwhise there would be an compilererror and starting the programm would be impossible. This early binding has the benefit of preventing mistakes due programming of methodcalls. However early binding is very unflexible.

Among ObjC you send messages to objects. This comes from Smalltalk. Messages are send during the runtime, enabling late binding. The object interprets the messages while runtime and decides which function to call. This means that the compiler dont check the existence of the function before runtime. Late binding hold the drawback of making mistakes while programming functioncalls. But the big advantage of flexibility.

This Example looks very simple but wouldnt work on C++ or Java:

implementation ClassOne
…
-(void)doSomeThing
{…}
@end

implementation ClassTwo
…
-(void)doSomeThing
{…}
@end

int main(…)
{
id *object = [[ClassOne alloc]init]; //id stands for any type of object
[object doSomeThing]; //call ClassOne`s method
[object release];
object = [[ClassTwo alloc]init];
[object doSomeThing]; //call ClassTwo`s method
}

Bookmark It