Coin3D: Cross-platform API

Thinking of doing a cross-platform 3D game? Need a good API? Then maybe Coin3D is for you. Coin is a high-level 3D graphics library with a C++ Application Programming Interface. Coin uses scenegraph data structures to render real-time graphics suitable for mostly all kinds of scientific and engineering visualization applications. Coin3D is portable over a wide range of platforms: UNIX, Linux, Windows, and importantly for us, Mac OS X.

Related Link: Coin3D Mac Page

coin3d,cross,platform,api

New Royalty Free Sound Effects Library Announced

Castles Music Productions will unveil their online sound effects shop within the next month. The new shop will allow game developers to purchase affordable royalty-free sound effect sets covering areas like: interface/menu, pickup, powerup, weapons and more. The library will be continually updated to provide the common staple sound varieties required by game developers. There are also plans to expand the library to include royalty free music. Castles Music offers a total audio development service to the professional game development community. For more information contact Simon Castles.

Related Link: Castles Music Productions

new,royalty,free,sound,effects,library,announced

The Ruby Way’ by Hal Fulton

‘The Ruby Way’ is a book about solving practical problems using the Ruby Language. Ruby is a dynamic, interpreted, object-oriented programming language in a similar vein to Python, and has been installed by default on Mac OS X since 10.2.

As Fulton states up-front, this is not a book for Ruby beginners; the Ruby website has many resources dedicated to learning the language, which the book doesn’t attempt to duplicate. It does, however, contain a rapid review of the language (including some of the more obscure features) to bring intermediate Ruby programmers up to speed.

From there Fulton goes on to demonstrate how to solve certain kinds of problems using Ruby, always with clear and well-written code examples, though they’re often contrived. The content in these sections is in roughly three categories: a few algorithms that will be useful to programmers of all languages (such as an algorithm to calculate the date of Easter), examples showing how to implement basic data structures and algorithms in Ruby (such as queues and trees), and examples showing off Ruby-specific techniques and APIs. The book also shows how to interact with many third-party systems, such as the MySQL database and the Gtk+ GUI toolkit.

From the Macintosh perspective, there’s nothing here specifically for us. Neither is there much that’s not applicable, though. A short section about the Windows API bindings is about the only thing that couldn’t be of use. There is also nothing in particular to help game-programmers, but again, many of the general techniques and algorithms are applicable.

That said, this is an excellent book about Ruby. To anyone who’s dabbled in the language, I’d highly recommend it as a way to improve your productivity and enjoyment dramatically.

Related Books:

the,ruby,way,fulton

‘Game Creation and Careers’ by Marc Saltzman

Okay, which of you kids prefer discussing game designers, programmers, and artists over movie stars and super models? Raise your hands. Very well, this book is for us. ‘Game Creation and Careers’ is a collection of short and heavily edited interviews with the women and men who shape the games we play. In a feat worthy of military decoration, Marc Saltzman spoke with 162 developers on 24 topics and not only gained behind-the-scenes insights, but has also gotten hold of rare production material to throw into the mix (including concept art for ‘Myst III—Exile’, the script for the opener movie of ‘American McGee’s Alice’, hand-drawn level sketches for DOOM, and a photo of Cliff ‘Cliffy B’ Bleszinski in a bunny suit!). Finally providing Chris Taylor’s legendary design document template as a chapter of its own, Marc certainly has the material to back this book.

It must have been a diabolical task to edit that massive amount of material, but it’s well done. Perfect it is not, but even the flaws have their use. My main grievance with the editing job is its redundancy. There are some truths that are shared amongst almost all game developers, so many of the developers in the book repeat one another and the reader sometimes has to get through a few pages to find something genuinely new. I don’t know about others, but I for one already know that gameplay is more important than technology, and I don’t need five developers pointing it out for me. On the other hand, it provides a bit of closure to each section—each chapter is complete in itself.

Another effect of having so many developers discussing the same topic is the interesting and inevitable contradiction that emerges. An authority’s statement about a particular facet of game design will usually stand on its own. However, when another authority completely mows that view and provides a new one, fresh ideas result.

