Support & Learning
Application Development and Deployment
Data Connectivity and Integration
Web Content Management
Get A Free Trial
close mobile menu
Testing & ALM
Adventures as an iOS Indie Game Developer
Adventures as an iOS Indie Game Developer
February 22, 2014
Testing & ALM
It was late 2008. The iPhone had been out for well over a year, and the iPhone SDK had been out for a mere nine months. Apps like iFart were making thousands of dollars a day, and smalltime developers dreamed of striking it rich with simple ideas.
I was one of those smalltime developers. A hardcore Windows and C# enthusiast at the time, I had recently lost my job as a contract WinForms application developer. A few friends and I had noticed the recent trend in app developers striking it rich with simple ideas, aging source code to long forgotten PC games reinvigorated, etc. We decided we could have our day as well, and we ventured forth to create our first app.
Now the iPhone definitely was not the first smart phone. Around the time the iPhone was released, smart phones had actually been available from other companies such as Microsoft for several years. Around 2003, my brother and some of his friends had created a game called Blade of Betrayal for a device known as the Pocket PC.
Blade of Betrayal was a platform game based on a game engine written by my friend Eric. It did moderately well for a game in a niche market at the time, and it was even reviewed on a few popular Pocket PC gaming sites. Several years had passed however, the team had moved on, and the source code was thought lost.
Well, it was during 2008 when Eric discovered the long lost source code to Blade of Betrayal on an old discarded hard drive. Although my brother had originally befriended him, by this time, Eric and I had become good friends as well. It was around this time as well, that I ran into another friend of mine while out one night in Houston. Billy, the original artist of Blade of Betrayal, and a lifelong friend of mine.
While chatting with Billy, we started reminiscing about game development, and how we wished we had had the chance to make a game together. Well, shortly after this encounter, Billy, Eric, and I met up, and a new team was formed. Billy would work to update the graphics, and Eric and I would work together to port the source code from Pocket PC, to iOS.
Now I know a lot of developers reading this probably come from the Visual Studio, and C# world. I know this, because I did too. If I had one piece of advice though, it would be to
embrace the platform you are working with
. When people use a Windows Phone, they expect apps to feel like they were written for a Windows Phone. When people use an Android phone, they expect apps to feel like they were written for an Android phone. When people use an iPhone, they expect apps to feel like they were written for an iPhone.
People buy phones targeted by specific operating systems, not because they like making phone calls on them, but because
they like the environment and UI enforced by the operating system
. It's an experience these users prefer on a personal level, and as developers, it's our job to consistently provide that experience to them.
I have to admit though, games are a different kind of beast. Blade of Betrayal was originally written in a semi-portable language, C++. Fortunately, this meant that most of the game "just worked". Unfortunately though, this meant the portion that didn't work needed to be updated to utilize the proper operating system specific abstractions. This meant it was time to learn Objective-C. It also meant it was time to betray years of loyalty to the one platform I had always trusted. It was time. Time to buy a Mac. Uhgg.
Stepping into that Apple Store back in 2008 was a surreal experience for me. Here I was, buying a computer that bore such a stigma in my mind that I swore I would never touch one. Little did I know that this machine would eventually set the long term path for my career as a Software Developer.
Once I had the Macbook in my hands, the next step was to figure out how to develop on it. A few quick searches on Google revealed that the Integrated Development Environment (IDE) was known as Xcode, and it was provided for free on the OS X CD that came with the machine. After installing Xcode and trying out a few of the default project templates, I quickly realized I had no idea what I was doing. In order to remedy this, it was time to start reading.
Two of the most important books I've ever read are about the Objective-C language, and the Cocoa Touch UI Framework. If you want to be taken seriously as a native iOS developer, I highly recommend checking out these books for yourself. Here are some links to the latest editions.
Learn Objective-C on the Mac: For OS X and iOS
Beginning iOS 7 Development
Once I achieved a general idea of what I was doing in Xcode, it wasn't long after that I had the source code for Blade of Betrayal in an Xcode project. The initial results were underwhelming. It involved a lot of crashes, commenting out huge blocks of code, re-compiling, more crashes, then
even more crashes
. I was pretty excited when it finally didn't crash, and I could see some remnant of graphics being displayed on the iPhone simulator.
Once we had the game actually working, it had no sound, no save game system, and several other systems had been completely commented out in the codebase just to get it to run. A lot of the old code relied on APIs specific to Windows Mobile, and would just not work on iOS. It all needed to be rewritten. The portion of the game that did work though, was the graphics. We had used Objective-C and Apple's OpenGL APIs to start up the games rendering systems.
Over the next three months, Eric and I spent all of our free time figuring out how to get all of the broken systems working again. At the same time, we both worked with Billy to modernize the game's graphics and UI for the iPhone. This involved switching it's orientation from portrait to landscape, and adding support for gesture based UIs.
[ Picture - Level Selection UI ]
One of the most difficult things we had to design for was the lack of hardware buttons on the iPhone. All input had to be done through the touch screen. We ended up building an on-screen D-Pad with buttons for actions. This was very similar to what most other developers were doing at the time.
[ Picture - In Game w/Controls ]
As our development time went on, tons of games were being released to the app store on a daily basis. We really started feeling the pressure and started pushing ourselves to get the game out as soon as possible. Doing so meant working every night, sleepless weekends, and QAing the same levels over and over and over again.
Eventually, three months had passed. The game was ready.
The day we pushed the final binary to the App Store, excitement was high. After all, we were going to be rich very soon! Once the game finally made it on to the App Store, we eyed it like a hawk for customer reviews, download counts, etc.
[ Success and money isn't for everyone ]
[ In comes Telerik ]
[ Striking it big vs. striking it rich]
[ Moral of the story, you don't have to strike it rich to strike it big. Venturing out and attempting to achieve success, helped me achieve the greatest job I've ever had. ]
Comments are disabled in preview mode.
comments powered by Disqus.
Testing & ALM
Latest updates in your inbox