Tag Archives: progress

Briefly Looking Back Before Charging Forward

I had originally meant to post this on my birthday a few days ago but a blizzard over the weekend with record cold temperatures followed by rolling blackouts necessitated by a sharp increase in demand on our electrical system and then ultimately a province-wide blackout for a few days kinda put a damper on any computer-related activities such as blogging.

That said, instead of New Years Eve, my birthday occasionally becomes a focal point of my life where I reflect on how things are going and look to the future. I think most importantly my impending 30th birthday, four years ago, became the catalyst that drove me down the path to creating Celsius Game Studios and attempting to follow my dream of creating my own video game company. While the road has been bumpy at times the journey overall has been great so far and despite occasional slowdowns and setbacks it feels like 2014 is poised to be an amazing year.

Continue reading

A Post With Numbers In

Update (April 6, 2011): Hit 4,000 sales last month, and well on the way to 5k! πŸ™‚

I haven’t made a real substantial blog post in a while but with my trip to GDC rapidly approaching and Red Nova being featured by Apple in “What We’re Playing” as well as a fairly significant milestone in sales of the game I figured it may be interesting to some to post some numbers, and talk a little about where Celsius Game Studios Inc. (oh yeah, I also got incorporated!) is headed in the near future.

First of all, the bit you’re probably here for: The Numbersβ„’. Many developers are hesitant to discuss specific sales figures, either for fear of being seen as unsuccessful or because their sales are directly tied to their income, which I suppose is why these sorts of things are still generally interesting. I feel that Red Nova has been relatively successful so far and because sales of the game do not directly tie into my own income I think I can safely say that the sales of Red Nova are… *dramatic pause*… larger than a breadbox and smaller than an exotic super-car.

Okay, in all seriousness, and this is pretty exciting for me: as of this weekend Red Nova handily sailed past 3,000 sales. All over a period of just over 2 months.

While some of you may be looking at that and saying “big deal, Angry Birds sells that many copies in, like, thirty seconds” understand that the average iPhone app will see approximately 100-200 downloads over its entire lifetime. Sales-wise, Red Nova is already in the top 7% of games on the App Store! While I’m not popping any champagne corks just yet, considering that with no money spent on advertising, relatively poor circumstances surrounding the launch over the holidays and the fact that up until recently I was pretty much unknown as a game developer, I think I’m doing quite well for myself.

As I mentioned in an earlier blog post, Red Nova still hasn’t hit its stride, and I don’t expect it to right away. Ultimately my plan all along was to release the game in episodic “chunks” to help make it easier to develop the game and grow its audience at the same time, especially seeing as, at least in the short term, I’m still limited in the time I can spend working on it. Also early sales help support the development of future episodes not unlike how Minecraft‘s sales model works, where the people buying the game now are getting an already good game for a low(-low!) price as well as a bunch of new content for free. So, I’d just like to take a moment to thank everyone that has already gotten the game so far for helping me realize my dream of becoming a game developer!

That being said over the next few months I’m planning on expanding Celsius beyond just myself, continuing development on new episodes and feature updates for Red Nova and, closer to the end of the year, beginning work on an exciting new game project I (cryptically!) hinted at a few weeks ago on Twitter which I think will be pretty damn awesome, and when I’m ready to talk about it in more detail I hope you’ll agree with me πŸ˜‰

So, here’s to the future… it may still be up-hill, but it’s looking bright!

Genesis

The Genesis Centre is in the Inco Innovation Building

The Genesis Centre

I just wanted to make a quick post saying that I am very pleased (and excited!) to announce that Celsius Game Studios is the latest client of The Genesis Centre. The centre is a technology start-up incubator run by Memorial University and seems to be a pretty awesome place to get my bearings as I try to develop and grow CGS as a company.

Also Chromodyne HD had a nice positive review from Simple Reviews last month, which is pretty cool! Thanks Parth!

In the meantime, my next mini-project is coming along nicely. I don’t want to say too much at this point as it’s very prototype-y but let’s just say it will involve shooting hot plasma death at evil aliens and blowing them the hell up. Oh yes.

I may have some screenshots by the weekend depending on how quickly I can finish these last few art assets to make it sexy and awesome.

The Game Is Afoot!

Just wanted to drop you all a note saying that I am forging ahead with my plans to turn Celsius Game Studios into something more than a hobby in my spare time. I really do love creating video games and I’ve been thinking about making my own company to do this for over 12 years now, it’s unfortunate it took me this long to stop being afraid about “what if it doesn’t work” and just realize it’s more important to get out there and kick some ass and do awesome things. I’ll be spending the next few months easing out of my current job before I can fully spin up the turbines at Celsius. However I have started pre-planning my next title, which you will find out about soon enough πŸ˜‰

I still have a lot of hard work ahead of me, business plans, and funding and all that crazy scary stuff, but rest assured this is the real deal. I just wanted to let everyone know that awesome things are in the pipes, but that I have a lot on my plate right now so I hope you’re understanding while I work on them all at the same time.

To that effect I wanted to say that I’m still working on the 1.1.0 update for Chromodyne, and it will be out Real Soon Now.

Things that will definitely be in the update:

  • Improved game timing, reducing the time between a match being made and the play field being active again
  • 3D lighting has been improved
  • Cutscenes are now skippable
  • Improved load times slightly and added spinner when loading

Things that I’m currently working on for the update, which will hopefully make it in:

  • Alternate control style, currently testing a few final candidates
  • Online leaderboards, working on securely transmitting scores

Until next time!

Spinning Wheels