I recently reviewed ‘Chris Crawford on Game Design’, an excellent book that provides enormous amounts of abstract wisdom on the philosophy and very soul of gaming, and which is the exact opposite of ‘Game Creation’. While Chris offers one man’s view on gaming in a somewhat intangible way, Marc provides specific hands-on tips on game production as told by almost everyone in the industry. This kind of direct, almost physical advice is very refreshing. It includes everything from step-by-step instructions on how to light a deathmatch map as opposed to a single-player map, to Sid Meier’s explanation as to why he tests his code every 20 minutes, to why Greg Thomas had problems using a cylinder for player collision detection in NFL2K, to Chance Thomas telling you to learn ProTools. A particular gem for any game developer hoping to ever run a game company is Tammy Schachter of Konami sharing her Top 10 list for managing Public Relations. Also, towards the end of the book there is a section on game design schools, as well as key internet sites and, most importantly, key conventions, organizations, and awards—a very important topic, despite its apparent dullness. In fact, that section deserves a place in the middle of the book instead of being tucked away with the appendices (although why isn’t iDevGames represented as a key organization, eh?). Get this book and learn how to get a job making games (or be scared away). The chapter “How To Make It Happen” will not disappoint you.

The cover displays an impressive list of contributors to the book. While that list is long, only the most famous of the developers made the front cover—the list continues in three columns down the inside of it. There is virtually no possibility that you could read that list without recognizing at least a few names, but if you do, then you badly need this book. The “personal” aspect makes it an interesting read for gamers themselves. While some technical mumbo-jumbo might pass over their heads, it is really cool to see what Tim Willits is thinking about when designing the levels you play.

The last part of the book contains a biography section, which is essentially a very nice “Who’s who” of the game industry. If you stumble upon an unfamiliar developer name in the main body of the text, chances are that you’ll find information on her in this section. The index at the back is also helpful, as it allows you to look up certain developers, games, and terms.

The word “Careers” in the title suggests that this book is a description of different career choices in the game industry, and while that is partially true, it’s much more than that. For a novice game developer, the true benefit here isn’t the tips, but the insights the book offers into the industry—having Bill Roper of Blizzard Entertainment tell you how to break into the business could be invaluable. For those who already have a foot in the door, the tips, tricks, and advice are more than useful, and for the elders of the game industry this book provides clean industry espionage.

Marc is very thorough, and where other books of this kind deal with programming, art, and possibly game design, his is distinct in that it also covers marketing, testing, technical support and more. Those particular sections separate this book from others, and contribute to its overall quality. Marc also shows journalistic professionalism, refraining from interfering with the material. He acts merely as a reporter and medium, never passing judgement, the perfect bystander. He never talks about game creation himself, but leaves it to those who know their gig. Often, in his closing words on a snippet of text from a certain developer, he also refers to other texts in the book by that same person, which is a nice touch that allows the reader to follow a developer rather than a topic. Once in a while, his enthusiastic comments and filler talk do get rather intrusive, in which case you can safely skip everything written in the Times font.

Apart from the content already discussed, the book is also filled with fun anecdotes told by the contributors, which lend a great lightheartedness throughout; you can open the book on any page find something that interests or amuses you.

Marc Saltzman seems to be a little vague about his target audience. At times the book is very technical—John Slagel’s discourse on the GeoMod technology used in Red Faction is definitely aimed at experienced programmers, but why is he then explaining the difference between scripted and pre-rendered cut-scenes? Most likely Marc is trying to not close anyone out from the book, which is appreciated, but the effect is a little awkward at times.

A small disappointment is that Shigeru Miyamoto only contributed about one page in total (although completely understandable—just scoring an interview with the man is impressive). The same goes for Peter Molyneux, but what both Molyneux and Shigeru lack in quantity they make up for in quality. The book sadly misses out completely on Jeff Minter, though.

In conclusion, ‘Game Creation’ isn’t a vital read, but it is an insightful and interesting one that could prove very helpful.

Related Books:

game,creation,and,careers,saltzman

Python OpenGL Binding with PyOpenGL

PyOpenGL is the cross platform Python binding to OpenGL and related APIs. The binding is created using the SWIG wrapper generator, and is provided under an extremely liberal BSD-style Open-Source license. PyOpenGL is also interoperable with a large number of external GUI libraries for Python including (Tkinter, wxPython, FxPy, PyGame, and Qt).

Related Link: PyopenGL’s Project Page

python,opengl,binding,pyopengl

