lib/games/games.rb

   1 # Copyright (c) 2009 Paolo Capriotti <p.capriotti@gmail.com>
   2 #
   3 # This program is free software; you can redistribute it and/or modify
   4 # it under the terms of the GNU General Public License as published by
   5 # the Free Software Foundation; either version 2 of the License, or
   6 # (at your option) any later version.
   7
   8 require 'factory'
   9 require 'plugins/loader'
  10 require 'toolkit'
  11
  12 class Game
  13   GAMES = { }
  14   LOADER = PluginLoader.new
  15   # common translatable strings
  16   STRINGS = {
  17           :white => KDE::i18n('White'),
  18           :black => KDE::i18n('Black') }
  19
  20   def self.load_all(directory = nil)
  21     klasses = { }
  22     LOADER.get_all_matching(:game).each do |game|
  23       klasses[game.data(:id)] = game
  24     end
  25
  26     klasses.values.each {|klass| register_game(klasses, klass) }
  27   end
  28
  29   def self.dummy
  30     # dummy is chess for the moment
  31     get(:chess)
  32   end
  33
  34   def self.get(name)
  35     GAMES[name]
  36   end
  37
  38   def self.each(&blk)
  39     GAMES.each(&blk)
  40   end
  41
  42   def self.new_combo(parent)
  43     KDE::ComboBox.new(parent) do
  44       self.editable = false
  45       GAMES.map do |id, g|
  46         [g.class.plugin_name, id.to_s]
  47       end.sort.each do |name, id|
  48         add_item(name, Qt::Variant.new(id))
  49       end
  50     end
  51   end
  52
  53   def self.new_list(parent)
  54     games = GAMES.map do |id, g|
  55       [g.class.plugin_name, g]
  56     end.sort
  57     Qt::ListWidget.from_a(parent, games)
  58   end
  59
  60   def self.categories
  61     @@categories ||= to_enum(:each).map {|name, game| game.class.data(:category) }.uniq.sort
  62     @@categories
  63   end
  64
  65   private
  66
  67   class GameListWidgetItem < Qt::ListWidgetItem
  68     GAME_ID_ROLE = Qt::UserRole
  69
  70     def initialize(name, id, list)
  71       super(name, list)
  72       set_data(GAME_ID_ROLE, Qt::Variant.new(id))
  73     end
  74
  75     def game
  76       id = data(GAME_ID_ROLE).toString.to_sym
  77       Game.get(id)
  78     end
  79   end
  80
  81   class GameProxy
  82     def initialize(game, context)
  83       @game = game
  84       @context = context
  85     end
  86
  87     def method_missing(m, *args)
  88       result = @game.__send__(m, *args)
  89       if result.respond_to? :__bind__
  90         result.__bind__(@context)
  91       else
  92         result
  93       end
  94     end
  95   end
  96
  97   module GameExtras
  98     module ClassMethods
  99       def _load(source)
 100         instance
 101       end
 102
 103       def instance
 104         Game.get(data(:id))
 105       end
 106     end
 107
 108     def _dump(limit = -1)
 109       self.class.data(:id).to_s
 110     end
 111
 112     def self.included(base)
 113       base.extend ClassMethods
 114     end
 115
 116         def translate(word)
 117       (@strings || {})[word] ||
 118           Game::STRINGS[word] ||
 119           word.to_s.capitalize
 120         end
 121   end
 122
 123   def self.register_game(klasses, klass)
 124     unless Game.get(klass.data(:id))
 125       # register dependencies
 126       (klass.data(:depends) || []).each do |dep|
 127         depklass = klasses[dep] or
 128           raise "Invalid dependency #{dep} for game #{klass.plugin_name}"
 129         register_game(klasses, depklass)
 130         dep_game = Game.get(dep)
 131         klass.instance_eval do
 132           define_method(dep) { GameProxy.new(dep_game, self) }
 133         end
 134       end
 135       # register superclass
 136       if klasses.values.include?(klass.superclass)
 137         register_game(klasses, klass.superclass)
 138       end
 139
 140       # add extra methods
 141       klass.instance_eval { include GameExtras }
 142
 143       GAMES[klass.data(:id)] = klass.new
 144     end
 145   end
 146 end
 147