metro 0.2.5 → 0.2.6

data/lib/metro/models/ui/menu.rb

@@ -8,141 +8,152 @@ module Metro
     #
     # @note Only one 'menu' can be defined for a given scene
     #
+    # @example Creating a menu with basic options
+    #
+    #     menu:
+    #       model: metro::ui::menu
+    #       position: "472.0,353.0,5.0"
+    #       alpha: 0
+    #       unselected_color: "rgba(119,119,119,1.0)"
+    #       selected_color: "rgba(255,255,255,1.0)"
+    #       options: [ 'Start Game', 'Exit' ]
+    #
+    # @example Creating a menu with a selected item
+    #
+    #     menu:
+    #       model: metro::ui::menu
+    #       position: "472.0,353.0,5.0"
+    #       alpha: 0
+    #       unselected_color: "rgba(119,119,119,1.0)"
+    #       selected_color: "rgba(255,255,255,1.0)"
+    #       options:
+    #         selected: 0
+    #         items: [ 'Start Game', 'Exit' ]
+    #
+    #
+    # @example Creating a menu with complex options
+    #
+    #     menu:
+    #       model: metro::ui::menu
+    #       position: "472.0,353.0,5.0"
+    #       alpha: 0
+    #       layout: vertical
+    #       # layout: horizontal
+    #       unselected_color: "rgba(119,119,119,1.0)"
+    #       selected_color: "rgba(255,255,255,1.0)"
+    #       options:
+    #         selected: 1
+    #         items:
+    #         -
+    #           model: "metro::ui::label"
+    #           text: "Start Game"
+    #           action: start_game
+    #         -
+    #           model: metro::ui::label
+    #           text: Exit
+    #           action: exit_game
+    #
+    #
     class Menu < Model
 
       property :position, default: Game.center
+      property :alpha, default: 255
 
       property :scale, default: Scale.one
 
-      property :padding, type: :numeric, default: 40
-
-      property :unselected_color, type: :color, default: "rgba(119,119,119,1.0)"
-      property :selected_color, type: :color, default: "rgba(255,255,255,1.0)"
+      property :padding, default: 10
 
       property :dimensions do
-        width = font.text_width(longest_option_text)
-        height = options.length * font.height + (options.length - 1) * padding
-        Dimensions.of width, height
-      end
-
-      # This is a temporary method as there is no options propery yet defined
-      def options
-        properties[:options]
-      end
-
-      def alpha
-        self.unselected_color_alpha
+        Dimensions.none
       end
 
-      def alpha=(value)
-        self.unselected_color_alpha = value.floor
-        self.selected_color_alpha = value.floor
-      end
+      property :options
 
-      property :font
+      property :unselected_color, type: :color, default: "rgba(119,119,119,1.0)"
+      property :selected_color, type: :color, default: "rgba(255,255,255,1.0)"
 
-      event :on_up, KbLeft, GpLeft, KbUp, GpUp do
-        previous_option
+      def alpha_changed(alpha)
+        adjust_alpha_on_colors(alpha)
+        options.each { |option| option.alpha = alpha.floor }
       end
 
-      event :on_up, KbRight, GpRight, KbDown, GpDown do
-        next_option
+      def adjust_alpha_on_colors(alpha)
+        self.selected_color_alpha = alpha
+        self.unselected_color_alpha = alpha
       end
 
-      event :on_up, KbEnter, KbReturn, GpButton0 do
-        selection
-      end
+      property :selection_sample, type: :sample, path: "menu-selection.wav"
+      property :movement_sample, type: :sample, path: "menu-movement.wav"
 
-      attr_reader :selected_index, :menu_options
+      property :enabled, type: :boolean, default: true
 
-      def after_initialize
-        @selected_index = 0
-      end
+      # Allows the menu to be layouted out horizontal or vertical
+      property :layout, type: :text, default: "vertical"
 
-      def window=(value)
-        @window = value
-        @menu_options = options.map {|option| Option.new option }
+      def contains?(x,y)
+        bounds.contains?(x,y)
       end
 
-      def selection
-        scene_method = option_at_index(selected_index).method
-        scene.send scene_method
+      def bounds
+        Bounds.new x: x, y: y, width: width, height: height
       end
 
-      def previous_option
-        @selected_index = @selected_index - 1
-        @selected_index = options.length - 1 if @selected_index <= -1
-      end
+      # @TODO: enable the user to define the events for this interaction
+      #################################################################
 
-      def next_option
-        @selected_index = @selected_index + 1
-        @selected_index = 0 if @selected_index >= options.length
+      event :on_up, KbLeft, GpLeft, KbUp, GpUp do
+        if enabled
+          movement_sample.play
+          options.previous!
+          update_options
+        end
       end
 