SimGear an Open-Source Simulation Library

SimGear, a set of open-source libraries designed to be used as building blocks for quickly assembling 3D simulations, games, and visualization applications, is available to download. It is released under the GNU LGPL license. SimGear has been developed in conjunction with FlightGear, a flight simulator available on multiple platforms. The Mac OS X version of FlightGear is currently at 0.9.2, one point-release lower than the newest version, 0.9.3, so the developers are probably looking for more help with both FlightGear and SimGear.

Related Link: SimGear

simgear,open,source,simulation,library

Policing Online Games’ by Peter Wayner

I did not have very high hopes for ‘Policing Online Games’. At first glance, I thought its relevance for me was close to zero. What use do I have for secure transfers for massive multiplayer online games? I only write simple puzzle games and the like, and will probably be senile by the time I release a ‘real’ game. But, as so often before, the book in my hand held much more relevance than I thought at first. While much of the book is intended for an online experience, it is just as relevant for developers who want to prevent cracking of the game on the gamers’ computers. For anyone desiring to implement an online high-score list, the techniques within are very useful. And, I believe, as Apple presses on with its Rendezvous1 technology, more of us will come to develop head-to-head games, online multiplayer games, games depending on a centralized server’s data, and such. If not, the book is a very good entry-point to cryptography for those who aren’t too keen on buying a book that might be out of their mathematical league.

A slim little paperback book, all 120 pages of ‘Policing’ fit neatly into my coat pocket. It is extremely compact, to the point, and devoid of unnecessary filler. Presenting an introduction to computer game cheating and cryptography (including very good explanations of RSA, DAE, SHA and other three-letter acronyms that scare anyone with weak math skills), followed by fourteen encryption techniques and a concluding chapter on building a secure engine architecture, this is an Encryption 101 book that also deals with using the techniques in new, innovative ways.

The way I understand it, the entire online gaming industry has decided that the only workable strategy is “Never trust the client”, which means that nothing that could be subject to cheating is ever performed on the player’s computer. The player’s computer is reduced to a machine that renders the graphics, plays the sounds, and sends the keystrokes to the central server. While this might be the most secure method, it is also very ineffective. It requires tedious machine maintenance of the central server, which must be very powerful, and the players’ gigahertz machines are twiddling their thumbs while the server is doing all the work. By applying Wayner’s encryption methods, the client can once again be trusted, and many of the classical online gaming problems vanish into thin air.

The fourteen techniques are presented in separate chapters, and each is applied to a precise problem. In that respect the book is rather hands-on, though without a trace of source code, and very few equations. Wayner starts out with the lightweight example of using a secure hash algorithm to synchronize clients. This is a good method of making sure that no player cheats by tampering with the data on his/her computer—all the computers involved compare their data to ensure that they are in total agreement on the state of the world. In the next chapters, Wayner passes over methods to, for example, prevent players from changing a guess after it has been committed, guarantee randomness in online casinos, and ensure that secrecy is maintained for information that needs to be shared while also being kept secret.

I had virtually no experience with cryptography, encryption, or even hash algorithms before delving into this book, so I can assure you that it passes the newbie test. Still, the book is advanced enough to satisfy those who know their cryptography. The secrets of this book are not in the algorithms themselves, but in the way they are used.

Each chapter (technique) has a short introduction involving a fictive company and the specific problem it faces, and presents a solution to that problem in the simplest possible way—no deviations whatsoever. Often witty, and using good examples, Wayner guides the reader in an almost step-by-step fashion. As Peter Wayner is the author of twelve books, he is obviously a very experienced writer, and it is evident that the book is well-planned and has a clear goal.

In short, for anyone wanting to go online with their games, I really recommend spending some time with this little gem. It is a small book that packs a lot of punch, and it doubles perfectly as an introduction to encryption techniques.

Gamasutra has published an excerpt from the book:

http://www.gamasutra.com/features/20031010/wayner_01.shtml

Related Books:

1 Editor’s Note: Rendezvous, now renamed Bonjour, is a networking technology that lets you create an instant network of computers and devices without any configuration.

policing,online,games,wayner

World to Conquer

Back in high school, Phil wrote a simple strategy game called “Battle of the Masters” on an old (well, not at the time) TSR-80. This game was almost chess-like in its simplicity. Two armies fought to defeat one another over a battlefield of simple obstacles. The graphics were crude but the idea was there, along with some familiar unit types.

