One of my primary goals while building Forgecraft is to learn as many new technologies as possible. I’ve learned the hard way that it’s better to leave this kind of exploration in your hobby projects and out of your production “for real” stuff. And, seeing as how there are so many emergent technologies right now in web development there’s a lot to explore!

Whole Hog is Too Much Hog

MongoDB has quite a bit of steam behind it in the Rails/Ruby community (and plenty of other places too), and with projects like Mongoid and MongoMapper (I went with Mongoid) it’s an easy drop-in replacement for Active Record that maintains all those ORM conventions you know and love. I decided against the replacement approach for one primary reason: I wanted to use existing, robust, and actively developed libraries that rely on Active Record.

Example: There’s no reason to roll your own authentication/user system when there are insanely popular and feature-full libraries already in place for them like Devise and authlogic (I went with Devise).

Fortunately combining Active Record with Mongoid and getting the best of both worlds proved to be easy and painless.

The Set Up

The instructions for Mongoid include a step to remove the Active Record libraries from being loaded and delete your database.yml. Simply skip that step and both systems will run in conjunction.

One small operational change you’ll have to make during development is explicitly defining when your rails generators should use Active Record. If you want to make an AR-driven model, your generators will look like:

rails g active_record:model Player … produces a model the extends from ActiveRecord::Base.

And by default, the data generators will use Mongoid:

rails g model Skill … produces a model that includes Mongoid::Document.

The Implementation

Here’s how this combo system really shines in my opinion: get all the great features of gems built on AR with all the schema less features of Mongo. I’ll walk through an example:

In Forgecraft, the authenticating object is the Player and players have many Skills which, right now, are Accuracy, Craftsmanship, and Perception. But, the skill list will likely grow and change over time as the game evolves. A typical AR/SQL based approach would be to create a skills table and a join table between players and skills resulting in a complex multi-table query to get a player’s complete skills.

It’s clear here that the Player and Skills would fit well together as a single document in Mongo, queried all at once in one tidy object. But, since the Player is also our authentication model, using Mongo would prevent us from using Devise to handle all of that boring and complex auth stuff for us.

Enter Hybridization. Forgecraft’s implementation uses the typical Devise set up around the Player object (again all on top of AR). All of a player’s skills go into a single document with a reference to the player, like so:

class Skill
  include Mongoid::Document
  field :player_id, :type => Integer

  field :accuracy, :type => Integer, :default => 0
  field :craftsmanship, :type => Integer, :default => 0
  field :perception, :type => Integer, :default => 0

  index :player_id, :unique => true

  def player
    Player.find_by_id(player_id)
  end
end

To set up the relationships like one would expect with Active Record is a simple method on your Player object:

class Player < ActiveRecord::Base

  # ...

  def skills
    @skills ||= (Skill.where(:player_id => self.id).first || \
                 Skill.create(:player_id => self.id))
  end

end

Bam! Now we can retrieve our skills as a single document (fast), and add new skills with ease (easy). Since Mongo is schema less, you could even have a different set of skills per player. Again, all of this is achievable through SQL — it’s been done for decades — but it just makes more conceptual sense to treat these as a single document.

Querying and working with these objects and their relationships looks and feels just like active record:

player.skills
player.skills.accuracy
player.skills.update_attributes(:accuracy => 5)
player.skills.inc(:accuracy, 1)

Benefits Outweight the Consequences

I know, I know — any time you introduce an additional system, especially a datastore, you introduce a lot of complexity, failure modes, testing, etc. But, I honestly think the benefits are worth this extra complexity. Speed, ease of development, and the potential for less schema-driven growth make this an ideal environment for me. I highly recommend it, and will be using it in the future!

More Forging Forgecraft:

• Introducing Forgecraft
• Integrating CSS3 Transitions with Javascript

What is Forgecraft?

If you’ve played bejeweled you’ve got an idea of the primary game mechanic: move gems into patterns. If you’ve played Minecraft you’ve got an idea of the gameplay twist: patterns. You’re not just matching 3, but moving ores into patterns that resemble weapons and armor. And finally, if you’ve played any loot-based game ever you’ve got an idea of reward structure: loot!

The target player is the casual player, but the game may also appeal to people who just like loot. And the target platforms are any modern web browser. Right now things are working ok in Chrome, Firefox, and Safari. Oh, and the game plays well as an installable web app on the iPad. In fact, all of the design decisions were made with this play mode in mind. Go ahead and save-to-homescreen on your iPad!

Warning: It’s rough around the edges. There’s no tutorial and there may be bugs/features just flat out missing. I consider the game’s state as ‘playable demo.’ But do let me know if you run into any bugs.

The Tech

Over the next few months I hope to put together a series of posts on the different technologies I played with while making Forgecraft. You know, go in-depth on each of them and all that jazz. For now, here’s just a run-down of the fun stuff I used:

Back End