-      def font
-        @font ||= Gosu::Font.new(window, Gosu::default_font_name, 20)
+      event :on_up, KbRight, GpRight, KbDown, GpDown do
+        if enabled
+          movement_sample.play
+          options.next!
+          update_options
+        end
       end
 
-      def contains?(x,y)
-        bounds.contains?(x,y)
+      event :on_up, KbEnter, KbReturn, GpButton0 do
+        if enabled
+          selection_sample.play
+          scene.send options.selected_action
+        end
       end
 
-      def bounds
-        Bounds.new x: x, y: y, width: width, height: height
-      end
+      #################################################################
 
-      def longest_option_text
-        longest = options.map {|opt| opt }.inject("") {|longest,opt| opt.length > longest.length ? opt : longest }
-      end
+      def show
+        adjust_alpha_on_colors(alpha)
 
-      def option_at_index(index)
-        menu_options[index]
-      end
+        previous_width = 0
 
-      def draw
         options.each_with_index do |option,index|
+          option.color = unselected_color
+          option.scale = scale
 
-          option_name = option_at_index(index).name
+          option_x = x + (layout == "horizontal" ? (previous_width + padding) * index : 0)
+          previous_width = option.width
+          option_y = y + (layout == "vertical" ? (option.height + padding) * index : 0)
+          option_z = z
 
-          draw_color = unselected_color
-          draw_color = selected_color if index == selected_index
+          option.position = option.position + Point.at(option_x,option_y,option_z)
 
-          y_position = y + padding * index
-          font.draw option_name, x, y_position, z_order, x_factor, y_factor, draw_color
         end
+
+        options.selected.color = selected_color
       end
 
-      #
-      # The Option represents a choice within the menu.
-      #
-      class Option
-
-        #
-        # The raw data that was used to create the option.
-        #
-        attr_reader :data
-
-        #
-        # The human readable name of the option.
-        #
-        attr_accessor :name
-
-        #
-        # The method to execute within the scene when the option is selected.
-        #
-        attr_accessor :method
-
-        def initialize(data)
-          @data = data
-
-          if data.is_a?(Hash)
-            @name = data.keys.first
-            @method = data.values.first
-          else
-            @name = data
-            @method = data.to_s.downcase.gsub(/\s/,'_').gsub(/^[^a-zA-Z]*/,'').gsub(/[^a-zA-Z0-9\s_]/,'')
-          end
-        end
+      def update_options
+        options.unselected.each { |option| option.color = unselected_color }
+        options.selected.color = selected_color
+      end
+
+      def draw
+        options.each_with_index { |label| label.draw }
       end
 
     end

data/lib/metro/models/ui/rectangle.rb

@@ -1,6 +1,17 @@
 module Metro
   module UI
 
+    #
+    # The rectangle will draw a rectangle from the specified position out to the specified
+    # dimensions in the specified color.
+    #
+    # @example Drawing a red rectangle that starts at (20,20) and is 200 by 200
+    #
+    #     class IntroScene < GameScene
+    #       draw :backdrop, model: "metro::ui::rectangle", position: "20,20",
+    #         color: "rgba(255,0,0,1.0)", dimensions: "200,200"
+    #     end
+    #
     class Rectangle < ::Metro::Model
 
       property :position
@@ -8,10 +19,19 @@ module Metro
       property :color
 
       property :dimensions do
-        # By default the dimensions of the rectangle will be the size of the window
         window.dimensions
       end
 
+      def draw
+        window.draw_quad(left_x,top_y,color,
+          right_x,top_y,color,
+          right_x,bottom_y,color,
+          left_x,bottom_y,color,
+          z_order)
+      end
+
+      private
+
       def left_x
         x
       end
@@ -28,13 +48,6 @@ module Metro
         y + height
       end
 
-      def draw
-        window.draw_quad(left_x,top_y,color,
-          right_x,top_y,color,
-          right_x,bottom_y,color,
-          left_x,bottom_y,color,
-          z_order)
-      end
     end
   end
 end

data/lib/metro/version.rb

@@ -1,5 +1,5 @@
 module Metro
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
   WEBSITE = "https://github.com/burtlo/metro"
   CONTACT_EMAILS = ["franklin.webber@gmail.com"]
   