Let’s jump forward a bit now; it’s about 2000 or 2001 at this point. Phil sends Louis an email with a link to a TSR-80 emulator and a bunch of games. These were all old games Phil had made back in high school. Louis was beside himself, and in his glee he noted the beautiful simplicity of “Battle of the Masters.” Talk was talked and “Battler” was born.

That’s right, “Battler,” not “World to Conquer”; we’re not there yet.

Six different unit types were completed for Battler, many of which were redone for WtC. It was basically the same game as its more modern counterpart but played instead on an isometric grid of squares. It was pretty fun, but then attentions wavered and other projects took the spotlight. Battler was never completed—until now.

After the success of their GBAX2003 entry Kunoichi Yami, the Northern Bytes team decided that competitions were a great way to force the completion of a project. And thus was it decided that Northern Bytes would participate in the 2003 uDevGames Contest. But what to do?

With a few ideas bouncing around, including one for a total “Advance Wars” rip-off, it was decision time. After careful consideration, it was decided that Battler would make a great entry. Unsatisfied with the original graphics, Louis sought to give the game a more refined look. A hex system was chosen to replace the problematic squares and from there, a whole new game was born: “Battler 2,” later renamed “World to Conquer.”

The Tools

We chose to build World to Conquer as a Carbonized application using Metrowerks CodeWarrior, partly due to familiarity with that particular integrated development environment, but mainly because our lead programmer was too lazy to purchase a new iBook with specs sufficient to run Mac OS X.

On the plus side, this ensured that we could reach as big a potential audience as possible—the game runs well under Mac OS 9, and doesn’t have particularly demanding CPU or memory requirements. These are big pluses for a contest (like uDevGames) that uses public voting, especially since World to Conquer is primarily a gameplay-driven title anyway.

Our programmer made sure to keep the bulk of World to Conquer’s source code and external tools portable, using a platform abstraction layer that was implemented both for Macintosh and Windows. Being able to test on both platforms made it easier to track down tricky bugs. It also made our project accessible to team members that weren’t fortunate enough to own a Macintosh computer.

We used Apple’s QuickTime for music on both the Macintosh and PC ports. This technology lent itself well to playing compressed AIFF files, which we selected as a good compromise between file size and quality. MP3s sound better, but were much larger. MIDI was briefly considered, but rejected as too limiting for our talented musician.

Our graphics code makes heavy use of translucency for special effects and highlights. That part of our code isn’t particularly efficient (the fades during the splash screen sequence are particularly sluggish), but we were able to eliminate in-game speed hits thanks to a custom graphics manager that divides the screen into a grid of 16×16 chunks, and only bothers to repaint dirty (changed) areas. The screen is represented internally as a hierarchy of graphical elements, allowing us fine control over layering and placement.

We used the well-documented BMP and GIF file formats for our graphics resources, and uncompressed WAV files for sound effects.

Probably the hardest part of this project, from the programming perspective, was creating a reasonable AI for the computer opponent. The gameplay doesn’t lend itself well to a traditional “depth first search” because of the sheer variety of moves and randomized attack effectiveness. We made the problem tractable by breaking down the computer behavior into a smaller class of objective problems: finding shortest paths on hexagonal grids stocked with obstacles, evaluating potential attack options, minimizing “friendly fire,” and even some rudimentary cooperation between computer-controlled units (e.g. for computer-controlled healers).

Fortunately, when we decided to switch to canned scenarios, this took some of the pressure off having a “flawless AI.” You may notice that many of the scenarios by design feature large computer armies vs. a relatively small group of player-controlled units. This gives the computer army an artificial advantage, to help balance out the intelligence of a human player. In some respects, this may actually make the game more fun. If the computer were perfectly intelligent, a human would struggle to even draw. As things stand, there’s fun to be had in using superior intelligence to defeat sheer numbers. A planned two-player option to the game will make things more interesting for folks that want to have a more even-handed battle of wits.

Gameplay philosophy aside, the computer AI has some major flaws we hope to address in the future. Specifically, it does not go out of its way to protect computer “leaders” nor does it more aggressively pursue player “leaders.” The computer AI also does not yet have any knowledge of goal-based scenarios.

