The Rubygame Book Part 8

From Kibabase

WARNING: This Page is Incomplete. Last update: 2010/03/07

Now that we finished the registrar system, we can start working on the mode manager. The mode manager, if you did not remember, is supposed to manages the running of major modes such as title screen, game mode, and preferences. Thus, our objective here is to complete writing the modes manager.

Ordering of Modes

If you recall, minor modes compliment major modes with additional features, and sometime serving as modular code. Think of them as little helpers that help major modes accomplish its job.

Since it is the nature of a program to operate sequentially, we'll need to create two minor modes array. One is for before the operation of the major mode. Another is after the operation of the major mode. This will allow us to control the order of modes so that the application can run in correct order.

   Let add a couple of helper method before the test method in file: test/events/test_mode_manager.rb

    def get_modes
      return @manager.instance_variable_get(:@modes)
    end
    def get_before_modes
      return @manager.instance_variable_get(:@minor_modes_before)
    end
    def get_after_modes
      return @manager.instance_variable_get(:@minor_modes_after)
    end

   Add to this unit test method in file: test/events/test_mode_manager.rb:

    def test_initialize
      modes = get_modes()
      before = get_before_modes()
      after = get_after_modes()
      assert mode.class == Array
      assert mode.size() == 0
      assert before.class == Array
      assert after.class == Array
      assert before.size() == 0
      assert after.size() == 0
    end

After writing the unit test, try to satisfy the unit test requirement.

Here's my code.

  file: lib/events/modes_manager.rb

   class ModesManager
     def initialize
       @modes = []
       @minor_modes_before = []
       @minor_modes_after = []
     end
   end

The Minor Mode Class Type

Let create a skeleton class for minor mode since it doesn't exist yet.

 file: lib/events/minor_mode.rb

    class MinorMode < Mode
      def initialize
      end
    end

It is inheriting the mode class because it is a type of mode.

Adding Mode

Adding modes is an easy task. However, let write method for adding modes for testing purpose first.

file: test/events/test_mode_manager.rb

  def setup_mode
    test_mode = Mode.new()
    @mode_manager.add_mode([test_mode,:test])
  end
  def setup_minor_before
    test_before = MinorMode.new()
    @mode_manager.add_mode_before([test_before,:minor])
  end
  def setup_minor_after
    test_after = MinorMode.new()
    @mode_manager.add_mode_after([test_after,:minor])
  end

Just pass this unit test:

 file: test/events/test_mode_manager.rb

  def test_add
     setup_mode()
     modes = get_modes()
     assert modes.size == 1
     assert modes[0][0].class == Mode
     assert modes[0][1] == :test
  end

The reason why we have an array within an array is because we also need an identifer for each of the modes we're going to add.

Here's mine.

 file: lib/events/modes_manager.rb

  def add_mode mode
    @modes << mode
    register(mode)
  end

Methods for adding to before and after are completely identical in how they work. Add these unit tests and then write new code based on them.

  def test_add_before
    setup_minor_before()
    before = get_before_modes()
    assert before.size == 1
    assert before[0][0].class = MinorMode
    assert before[0][1] == :minor
  end

  def test_add_after
    setup_minor_after()
    after = get_after_modes()
    assert after.size == 1
    assert after[0][0].class = MinorMode
    assert after[0][1] == :minor
  end

Deleting modes

Sometime it is necesary to delete whole modes.

  def test_delete_mode
  end