• Hosted on Heroku (Cedar stack)
• Rails 3.1 with the asset pipeline
• MongoDB

Front End

• Haml/Sass through Compass
• Coffeescript
• jQuery
• Backbone.js
• Bootstrap from Twitter

HTML5 Buzzwords

• CSS3 Animations
• Web Audio API
• History API / Pushstate API
• iOS web-app installable

My plan is to continue developing Forgecraft, expanding the items, mines, etc. and digging further into these emergent HTML5 technologies. I also would like to continue improving performance across the board. Things can get pretty choppy on the iPad when there are a lot of animations running at the same time.

Please, give Forgecraft a try and let me know how you like it and if you have any suggestions. The number one question I have is, is it fun? A game should be fun, I’m told.

More Forging Forgecraft:

• A Hybrid SQL MongoDB Data Solution
• Integrating CSS3 Transitions with Javascript

a FREE and LEGAL compilation of over 300 games by over 100 developers! It was put together at the last minute for entry into the 2012 Independent Games Festival Main Competition.

I’ll be honest, it’s pretty dense and the fun-to-meh ratio is pretty low, haha. But, there are a few games I’ve stumbled upon in there that have neat concepts or neat execution. Here’s a package of 4 that I thought were playable at least. Grab the full torrent if you want to check them all out, otherwise grab this pack:

IGF Pirate Kart Pack 1

Perhaps my favorite of the bunch is “A Friendship in 4 Colours” by Damian Sommer. I may try to cull a few more gems out of the pack if I can find the time. Enjoy!

• Linear Algebra For Game Developers Part 1
• Part 2
• Part 3

Fortunately, Cocos2d takes care of a lot of this for you with their CGPoint Extensions. But, it’s still good to understand the basics.

The four I know of:

• Core Graphics space
• Open GL space
• Node space
• Node space relative to anchor point

I wasn’t totally clear on these going in, and I regret it. I ended up writing a lot of code that mish-mashed these and had to refactor it all.

Most likely you’re going to be processing a touch input on an iOS device and translating that to a coordinate system inside of a Cocos2d node (most likely a CCLayer) as such:


UITouch *touch = [touches anyObject];
CGPoint point = [touch locationInView: [touch view]];
CGPoint glPoint = [[CCDirector sharedDirector] convertToGL:point];
CGPoint nodePoint = [self convertTouchToNodeSpace:touch];
CGPoint nodePointAR = [self convertTouchToNodeSpaceAR:touch];


With that in mind, here’s how I understand them:

Core Graphics (point) — This is what you normally work in if you’re accustomed to iOS development with UIKit and similar APIs. CGPoint(0, 0) is in the top left corner of the screen and ascending Y values go down towards the bottom of the screen.

Open GL (glPoint) — This coordinate system has (0, 0) in the bottom left of the screen, and ascending Y values go up towards the top of the screen.

Node space (nodePoint) — This space is relative to the origin of the reference node with which you are observing the point, and follows the same rules as the Open GL system. If your node is full-screen and unshifted (e.g. a default CCLayer), this coordinate system is exactly the same as the Open GL system.

Node space relative to anchor point (nodePointAR) — In Cocos2d, the default anchor point of any node is its center point. This coordinate system is relative to that center point. If you redefine the anchor point, this system is adjusted.

The big gotcha that I ran into was that I was doing something frowned upon in Cocos2d: shifting Layers! I was then using the Node space throughout my code but expecting points to resolve to Open GL space. So, word to wise: understand these coordinate systems going in, and don’t shift the position of your Layers!

Magrath: man, Minecraft

Magrath: so nice and relaxing

Magrath: just put a game or some music on in the background and I can play for hours

Yeah, that about sums it up. There’s so much value in being able to enter that ‘zone’ that I’d gladly pay a monthly fee for it. Fortunately, we don’t have to.

Oh, and if you find yourself liking Minecraft definitely follow its creator, @notch, on Twitter. You’ll get the inside perspective on development (like this tweet about the upcoming sky dimension) as well as the random thoughts of a humble and passionate gamer.

But, I also hate it.  Spore is the type of game the industry needs – innovative, fresh, and well polished.  It’s a damn shame that publishers care more about pirating software than the fidelity of the gaming experience.

I hope this revolt affects EA’s bottom dollar so much that they realize that pissing off your customers with computer-destroying DRM is much, much more damaging than underground software pirating.  I personally will never install this game on my computer – I can’t stand hidden processes, can’t stand spyware, and can’t stand the audacity of some publisher who thinks they can get away with this trash on my computer.

Sorry to all the people who poured their creative effort into what appears to be an amazing game.

If you’re not an xbox live-er, you go grab the game at greenhouse games. I want to say they have it available for PC, Mac, and Linux but I’m not sure and too lazy to follow my own link.

I highly recommend checking this out. On XBLA it’s 1600 points but well worth it.