Graphics were made primarily in Photoshop, though it’s been rumored that Richard dabbled in the use of Painter in his attempt to find an easier way to draw the base black outlines for sprites. Painter was used to make the title background as well.

The music was done using Finale 2003 for notation, Pro Tools LE for playback, and a Yamaha MOTIF as the primary (and only) sound box. The original sound proposal called for a series of five themes-encompassing both melody and orchestral texture-that would be executed in a wide variety of styles. After the game concept was revised the in-game motivation for the five themes no longer existed, so the team adapted much of the music that had already been composed for the new game concept, and Ben finished the rest of the music to new parameters. Ben was pleased with the final product, though he admits he is still learning all the nuances and tricks of the MOTIF instrument. With a little more time to devote to it, he would have developed the various themes more fully and touched up some sound-balance issues.

Sound effects were mostly made from arrangements of original and free sound clips. The original sounds were recorded on a digital video camera, being the best mic that could be found at the time. The sounds were all pieced together in Sound Effects and Sound Studio.

An indispensable tool to the creation of WtC has been, of course, the level editor developed along with the game. Since we do plan to release it to the public, it has been kept relatively easy to use and has made mission creation a breeze.

The Making of WtC

Much of the game’s design was already in place thanks to it being a sort of pseudo sequel to a previous project. The guiding principal of the game never changed, i.e. a simple strategy game. That was the goal, to reproduce the elegance of Battle of the Masters. Every unit was to perform but one action, every unit would be dramatically different. And everything would be done with the mouse, no menus.

Though the core of the gameplay never changed, the game’s focus took a huge turn when it was realized that time would not permit the creation of the conquering aspect that was originally intended. That’s when the non-combat aspect of the game switched from a freeform Risk style to a challenge-based mission style. This change greatly affected the focus of the game, as the creation of missions became a new and interesting challenge to take on.

Graphic design was done first and foremost on paper. Come to think of it, most of the design was. Louis spent much time bouncing ideas off friends and classmates in order to emerge with a tighter sense of the game and the final graphical look.

A constant exchange of resources and products between Louis and Phil eventually led to the contest complete version of World to Conquer that made it here.

What Went Right

Game design and Gameplay

First and foremost among things that went right was making a complete, playable game; having a deadline to stick to had everything to do with it.

Sticking to a simple battle plan also proved to be a life saver. With the battle engine up and running in no time, it was possible to concentrate on the nit and grit of content.

Switching to the mission based game play was also indispensable to the game’s completion, since the Risk style conquest part would have involved the creation of a whole other game on top of the existing battle engine.

Polish

And finally, the feel: the essential simplicity and concept of the original was conserved brilliantly in the final product.

What Went Wrong

Interface Design

Not enough time was spent designing and implementing an interface, so the game ended up not really having one as far as menus go.

Also, we weren’t able to fit in all the features we wanted, such as save and load and army color edit.

Unfinished Graphical Refinement

Although all the graphical content was completed, the implementation was never fully achieved. This is unnoticeable to the player, but some of the effects were designed to play out in more dramatic ways. Time constraints once again didn’t allow the changes to be made.

Few Unit Types

Three more unit types were originally designed but had to be cut because of lack of time.

In Conclusion

If anything, this has only strengthened our resolve to continue making games and having fun doing it. Barring time constraints, this project went off without a hitch. With no major bugs, no huge unforeseen delays, it was smooth sailing. We had a blast making the game and learned a whole heap.

RTS,SNES,CodeWarrior,Carbon,MIDI,AI,Pro Tools

Argonaut 2149

screenshot1 — Theseus, the beginnings of Argonaut

What Went Right

Good Use of Language Features and Paradigms

Once converted to Objective-C, Argonaut began to benefit a great deal from Objective-C language features and from the use of object oriented design. All in-game objects shared a class hierarchy which allowed them to inherit common abilities such as collision detection and response. Each class of ship automatically inherited common AI(artificial intelligence) abilities like seeking and evasion, while their specific attributes could be modified by subclassing. This significantly reduced the amount of programming required of me. Using Objective-C’s dynamic binding I was able to put together a rudimentary scripting system, also without much additional programming, which was used for Argonaut’s level system.

The User Interface

