If you've been in development long, you've heard the phrase or something similar:
[font=arial][color=rgb(0,0,0)]"The first 90 percent of the code accounts for the first 90 percent of the development time. The remaining 10 percent of the code accounts for the other 90 percent of the development time."[/color][/font]
Sometimes even this seems overly optimistic.
Are we there yet?
After roughly 2 1/2 years of development, we're looking at our initial beta release in the next couple days. The funny thing is that we've been saying this for about 2 years! "90% done".
When Basis first started development, it was called something else, and there were no other 2d skeletal animation programs worth much of anything out there (publicly). That was the motivation for it. So "there" was "the bare minimum of what I can use to make a game", and I was excited to share it with others as well. Then I used it, was happy and excited and all those good things... and tried to use it in a small game. Animations worked great! And then I needed to know when my character punched, or ran into a wall, or ... uh oh... back to work on the tool.
At this point, there were periods of disinterest, as well as periods of heavily committed working. There was a lot to do. While I was at it, it was time to take it seriously, knock out some of these bugs, and fix some of the "systems" that were being implicitly defined by the software logic.
Are we there yet?
So, around a little more than a year ago, I was determined to release Basis. Started telling other people. But something happened...
I let someone else use it. And then another someone else. That was all it took. It was quickly clear there were some fundamental issues that needed changing in the workflow. This was developed by a programmer after all, from a programmer's perspective. Artists often have a different world-view...
All this time it was becoming more and more evident that the current undo/redo/command system was inadequate, and shoehorning new features in was making the whole software less and less stable. Bugs were harder to fix, and fixing them were more likely to create new ones... you know the drill. I'm sure you do. So I was going to rebuild the system after our first release, but fixing our newly discovered workflow issues was going to dig deep into the action system anyway... it was clearly a bad decision to put it off any longer.
So the central nervous system of the program was redesigned, then reconstructed piece by piece for the next 6 months, all while adding some of those new features and workflow enhancements simultaneously.
Are we there yet?
This part was like the monotonous many-hours drive on a very straight highway with nothing interesting to look at... at night time. But it's done now, and the benefits are shining so brightly pretty much every day! Everything is more stable, the code is better organized, things are so much easier to tweak and refactor... the whole software didn't change that much but it some how actually felt tremendously more solid! And the fundamental issues with the first testers were resolved. So again I determined to release in a couple days.
Then I let someone else use it, again. Only this time it was for more than a couple minutes to just goof around. This time they were really set to use it for a purpose. It quickly became clear that those big workflow issues were just the beginning, now we were going to get into the little details... 90% done right?
ARE WE THERE YET?
So, we did it again. This time, however, there were 2 key differences:
1) Starting roughly 3 months ago, my friend used it the entire time it was being developed. I can not explain with words how helpful this was.
2) After about 6 months redoing the action system (yes I had bouts of neglect), there was not much to show for it, besides it actually being functional again. In complete contrast to this, and thanks to those 6 months' work, the last 3 months have been spent implementing feature after feature after feature... it has been very nice! Exciting actually! But it has been much like a second full-time job.
With so many ideas and plans and freedom to develop and feedback, it was hard to come to a decision about when it was "good enough" for others to use, especially after the first 2 or 3 blunders. Finally, it has come again to that point.
Now are we there?
So here we are again... ready to release in a couple days. Is it real? Will there be any unexpected surprises? Are we making the same naive judgment we made so many other times?
In many ways, yes!
I'm sure there will be a myriad of issues we haven't encountered before. Another friend tested it out to make a quick 3 hour game-jam-like game (speed challenge). We had mixed results. On the plus side, he figured out the software for the first time and used it in his game all within the 3 hour time period! On the minus side, he used windows paint, so his background was a color mask instead of an alpha channel. Basis automatically detects this, but the Basis plugin developed for his software did not. Naturally, this had to be fixed for his game to work.
At some point you realize the question isn't "are we there yet?". At some point you realize it is "Where is there?"
So... where is "there"?
This has been a moving target, honestly. Not usually a good thing, but unavoidable sometimes. Especially with iterative development.
Eventually, software called "Spriter" was shown to the world and it showed a lot of promise. Had this happened a year or 2 earlier, I probably would have funded it instead of starting my own. (We donated a bit anyway). They thought they had found their "there", only to soon realize they basically had to start over. It is just now coming to fruition.
Then, a few months ago, software called "Spine" was released. This software is very good, and a lot of developers have made it a part of their workflow. They are getting a great deal of much deserved recognition. In a different universe, we probably would have switched from Spriter to Spine at this point, though they each have different strengths and weaknesses. They found their "there".
Then we have our software. Some things are complete, and have undergone enough iterations that they are easier/better to use (subjectiveI know). Some things are in their infancy. Some features are totally different then our brother softwares have to offer. Some things they are just getting, we had 1-2 years ago! We even have a couple nice innovations (again subjective)... so at what point do we let it out there? Does it even matter at this point? I didn't answer the question about where "there" is yet, did I?
We didn't really know it until we found it.
Often times this is a horrible way to develop. It is harder to meet goals, and it raises the chances of "vapourware" and things such as that. However, because of the iterative nature of this type of development, and the fact we had no real deadline and no publisher or bosses pressing us to finish, we were free to let it run its own course. The "it's done when it's done" methodology.
I wouldn't necessarily recommend doing software development like this to anyone. Not with a clear conscious anyway. And especially not with actual games. You're creating an alternate world with games, and there are never enough details. Even our world is still in development. You have to have a clear goal in mind. Unless you're Blizzard. Or Valve. But even when you're one of them, you may never find your "there". Halflife 3, right?
Iterative software development works very differently, whether it happens intentionally or naively. We are probably one of the lucky ones in this case.
I'm not saying the program is complete. Again, there are many very exciting features we are working on or will be working on soon. It is, however, quite usable, and quite efficient. And hopefully it is as intuitive as we believe it is. The only direction to go from here is up. It's a wonderful and encouraging place to be. But what is different this time?
How do we know it is usable? We've used it! How do we know it is intuitive? Others have used it! How do we know it is efficient? Experience! And carefully crafted workflow and design. And there are many more evolutionary changes in the works to increase all 3 of these main factors - not just a little, but very very much.
I have to wait on my friend to finish fine tuning some example artwork (another where is "there" issue). 1 more day? 2? In the mean time, we're taking the opportunity to implement some reference examples on other systems. We hit SFML, SDL, Allegro, HGE, this Amiga environment called Hollywood....
... and then for fun I downloaded Devkitpro and attempted a Wii implementation. Hmm.. If more than 2 nights of research and work then just forget it. Amazingly, in only a few hours, it worked. What a cool feeling.
(my family's Wii)