Much progress was to be had over the weekend, also much frustration… but my game code pretty much works on my iPod now! I’m so excited πŸ˜€

First of all, I’ve decided to create a new law. Let’s call this law Colin’s First Law of New Platform Development. It is thus: “When developing on a new platform and your code fails in a spectacular fashion, don’t assume it is the platform’s fault for being new and strange. It is in fact because you’re an idiot and didn’t initialize a variable properly.” I’ll just go ahead and leave this here.

In other news, I will now tell you how to make a fairly decent method to shuttle input from the main thread to your game thread when working on the iPhone OS. It took me a while to hunt it down, so I’m sure if this ever shows up in Teh Googles someone might find it useful.

First of all, I created a class which is basically a FIFO of “event” objects. It’s pretty basic, but it will do the trick.

Initially, I figured all I needed was a boolean variable in the FIFO to let the system know if the FIFO was busy. Boy howdy was I wrong. You see, I discovered that the variable itself was being accessed simultaneously by the view controller and the game code causing it to crash horribly. So I’m like… clearly people do this sort of thing all the time, I just need to keep searching until I find a mechanism that allows this sort of thing. After some searching I learned about atomic operations, or operations that are guaranteed to happen within one processor cycle. This guarantees that only one thread will be operating on the variable at one time, thus preventing Michael Bay levels of explosive action in your code.

So, where do we find these atomic operations? Thankfully Apple has thoughtfully included some in the OS. I’m sure there are more elsewhere, but for my code I decided to use the functions in the scarily located <libkern/OSAtomic.h>. Really though, it’s not so scary! What we’re going to do is use a spinlock to resolve resource contention (the resource being our FIFO). Basically we give our game code and the view controller a pointer to an OSSpinLock variable and they both use OSSpinLockLock(OSSpinLock *); to fight it out for who gets first crack at the buffer. The reason I chose OSAtomic functions is because they are relatively lightweight, and this sort of resource sharing is fairly simple.

Anyway! To get this to work, you need to declare an OSSpinLock variable (it’s basically an integer) somewhere and pass a pointer to it to your view controller and your game code. Also you have to do the same with your event queue object. Because your view controller will probably be trying to send touch events before your game code has fully initialized, it is best to have the view controller call the functions to init the spinlock and the event queue.

A word of warning, most of my game code is in C++, as I’m really not very comfortable with Obj-C atm, but C++ code will happily co-exist with your Obj-C code. The only major caveat is if you’re calling C++ inside your Obj-C objects, the implementation files have to be .mm, not just .m so they are compiled as Objective-C++. Otherwise the compiler will just sit there and stare at you funny. This spinlock method should work with straight Obj-C too though!

Okay so I’ve created a few simple functions (in C!) to initialize and pass around the spinlock and the event queue. They live in eventsync.cpp:

#include "eventsync.h" //This includes OSAtomic.h and the header for the event queue
 
static OSSpinLock *lock; //static so it never goes away
static CGEventQueue *uiEventQueue; //same here
 
CGEventQueue *getEventQueue()
{
  return uiEventQueue;
}
CGEventQueue *getEventQueueAndInit()
{
   uiEventQueue = new CGEventQueue;
   return uiEventQueue;
}
OSSpinLock *getSpinLockAndInit()
{
   lock = OS_SPINLOCK_INIT;
   return &lock;
}
OSSpinLock *getSpinLock()
{
   return &lock;
}

Now that that’s sorted out it’s pretty easy to get started. In your view’s interface add a pointer for an OSSpinLock and your queue object. Then in the view’s init code (in my case initWithCoder), call getSpinLockAndInit() and getEventQueueAndInit() to set up your view’s pointers (in this case, lock and eventQueue). In your game code you’ll want to call getSpinLock() and getEventQueue().

WARNING: Stargate references abound. Now that you’ve spanned your two threads with the code equivalent of a wormhole, just like in Stargate, they can only work in one direction. So your spinlock is going to act like a DHD and will activate the wormhole and send SG-1 in the right direction, hopefully avoiding killing some hapless team member in the process.

Basically what we will do is use OSSpinLockLock() to try and set the spinlock variable. If the spinlock is already locked, it is in use somewhere else, so OSSpinLockLock() will loop until it is no longer locked. It is our responsibility to unlock the spinlock in each thread when we’re done with it or everything will stop working.

So before this post gets even longer, here’s the upshot. When we overload touchesBegan, touchesMoved, and touchesEnded (or other input methods) we’re going to do something like this:

-(void) touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event
{
   UITouch *touch = [[event allTouches] anyObject];
   CGPoint touchLocation = [touch locationInView:touch.view];
 
   OSSpinLockLock(lock);
   //when the lock is free we can safely push events into the queue
   TouchEvent *ev = new TouchEvent;
   ev->type = CGE_TOUCHDOWN;
   ev->x = touchLocation.x;
   ev->y = touchLocation.y;
   eventQueue->pushEvent(ev);
   OSSpinLockUnlock(lock);//important to release the lock!
}

In our game code we’d have something like:

OSSpinLockLock(lock);
TouchEvent *ev;
while(eventQueue->getNumEvents())
{
   switch(eventQueue->topEvent()->type)
   {
      case CGE_TOUCHDOWN:
         ev = static_cast<TouchEvent *>(eventQueue->topEvent());
         //do stuff with the event
         break;
      }
      //Handle other events here
      eventQueue->delTopEvent();
   }
}
OSSpinLockUnlock(lock);

It’s as simple as that!

Til next time πŸ™‚