The user interface code, which formed Argonaut’s stylized in-game interface, followed a design which imitated that of Cocoa’s GUI classes. Since the in-game elements were similar to what you would find in a normal application (buttons, tables, text-fields, etc) this was a good model to follow. The disadvantage was that it was a pretty large undertaking for such a small game, so it consumed a good portion of development time. And though I had programmed my UI classes in such a way that they would be reusable, it turned out that I would never reuse them, because future games I worked on would not be done in Objective-C.

screenshot — The Main Menu

The Art

Once I had a working prototype, Daniel Labriet of Danlabgames took interest in my work. Dan replaced most of the awkward artwork I had made myself with his superior artwork. I didn’t give him any guidelines for the work (Dan works by his own rules!) but nevertheless I was incredibly happy with what he produced. Dan continued to supply artwork for Argonaut until its completion. Argonaut’s 2D graphics were produced in Adobe Photoshop, as were the textures. The 3D models were produced in Cinema 4D, and were exported in the .obj file format for its simplicity and because code for loading this format is readily available.

The Sound and Music

For Argonaut’s sound and music I settled on using the FMOD library, which is free to use for freeware projects and offers variable pricing for other uses. The key thing is that it was free for use in Argonaut and offered the features I wanted, like control over volume, balance, frequency, and the ability to stream music. We settled on the Ogg Vorbis format for the music, because it is comparable to commercial compressed formats (such as mp3), but it has no license fees.

screenshot3 — KillCo, The Weapon Store

After the sound and music system was up, Miyaka Cochrane, who had done the music for my previous (2002) uDevGames entry, became interested in composing the music for Argonaut. Miyaka used Ableton Live for his contribution to the game, and his talent for electronic music really showed through in the product. He was dedicated to getting the music to match the look and feel of the game, and so he needed little direction at all before he handed me music that frankly blew my mind. And even though I almost always thought the music was perfect, he would act as his own critic, go back to work, and come back with something even better!

What Went Wrong

Focusing on the Wrong Aspect of Gameplay

Argonaut’s gameplay earned pretty high marks in the uDevGames Contest, but I actually think it could have been significantly better. The dogfights in Argonaut are the most entertaining part of the game; the crystal mining portion of Argonaut can be laborious and obnoxious. After the level’s enemies have been cleared it is frankly annoying to have to clear all the asteroids—a trivial, but sometimes lengthy task. If I could remake the game there are two different paths I might take. One would be to introduce mining drones that the player could purchase in later levels. The drones, once deployed, would do the boring (pun not intended) mining work for the player. The other path would be to completely change the player’s role, making him a pirate instead of a miner. The destruction of the asteroids would then be optional.

screenshot4 — A dogfight

Working Too Far Outside of Previous Experience

After work on Argonaut wrapped up in Winter 2004, I tried to make a network capable version of the game. I failed because for the most part I didn’t have the skills necessary to write good network code. The network version worked somewhat, but required a ridiculous amount of bandwidth (I’m talking megabytes here). There were lots of topics in network game programming that I just wasn’t versed on at all, and so I wasted a lot of time on network code, and ultimately failed. This is what can happen if you just don’t know what you’re doing! After that disappointment, Argonaut’s source code wasn’t touched for a very long time.

Not Backing up Source Code

I had made an even greater error when attempting to add network play to Argonaut. I had completely ravaged Argonaut’s source code, left it in a non-functioning state, and not backed up the original source. This made it impossible to do small bugfixes and updates to the game. It became very depressing when users would email me requesting small changes, features, or bugfixes, because I could not compile a functional executable. When Mac OS X 10.4 rolled around we found that the textures in the previous release of Argonaut were not being loaded correctly. Luckily, resolving this issue did not require modification to the source code, only to game assets, and so Argonaut remains compatible with Apple’s latest operating system. The moral of this story is to backup source code frequently, and when working on a significant update, to maintain a concurrent version of the source that you can use to produce smaller updates.

Conclusion

In Fall 2005 we released a new version of Argonaut (version 1.1.1) with the texture loading bug fixed. Additionally, Dan modified much of the game’s original artwork to look even better than before. I am very happy with this last release of Argonaut, and it marks the end of the development of a game that I couldn’t be more proud of.

screenshot5 — A Massive Explosion

