Question

I’m trying setup a Rails app that will be something like a game. The app has Users, each of which have Pawns that they can create. A User can search other users and the Pawns that they created, and challenge another one if they like, using one of their own Pawns. The challenged user can then accept/decline the challenge.

Right now I can add/delete Pawns for a User fine, and my models look like this:

class User < ActiveRecord::Base
  has_many :pawns, dependent: :destroy

and

class Pawn < ActiveRecord::Base
  belongs_to :user

Now, if User1 wants to challenge a Pawn created by User2, he looks at User2’s list of Pawns and clicks a “Challenge” button for the Pawn he wants. User1 then has to select one of his Pawns to use for the challenge and clicks save. Now User2 needs to either accept/decline the challenge.

I’m having a hard time wrapping my head around how the challenges should be setup. My thought is that each Pawn will have a self-referential many-to-many relationship, almost like a friendship relationship would be setup. However, I don’t know if I should consider the challenge something related to the User or the Pawn.

Whats the best way to model something like this?

EDIT:

Here’s a diagram of what I’m trying to accomplish. I definitley think I need some sort of association setup. Result would hold statistics of that Pawn for that Challenge (something like time_spent, clicks_made, etc.). Challenge would also have a column for winner or something similar.

Answer 1

Your challenge may have association defined for each type of pawn.

class Challenge < ActiveRecord::Base
  # attributes :challengee_id, :challenger_id

  belongs_to :challengee, class_name: "Pawn"
  belongs_to :challenger, class_name: "Pawn"

  has_many :results
end

Pawns will have associations for each type of challenge.

class Pawn < ActiveRecord::Base
  # attributes :user_id

  belongs_to :user

  has_many :results
  has_many :initiated_challenges, class_name: "Challenge", foreign_key: :challenger_id
  has_many :received_challenges, class_name: "Challenge", foreign_key: :challengee_id
end

It’s probably ok to denormalize challenge_id for the result records.

class Result < ActiveRecord::Base
  # attributes: pawn_id, challenge_id, :result
  belongs_to :pawn
  belongs_to :challenge
end

Your user can have associations to pawns and to challenges through pawns. A simple way to get both challenge types associated with a user would be to combine the results of the two challenge associations (initiated and received) into one method #challenge.

class User < ActiveRecord::Base
  has_many :pawns
  has_many :initiated_challenges, through: :pawns, source: :initiated_challenges
  has_many :received_challenges, through: :pawns, source: :received_challenges

  def challenges
    initiated_challenges + received_challenges
  end
end

Performance optimizations for this method could include denormalizing the user_ids on to Challenge as :challengee_user_id and :challenger_user_id… or caching a list of challenge ids on the user so you make one query instead of two.