Under the Bridge

Game Design

And something a little different for you today: Whilst digging around Gamasutra for stuff interesting to iPhone developers, we stumbled across this article dissecting a variety of CPRGs. If you’re at all interested in designing a CRPG at some point — and we do feel the iPhone has not been overly well served in that realm to date — this is an interesting read.

[In the latest in his popular Game Design Essentials series, which has previously spanned subjects from Atari games through ‘mysterious games’‘open world games’‘unusual control schemes’ and ‘difficult games’, writer John Harris examines 10 games from the Western computer RPG (CRPG) tradition and 10 from the Japanese console RPG (JRPG) tradition, to figure out what exactly makes them tick — and why you should care.]

Those other articles in the series all look quite interesting as well!

Continue Reading →

Code: Plausible Blocks

So you’re all pumped up about this deft-sounding “Block” (aka Closure) concept that Grand Central Dispatch is going to bring to us in Snow Leopard … but it’s not out yet, and Snow Leopard does not run on the iPhone! So what do you do?

Well, if you’re really excited, you … implement it yourself.

If you caught the sessions on blocks at WWDC, you may be as excited as
I am to make use of them. Unfortunately, they’re only available for
Snow Leopard.

As a result, I decided to back-port block support to iPhoneOS 3.0 and
Mac OS X 10.5…

Dude. That’s hardcore. Here’s the announcement of Plausible Blocks; project page on Google Code; and a tutorial demonstrating its use with NSOperationQueue and UIActionSheet with sample code on github. Enjoy!

UPDATE — More good posts on blocks:

Using Blocks: Understanding the Memory Management Rules

Blocks, Episode 1

Blocks, Episode 2: Life Cycles

UPDATE 2 — Recommendations from the 1.0 release announcement:

Joachim Bengtsson’s Programming with C Blocks

Mike Ash’s Series on Blocks, Part I

Mike Ash’s Series on Blocks, Part II

Landon Fuller’s Using Blocks 1 (as mentioned above)

Landon Fuller’s Using Blocks 2

Google Code Project FAQ

h/t: iPhoneSDK!

Continue Reading →

Library: ParseKit

Now here’s something pretty darn nifty: ParseKit, a super-duper set of goodies for both string tokenization

ParseKit provides general-purpose string tokenization services through thePKTokenizer and PKToken classes. Cocoa developers will be familiar with theNSScanner class provided by the Foundation Framework which provides a similar service. However, the PKTokenizer class is much easier to use for many common tokenization tasks, and offers powerful configuration options if the default tokenization behavior doesn’t match your needs…

and grammar-based language parsing. Neat.

ParseKit allows users to build parsers for custom languages from a declarative, BNF-style grammar without writing any code (well, ok.. a single line of code). Under the hood, grammar support is implemented using the ParseKit Objective-C API, so the grammar syntax closely mirrors the features of the Objective-C API…

Cool, huh? This is an Objective-C implementation of the tools described in Building Parsers With Java apparently, and runs on Leopard and iPhone of course; check out the Google Code project page for code and more documentation!

Continue Reading →

Tutorial: UIPasteboard

Yet another not quite as thorough but still worth a gander 3.0 tutorial over on Mobile Orchard today, Copy & Paste With UIPasteboard:

There are two system pasteboards: a General system-wide pasteboard that’s used for copy-paste operations and a Find pasteboard that holds the last search string.

Additionally, applications can create their own pasteboards that can be used by other apps. For example, a point-of-sales app and a credit card terminal app could use a shared pasteboard to pass payment details back and forth…

Fairly straightforward stuff, especially if you’ve delved into NSPasteboard on the desktop … but since we actually never had any particular reason to do so all that deeply, it was still a worthwhile read!

Continue Reading →

Code: BWToolkit

Here’s a nifty-looking resource for your desktop Cocoa development: BWToolkit! A wide selection of handy-dandy classes for jazzing up and speeding along your interface work — and get this, they come with their own Interface Builder plugin to boot:

BWToolkit is a BSD licensed plugin for Interface Builder 3 that contains commonly used UI elements and other useful objects. Using these objects is as simple as dragging them from the library to your canvas or document window.

When I first heard about the plugin architecture in IB 3, I saw a huge potential for improving the developer user experience and lowering the barrier to entry for developers who are new to Cocoa. I hope to have accomplished that with this plugin…

Yes, the various goodies described in the links would be nifty enough on their own — and the latest version is right up to date with Snow Leopard, no less — but we’re quite looking forward to adding our own collection of custom views and the like to Interface Builder … just as soon as we have some spare time. *laugh* *sob* *whimper*. Well, anyways, in the meantime, grab the source from bitbucket and check it out for yourself!

Continue Reading →

Library: CocoaREST

Here’s a library that may be of interest if you’ve got a use for RESTful services in your iPhone or desktop app: CocoaREST, a generalized superset/replacement for libraries such as MGTwitterEngine:

Recently I created a set of Cocoa classes that let developers interact with internet services such as Twitter, Facebook, Friendfeed, etc. The initial intent was simply to support Twitter, but as the classes became more generalized, the possibilities grew exponentially…

My library is written so you won’t need to look at my headers more than once (if that). This is the developer’s workflow I envisioned when I began writing the API:

  • Create a task of a certain service (ie, SDTwitterTask)
  • Set the task’s type appropriately
  • Navigate to the service’s API page for that task (let’s use mentions as an example)
  • Read that page and note all optional and required parameters
  • Set any properties (ivars) on the task that you would like to have passed to the API
  • Run the task and await results (or an error)

As you can see, it’s almost completely transparent. That’s the goal, no intermediate complexity, just a simple gateway to a website’s API.