Overall, developing Argonaut was an incredibly rewarding experience. I was absolutely thrilled when Argonaut won the uDevGames 2003 Contest, and was ecstatic with everything that came with that. The two years that I competed in the uDevGames competition motivated my efforts to become a game programmer, and have given me invaluable experience and connections to other developers. On top of this, there is great satisfaction in a job well done, and in seeing appreciation for your work coming from all over. I miss that satisfaction.

It’s been two and a half years since I first released Argonaut. I’m now a second year student at the University of California, Santa Barbara. In 2008 I plan to graduate with a B.A. in Computer Science, and a B.S. in Mathematical Sciences. Unfortunately, since the beginning of my college ‘career’ I have yet to release a single game. Looking back, I realize the extent to which high school presented me an opportunity to pursue the creation of my game. This was because I had long stretches of free time in which to work, think, and explore that I just don’t have now. My advice to any aspiring game developers out there who find themselves in such advantageous situations is go for it now! You will not have such luck forever!

Genre: Arcade

Developer: Holmes Futrell

Team Size: 3

APIs: Cocoa, OpenGL, FMOD

Release Date: November 5, 2003

Project Length: 4-5 months

Development Hardware: PowerBook G4 667MHz

Critical Applications: Xcode, Photoshop, Ableton Live, Cinema 4D

shooter,shoot-em-up,space,Xcode,Objective-C,Cocoa,FMOD,gameplay

Dig It!

But which one to use? I already had a couple of early stage prototypes for games that could be really great, and Dig It!‘s was only a vague idea at the time. Looking at the uDevGames timeline, I weighed the possible problems and learning curves of each individual project, as well as the time it would take to design the externals like levels and graphics. Dig It! was a perfect match for my skills, resources, and time.

The Gameplay

As discussed in the previous section, the gameplay was made to be as original as possible. Since I have actually played no game like it, I am hopeful that I have succeeded in that venture.

But designing the gameplay itself was another issue, since you have to balance strategy and fun. Many first timers will make a mediocre game, then make it as difficult as possible to play. This false “challenge” is what gets them in trouble, because the balance is not there.

I made all of Dig It’s “tools” with this in mind. Just about all of them can be used as suicide weapons, yet at the same time they had other primary functions such as digging, exploring, cabling, etc. This way one could use a tool for its primary purpose, and then wreck it against the enemy when he was done with it.

The AI had to be fairly sharp too, requiring that it attack the player, and cable to the other side at the same time. In truth, I cannot say that the AI is 100 percent, but I managed to do it with enough time to spare for concentration on other parts of my project. Using A* to find a path to the other side, in the case of the cabling module of the AI, or to find a path to the enemy, in the case of the attack module of the AI, is basically the full extent of the computer’s intelligence.

The Polish

I consider polish the most important part. For a user to buy a program, it must be in perfect working order, behave as expected, be easy to use, and appeal to the eye. With such a wide border to cover, it is certainly the toughest part, and it can easily get out of hand.

With my last project, Microbian, I had lots of issues with polish, mainly because I was so busy working on the guts of it and trying to squeeze a few more frames per second out of it. The small stuff just piled up, and I was left with a lot of small fix-ups to do.

I resolved not to have that problem in the same magnitude this year. I made sure it worked perfectly, and if it didn’t I just tinkered on that part until it worked right. I certainly didn’t weed out all of the problems, but it helped keep the total number of problems in check.

As for eye candy, I just wasn’t able to put as much as I would have liked in there before the contest end. For instance, Dig It! is missing even simple animations, something our team just couldn’t focus on given time constrains. Though I consider it pretty well rounded as is, many key features of Dig It! will have to be implemented after uDevGames 2003.

The Graphics

I leave this section to my right hand man, Charles Hwang, who will give a little detail about himself as well:

I’ve been drawing icons since I was ten years old. All I had was ResEdit and ColorIt!. Fast forward about three years to Pixelpalooza 2001, hosted by the IconFactory. I got slaughtered with my entry called ‘School Supplies’. But I got very kind compliments, so I kept trying. Fast forward another year. I’m learning Java in high school and struggling with it. I decide to drop by iDevGames. The generous people in the forums helped me out with my programming dilemmas and sparked my interest in game development even more. I had a strong interest in game design. With iDevGames, I saw an opportunity for me to learn techniques and even make a game!