data/spec/metro/models/properties/array_property_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Metro::Model::ArrayProperty do
+
+  subject { described_class.new model }
+  let(:model) { "model" }
+
+  describe "#get" do
+    context "when the value is nil" do
+
+      context "when no default value has been specified" do
+        let(:expected) { [] }
+
+        it "should return an empty array" do
+          subject.get(nil).should eq expected
+        end
+      end
+
+      context "when a default value has been specified" do
+        subject { described_class.new model, default: expected }
+        let(:expected) { [:default_1,:default_2] }
+
+        it "should return the specified default" do
+          subject.get(nil).should eq expected
+        end
+      end
+
+    end
+  end
+
+  describe "#set" do
+    context "when the value is nil" do
+      let(:expected) { [] }
+
+      it "should return an empty array" do
+        subject.set(nil).should eq expected
+      end
+    end
+
+    context "when the value contains symbols" do
+      let(:input) { [ :a, :b, :c ] }
+      let(:expected) { input }
+
+      it "should not convert the items to strings" do
+        subject.set(input).should eq expected
+      end
+    end
+
+    context "when the value contains numbers" do
+      let(:input) { [ 1, 5.4, 0xABAB ] }
+      let(:expected) { input }
+
+      it "should not convert the items to strings" do
+        subject.set(input).should eq expected
+      end
+    end
+
+  end
+
+end

data/spec/metro/models/properties/{font_spec.rb → font_property_spec.rb}

@@ -7,14 +7,16 @@ describe Metro::Model::FontProperty do
   let(:window) { mock('window') }
 
   describe "#get" do
+    let(:expected_font) { stub('font') }
+    let(:expected_options) { { name: expected_font_name, size: expected_font_size, window: window } }
+    
     context "when the value is nil" do
       context "when no default value has been specified" do
         let(:expected_font_name) { Gosu::default_font_name }
         let(:expected_font_size) { 40 }
-        let(:expected_font) { stub('font') }
-
+    
         it "should return the default value" do
-          described_class.stub(:create_font).with(window,expected_font_name,expected_font_size) { expected_font }
+          described_class.stub(:font_for).with(expected_options) { expected_font }
           subject.get(nil).should eq expected_font
         end
       end
@@ -26,10 +28,9 @@ describe Metro::Model::FontProperty do
 
         let(:expected_font_name) { 'Times New Roman' }
         let(:expected_font_size) { 60 }
-        let(:expected_font) { stub('font') }
 
         it "should return the specified default value" do
-          described_class.stub(:create_font).with(window,expected_font_name,expected_font_size) { expected_font }
+          described_class.stub(:font_for).with(expected_options) { expected_font }
           subject.get(nil).should eq expected_font
         end
       end
@@ -38,13 +39,11 @@ describe Metro::Model::FontProperty do
     context "when the value is a hash" do
       let(:expected_font_name) { 'Helvetica' }
       let(:expected_font_size) { 80 }
-      let(:expected_font) { stub('font') }
-
+    
       let(:font_hash) { { name: expected_font_name, size: expected_font_size } }
-
-
+    
       it "should return the font value" do
-        described_class.stub(:create_font).with(window,expected_font_name,expected_font_size) { expected_font }
+        described_class.stub(:font_for).with(expected_options) { expected_font }
         subject.get(font_hash).should eq expected_font
       end
     end
@@ -52,10 +51,9 @@ describe Metro::Model::FontProperty do
     context "when the same font is requested" do
       let(:expected_font_name) { Gosu::default_font_name }
       let(:expected_font_size) { 40 }
-      let(:expected_font) { stub('font') }
-
+    
       it "should not be created a second time (pullled from memory)" do
-        described_class.should_receive(:create_font).once.and_return(expected_font)
+        described_class.should_receive(:font_for).twice { expected_font }
         subject.get(nil)
         subject.get(nil)
       end
@@ -72,10 +70,10 @@ describe Metro::Model::FontProperty do
         let(:expected_font) { stub('font') }
 
         let(:expected_result) { { name: expected_font_name, size: expected_font_size } }
-
+        let(:expected_options) { { name: expected_font_name, size: expected_font_size, window: window } }
 
         it "should return a hash of the default value" do
-          described_class.stub(:create_font).with(window,expected_font_name,expected_font_size) { expected_font }
+          described_class.stub(:font_for).with(expected_options) { expected_font }
           subject.set(nil).should eq expected_result
         end
       end
@@ -100,7 +98,7 @@ describe Metro::Model::FontProperty do
 
       let(:gosu_font) do
         font = stub('font', name: expected_font_name, height: expected_font_size)
-        font.stub(:class) { Gosu::Font }
+        font.stub(:class) { Metro::Font }
         font
       end
 
@@ -115,11 +113,11 @@ describe Metro::Model::FontProperty do
     end
 
     context "when the value is a hash" do
-      
+
       let(:expected_font_name) { 'Wingdings' }
       let(:expected_font_size) { 33 }
       let(:expected_result) { { name: expected_font_name, size: expected_font_size } }
-      
+
       it "should return the hash representation of the font" do
         subject.set(expected_result).should eq expected_result
       end