Sounds promising, yes? Introduction to be found here; source and instructions to be found at github; and check out the author’s other open source projects as well!

h/t: cocoa-dev!

Continue Reading →

Tutorial: Migrating Data

Here’s another good tutorial at MobileOrchard — my, they are on a run lately, aren’t they? — Lite To Paid iPhone Application Data Migrations With Custom URL Handlers.

Apple enforces a number of restrictions on applications in the App Store. Among the most painful is the lack of feature-limited trials. Applications are either completely free, or the customer must pay up front, sight unseen. The proliferation of “Lite” applications is a direct result of this shortcoming…

When building a game or other stateless application the approach makes complete sense. However, utility applications often maintain information entered by the device owner. Application authors are faced with a dilemma because the iPhone’s security sandbox prevents one application from reading another application’s files. Thus, when customers upgrade from the Lite application they are penalized by having to re-enter all data!

This is rather apropos, as we’ve been already planning something along these lines for migrating data from paid for 2.0 applications to new StoreKit-using 3.o applications, which is more or less the same basic problem as the Lite-to-Pro style migration they have in mind.

The tutorial goes on into exhaustive detail, but the basic idea is to use URL handlers for IPC between your application versions as we’ve mentioned earlier. We do have one additional tip to add though; they focus on using solely the URL itself to transfer data, which there’s a good chance to be problems with using for data in the dozens of megabytes like we need to do. Luckily, we have another earlier post of ours to point you at what looks like a fruitful avenue of inquiry; figure out where UIImagePickerController writes its photographs, which it seems is and is likely to continue to be necessarily a shared access folder, and stick your large temporary data in there. We’ll let you know how that works out once we’ve tried it!

Continue Reading →

Tools: gDEBugger

So, you serious about improving your Open GL code for the desktop or Open GL ES code for the iPhone? Really serious? Like, “$1000? Pffft! A BARGAIN!” serious?

gDEBugger does what no other OpenGL tool can – lets you trace application activity on top of the OpenGL API to see what‘s happening within the graphic system implementation. gDEBugger saves you time by locating “hard-to-find” bugs caused by the incorrect use of the OpenGL API. Debugging OpenGL applications is faster and your applications are more reliable.
gDEBugger provides you with the application behavior information you need for optimizing application performance. No more redundant or “performance killer” OpenGL calls.
Also, you can perform regression tests to understand changes in visual display, performance and accuracy between different versions of your OpenGL application..

Well, have we got the tool for you: gDEBugger!

gDEBugger does what no other OpenGL tool can – lets you trace application activity on top of the OpenGL API to see what‘s happening within the graphic system implementation. gDEBugger saves you time by locating “hard-to-find” bugs caused by the incorrect use of the OpenGL API. Debugging OpenGL applications is faster and your applications are more reliable.

gDEBugger provides you with the application behavior information you need for optimizing application performance. No more redundant or “performance killer” OpenGL calls.

Also, you can perform regression tests to understand changes in visual display, performance and accuracy between different versions of your OpenGL application…

Indeed. We’d seen this tool mentioned before on the mac-0pengl list, so when we saw news of an iPhone beta, we signed right up for it. And indeed, once you get past the flaky Windowsness of the port, it is a most uniquely functional tool. Check out the tutorial and this article on optimization which is part of the extensive online help.So that’s all very well, and it’s apparently popular, but how does it actually run? Well, we ran it over the very early shell of a little iPhone program we’re working on here, and here’s what it looks like at work:


That’s some pretty detailed information, huh? And on the right there is a sample of the kind of thing it finds for you; apparently we’re calling glGetIntegerv somewhere or other, and it politely tells us

Using “Get” or “Is” functions slows down render performance. These commands force the graphic system to execute all queued OpenGL calls before it can answer the “Get” or “Is” query.

Instead, consider caching relevant state variable values inside your application’s code.

Isn’t that helpful? Learn a new thing every day, yes indeed!

So we would suggest that you should all go out and add it to your toolset immediately if you’re doing any OpenGL work, being uniquely suited to that … but $1000-odd with the maintenance package whatever that is, that’s kinda on the steep side if you’re not actually optimization bound at this exact moment, isn’t it? But we shall see what price point they actually release it at soon enough apparently, the release version is scheduled for sometime in July apparently. And July is close!

Continue Reading →

Sales and Rank Tracking

So here’s a more up to date post drawing from this one on the various sales and rank tracking tools out there. The sales tools mentioned


AppSales Mobile


AppStore Clerk


My App Sales


are mainly the same ones we discussed a while back, and nothing there at first glance to change our mind that AppFigures is the killer product for us in that category because it lets us have daily emails for particular products automatically sent to particular email addresses for the partners in development on our different apps, and nobody else does yet.

But moving on to the ranking tools, there’s definitely been massive progress there compared to the Perl script we mentioned a slightly shorter while back! The mentioned products are





and we do indeed agree with the author that Applyzer looks like the niftiest of the bunch, providing nifty graphs like this sample of a not completely randomly picked app (We’re #341 overall in Sweden? Seriously?):


… and you’ll note that apparently they’re able to track ranks below 100. We did not realize you could do that! Anyways, it’s free for now, and lets you track not only your own apps but anyone else’s that might tickle your fancy, so it definitely looks like the clear winner in this space as far as we’re concerned.

h/t: iPhoneKicks!


09.09.11 App Sales Machine — sales/ranking scripts you can run yourself on your Google App Engine account!

09.09.11 Top App Charts — free (ad/commission supported) for now app ranking website!

Prismo is a tracking app with source on github.

Continue Reading →
Page 91 of 119 «...6070808990919293...»