My first job opportunity came from a fellow named Jake Leveto. He was designing a “sim-space” kind of game. I asked him if I could join the crew and he took me under his wing. Our team quickly created a foundation for the game and had gone through a few betas. I also contributed some artwork with my newly bought copy of Photoshop Elements. It was easy to learn and I could easily apply my art and icon knowledge to create graphics. While I was busily doing graphics for Jake, I saw a message posted by “Dr. Light” (a.k.a Lee Bond) on how to improve a game he was working on. I joined as a beta tester and played it for about a month. I replied to Lee Bond with my recommendations and some artwork he requested, and I thought that was the end of that. He came back to me a few weeks later to help him on a uDevGames 2003 project he was designing—I eagerly joined.

I had little knowledge about the uDevGames Contest. I was basically clueless about what to do except work my art and help design. Despite reading many Mac gaming websites, I really thought nothing of the uDevGames Contest. I had read the results from the previous year’s contest and I did download a couple of games and read a few postmortems. It was interesting, but I didn’t have any interest because I wasn’t very in-tune with the Mac development community.

So, I basically abused Photoshop Elements, churning out graphics every weekend with the time I had for the next three months. Expos? was a life saver for the last few weeks. It was a pain to have about 20 windows open at once and sorting everything out before installing Panther. To add to that, it was starting to look like my 17” Widescreen iMac’s display was too small! Long nights, short weekends. I was a mess. But I was sure it would pay off later. I mean, this is what I want to do for a living! Lee kept sending me “Dig It!” betas, while I tested and critiqued them. Boy, that was fun, especially when we got to around beta 4 and 5! All of my graphics were implemented, our ideas at work, with Kemal’s music, and a nearly-finished product. We had a game that I actually enjoyed playing! The greatest feeling to me is finishing a product. Whether it be icons, graphics, or games, knowing you completed something is always a good feeling. And I’d like to thank Lee, Jake, the iDevGames staff, and iDevGames’ forum for giving me such great opportunities in game development.

The Sound

Here, I got help from Kemal Yun of MacYunSoft, with whom I’ve had many previous dealings. I knew his work and liked it a lot, so I was pretty bent on having him do my sound work. The result was a catchy beat to play to and some slick sound FX.

At first he didn’t seem too sure about it, and wondered about how good the final result would actually be, since the first beta I sent him was really nothing to brag about. In later versions though, he came around and gave my own temporary music the boot (saying, “And PLEASE remove those MIDI files!”), and made a batch of awesome sound FX. Many thanks go out to Kemal for his great work.

What Went Right

The best thing I did this year was to form a team. Having other guys working on the sound and graphics not only freed me up to concentrate on programming, but it also rendered work of a much higher quality than my own. Many people are concerned about the fact that you have to split up the prizes, but I find making a high-quality game much more rewarding than any prize.

What Went Wrong

Using METAL Basic was my biggest problem. The fact that a new OS would be coming out BEFORE the end of the contest did not turn on any light bulbs in my mind.

There are many Panther users who report of METAL programs crashing after a time, making it hard to tell when it is a real problem, or just METAL’s fault. Also, because many beginners make some crashy programs in METAL, I had to BEG many people to try my game out. For many of them, when the slightest thing went wrong they’d just complain and whine about how terrible METAL was instead of helping me pin down the problem. METAL can be a stable programming language if you know how to dodge the quirks, but its outward image dragged Dig It! down some.

My second biggest problem was my timing. I posted to the forum way too late, and it was easy to tell that it became just another face in the crowd. Therefore, not many people really became familiar with the name.

Conclusion

In the end, I think it went really well, and many problems not handled during the contest will surely be weeded out after. Also, at the time of this writing, Dig It! is being ported to TNT Basic, in order to provide greater stability and speed.

Many thanks to Carlos Camacho and his band of merry men, the iDG staff, for putting on another great contest. The Dig It! team also thanks the community for testing and commenting on Dig It! Finally, I thank God; I personally believe that without Him I can accomplish nothing.

  • Critical Applications: METAL Basic v1.7.2, Reason 2.5, Adobe Photoshop Elements, ResEdit

AI,Photoshop Elements,MIDI,METAL Basic,TNT Basic

iDevGames Forum

iDevApps Forum